久久婷婷五月综合色99啪ak,91精品国产高清久久久久久io,久久精品国产亚洲αv忘忧草

安全讉K��数组的指针类模板

Marcky — Thu, 13 Aug 2009 10:29:00 GMT

在用数组作�ؓ数据�l�构存储数据的时候，一不小心就讉K��界了，�q�类错误有时候很不容易发现。�ؓ此自己封装一个专门用来访问数�l�元素的指针�c�L��ѝ��此�c�L��杉K��要数�l�的元素�c�d��Q��v始地址�Q�大��来构造一个安全的Ptr2T指针对象�Q�此对象讉K��数组的方法不但与普通的指针相同�Q�同时还增加了越界的安全��查�?br>

#include <iostream>
#include <stdexcept>

using namespace std;

template<typename T>
class Ptr2T {
public:
//构造函敎ͼ�形参为数�l��v始地址和大��?/span>
    Ptr2T(T *p, int size)
        : m_p(p), m_array(p), m_size(size) { };

    Ptr2T& operator++();                //前缀++
    const Ptr2T operator++(int);        //后缀++

    Ptr2T& operator--();                //前缀--
    const Ptr2T operator--(int);        //后缀--

    Ptr2T& operator+=(int n);
    Ptr2T& operator -=(int n);
//安全的数�l�元素访问操�?/span>
    T& operator*() const;
private:
    T *m_p;           //讉K��数组的指�?/span>
    T *m_array;       //保存数组的�v始地址
    int m_size;       //保存数组的大��?/span>
};

template<typename T>
inline Ptr2T<T>& Ptr2T<T>::operator++()
{
    m_p += 1;
    return *this;
}

template<typename T>
inline const Ptr2T<T> Ptr2T<T>::operator++(int)
{
    Ptr2T current = *this;
    ++(*this);       //用重载的前缀++来实�?/span>

    return current;
}

template<typename T>
inline Ptr2T<T>& Ptr2T<T>::operator--()
{
    m_p -= 1;
    return *this;
}

template<typename T>
inline const Ptr2T<T> Ptr2T<T>::operator--(int)
{
    Ptr2T current = *this;
    --(*this);       //用重载的前缀--来实�?/span>

    return current;
}

template<typename T>
inline T& Ptr2T<T>::operator*() const
{
    if (m_p < m_array || m_p > m_array + m_size - 1) {  //��界��?/span>
        throw out_of_range("out of range");
    }

    return *m_p;
}

template<typename T>
inline Ptr2T<T>& Ptr2T<T>::operator+=(int n)
{
    m_p += n;
    return *this;
}

template<typename T>
inline Ptr2T<T>& Ptr2T<T>::operator-=(int n)
{
    m_p -= n;
    return *this;
}

template<typename T>
Ptr2T<T> operator+(const Ptr2T<T> &p, const int n)
{
    return Ptr2T<T>(p) += n;   //用重载的+=来实�?/span>
}

template<typename T>
Ptr2T<T> operator+(const int n, const Ptr2T<T> &p)
{
    return p + n;
}

template<typename T>
Ptr2T<T> operator-(const Ptr2T<T> &p, const int n)
{
    return Ptr2T<T>(p) -= n;  //用重载的-=来实�?/span>
}

//使用�Ҏ��
int main(void)
{
    char a[5] = {'a', 'b', 'c', 'd', 'e'};
    int b[5] = {1, 2, 3, 4, 5};

    Ptr2T<char> pc(a, 5);
    Ptr2T<int> pi(b, 5);

    cout << *pc++ << endl;
    pi--;
    pi += 2;
    cout << *(pi - 1) << endl;

    *++pi = 100;
    cout << *pi << endl;

    return 0;
}

Marcky 2009-08-13 18:29 发表评论

昄��构造函��C��转换�q�算�W�的合作

Marcky — Thu, 13 Aug 2009 06:39:00 GMT

在设计一个Date�cȝ��时候，我们使用int�c�d��来表�C�年份，如果我们需要对�q�䆾�q�行一些特�D�的操作�Q�如�Q�检查，保护�{�）�Q�就很需要定义一个Year�c�，如下�Q?br>

class Year {
    int m_y;
public:
//explicit限制int到Year的隐式�{�?/span>
    explicit Year(int y)
        : y(m_y) { }
//Year到int的类型�{�?nbsp;
    operator int() const
        { return m_y; }
    //other funtion
}

class Date {
public :
    Date(int d, Month m, Year y);
    //
};

Date d1(1987, feb, 21);   //error, 21不能隐式转换为Year
Date d2(21, feb, Year(1987)); //ok

在这里Year��只是包裹住了int�Q�对int提供一层保护而已。由于operator int()的存在，只要需要，Year可以隐式的�{化�ؓint出现�q�算表达式中参加�q�算。而通过�l�构造函数声明�ؓexplicit�Q�就能够保证�Q�int到Year的�{化只能在明确无误的情况进行，避免了意外的赋倹{�?br>
昄��构造函数和转换�q�算�W�的合作�Q�让Year可以当int使用�Q�同时又对Year�q�行一定的保护。。�?br>

Marcky 2009-08-13 14:39 发表评论

Allocating Arrays Using Placement new (zz)

Marcky — Wed, 12 Aug 2009 16:48:00 GMT

An additional version of operator new enables you to construct an object or an array of objects at a predetermined memory position. This version is called placement new and has many useful applications, including building a custom-made memory pool or a garbage collector. Additionally, it can be used in mission-critical applications because there's no danger of allocation failure; the memory that's used by placement new has already been allocated. Placement new is also faster because the construction of an object on a preallocated buffer takes less time.

You already know how to use placement new to allocate a single object on a predetermined memory address. However, some programming tasks require the allocation of arrays on a predetermined memory address. Here's how you do it.

Placement `new` Overview

Mobile devices, embedded systems and custom garbage collectors are only a few instances of programming environments that may require placement new allocation of arrays. Before I discuss the details of such array allocations, let's remind ourselves briefly how scalar (i.e. non-array) placement new works.

The scalar version of placement new takes a user-supplied address on which it constructs a single object. Unlike the ordinary version of the new operator, placement new doesn't allocate storage for the object; it merely constructs the object on the memory address you provide:

#include <new> //required for using placement new
class Widget {
public:
    Widget();
    virtual ~Widget
    virtual void Draw();
};
char* buf=new char [sizeof (Widget)];//preallocate
Widget* widget= new(buf) Widget; //construct Widget on buf
widget->Draw(); //use Widget

To destroy widget you first have to invoke its destructor explicitly:

widget->~Widget(); //explicit destructor invocation

Next, reclaim the raw memory like this:

delete[] buf;

Array Allocation

Allocating arrays with placement new follows the same steps more or less, but you have to pay attention to additional nuances. Here is a step-by-step guide:

First, allocate a buffer large enough to hold an array of the desired type:

const int ARRSIZE = 15;
char * buf= new [sizeof(Widget)*ARRSIZE];

Don't be tempted to calculate the size manually; always use sizeof to ensure that the buffer is properly aligned and has the right size.

Next, construct an array of ARRSIZE objects on the buffer using placement new[] :

Widget* widgets=new(buf) Widget[ARRSIZE];//construct an array

You can now use the allocated array as usual:

for (int i=0; i<ARRSIZE; i++)
{
 widgets[i].Draw();
}
Make sure that your target class --
Widget in this example -- has a public default constructor. Otherwise, it would be impossible to create arrays thereof.

Destroying the Array

To destroy such an array allocated by placement new you have to call the destructor for each element explicitly:

int i=ARRSIZE;
while (i)
widgets[--i].~Widget();

The while -loop uses a descending order to preserve the canonical destruction order of C++ -- the object that was constructed last must be destroyed first. To comply with this requirement, the element with the highest index is destroyed first.

Finally, you release the raw memory on which the array resided by calling delete[] :

delete[] buf;

Performance Tuning

The array placement new has a potential performance problem: it initializes every element in the array unconditionally. If your app deals with large arrays, this isn't the most efficient way. In some apps only a portion of the array is actually used, and in other apps the elements are assigned a different value immediately after their construction. In these cases, you want to postpone, or even completely avoid, the automatic initialization of array elements. To avoid the initialization of placement new arrays, follow the following steps:

As before, begin with an allocation of a raw buffer with the appropriate size. This time however, use the global operator new instead of the new operator:

Widget * warr=
static_cast<Widget*> (::operator new ( sizeof(Widget)* ARRSIZE));

The global operator new , very much like C's malloc() , merely allocates raw bytes of memory from the free-store, without initializing them. It returns void * rather than Widget* which is why you need to cast the result explicitly.

At this stage, warr is a pointer to raw memory. You can't access its elements because they haven't been initialized yet. To initialize individual elements, call placement new once more, for each element you want initialized:

void assign(Widget arr[], size_t & sz,  const Widget& init)
{
    new (&arr[sz++]) Widget (init); //invoke copy ctor
}

assign() passes the address of an individual element to placement new which in turn invokes Widget 's copy constructor. The copy-constructor initializes that element with init . Using this technique, you can initialize elements selectively, leaving the rest of the array uninitialized.

To destroy such an array, invoke the destructor of every initialized object. Then call the global operator delete to reclaim the raw storage:

void destroy(Widget arr[], size_t & sz)
{
    while (sz)
    {
        arr[--sz].~Widget();//destroy all initialized elements
    }
     ::operator delete (arr); //reclaim raw storage
}

Summary

The techniques I've presented here are bug prone. Therefore, they should be encapsulated in higher-level classes that hide the implementation details from users. These techniques aren't rarely-used as they might seem. STL allocators use them under the hood to avoid object initialization and minimize reallocations.

Marcky 2009-08-13 00:48 发表评论

Marcky — Sun, 12 Jul 2009 17:56:00 GMT

摘要: 复制构造函数的函数名�ؓ�cȝ��名字�Q�无�q�回��|��和构造函数的区别��在于�Ş参的不同。复制构造函数的形参为同�cȝ��型的引用�Q��ƈ且通常限定为const的引用，如Person�cȝ��复制构造函数的声明为：阅读全文

Marcky 2009-07-13 01:56 发表评论

构造函数初始化列表

Marcky — Sat, 11 Jul 2009 09:47:00 GMT

摘要: 我们定义一个如下的Person�c�：
class Person {
public:
Person() { } //default constructor function
Person(string name, string phone, string addr) 阅读全文

Marcky 2009-07-11 17:47 发表评论

Marcky — Sat, 11 Jul 2009 07:09:00 GMT

摘要: 《C++ primer》中提到“仅当�Ş参是引用或指针的时候，形参是否为const才对重蝲有媄响。�?nbsp; 阅读全文

Marcky 2009-07-11 15:09 发表评论

关于多态的有趣理解

Marcky — Sun, 05 Jul 2009 14:12:00 GMT

摘要: 在CSDN学生大本营看到如下有��的理解多�?..呵呵。。�?nbsp; 阅读全文

Marcky 2009-07-05 22:12 发表评论

NULL, 0, \0 ,nul的区�?转蝲)

Marcky — Wed, 01 Jul 2009 15:10:00 GMT

NULL is a macro defined in several standard headers, 0 is an integer constant, '\0' is a character constant, and nul is the name of the character constant. All of these are not interchangeable:

NULL is to be used for pointers only since it may be defined as ((void *)0), this would cause problems with anything but pointers.

0 can be used anywhere, it is the generic symbol for each type's zero value and the compiler will sort things out.

'\0' should be used only in a character context.

nul is not defined in C or C++, it shouldn't be used unless you define it yourself in a suitable manner, like:

#define nul '\0'

Marcky 2009-07-01 23:10 发表评论

Marcky — Tue, 30 Jun 2009 08:02:00 GMT

所谓超大数��是int, 甚至long int�{�数据类型无法直接对其存储的整数。对于这�U�超大数的加法运��，我的解决�Ҏ��是：
首先��输入的大数转化为字�W�串存储��h��Q�这样一来，字符串的首字�W�就对应着大数的最高位�Q�末字符��对应大数的最低位�?br> 然后�Q�从两个字符串的末尾开始取��Z��个字�W�，��其转化��Z��个一位整数后�q�行相加�Q�这里相加的时候还需要加上进位标志的��|��Q�这样将产生两种情况�Q?br> 一、相加后大于�{�于10�Q�需要进1位�?br> 二、相加后��于10�Q�不需要进位�?br> 待对两个字符串中的所有位字符都处理完成后�Q�就得到了一个相加的�l�果字符�Ԍ��q�个�l�果字符串的不��之处是按低位到高位的��序排列的。所以还得对光��低位的对应字�W�进行交换处理，从而得出正��的�l�果和字�W�串。。�?br>
大数相加的函数C代码如下�Q?br>

/*
*功能�Q�addBigNum函数的功能�ؓ对两个大数进行相加运��?br> *参数�Q�pa, pb指向需要相加的两个大数的字�W�串表示�?br> *          psum指向的缓冲区用来存储相加的结果和的字�W�串表示�?br> *�q�回��|��?br> */
void addBigNum(char *pa, char *pb, char *psum)
{
    int indexa, indexb, index;
    int sum, addone;

    addone = 0; //向高位进一标志
    index = 0;  //psum的位�|�烦�?br>
    //indexa, indexb分别索引到字�W�串stra, strb的最后一个字�W?/span>
    indexa = strlen(pa) - 1;
    indexb = strlen(pb) - 1;

    for ( ; indexa >= 0 || indexb >= 0; indexa--, indexb--) {
        //处理字符串长度不同的�q�算
        if (indexa >= 0 && indexb >= 0) {
            sum = (pa[indexa] - '0') + (pb[indexb] - '0') + addone;
        } else if (indexa >= 0 && indexb < 0) {
            sum = (pa[indexa] - '0') + addone;
        } else if (indexa < 0 && indexb >= 0) {
            sum = (pb[indexb] - '0') + addone;
        }

        if (sum >= 10) {
            //两个一位数�l�相加最多向高位�q?
            psum[index++] = sum - 10 + '0';
            addone = 1;
        } else {
            psum[index++] = sum + '0';
            addone = 0;
        }
    }

    psum[index] = '\0';
    swapStr(psum);

    return;
}

void swapStr(char *str)
{
    //对str指向的字�W�串中的字符�q�行逆向重排.
    int len, i;
    char temp;

    len = strlen(str);

    for (i = 0; i < len / 2; i++) {
        temp = str[i];
        str[i] = str[len - i - 1];
        str[len - i - 1] = temp;
    }
}

Marcky 2009-06-30 16:02 发表评论