Q：构造函数中涉及的大量内存分配以及复杂对象变量的初始化失败应该如何处理
应该放在initialize list里面
ClassA():objb(new ClassB)
这样如果失败了一些构造好的对象也会自动析构掉
有些方法：
ClassA::ClassA()你这样根本不管用：
{
objb = new ClassB();
if(objb == NULL)
{
......
}
}
T* p1 = new T; // throws bad_alloc if it fails
T* p2 = new(nothrow) T; // returns 0 if it fails
失败的时候new的默认行为是抛出bac_alloc异常，可以参考标准
对于如下的类需要注意他的内部成员的order顺序
class myClass
{
private:
...
int m_nDataLength;
boost::shared_array<int> m_pData;
...
public:
myClass(): ..., m_nDataLength(10), m_pData(new int[m_nDataLength]), ...
{
}
}
class myClassthere will be a bug for compiler. Here is the detail reason for class member initialization: While the initialization in your example does happen in the order you want, it's not for the reason you assume: Initialization happens in the order of the data members declaration in the class definition. The reason for this is that the destructor must destroy the members in backward order not matter which constructor was used to create the object. For that, a constructor-independent way of defining the construction order must be used.
{
private:
...
boost::shared_array<int> m_pData;
int m_nDataLength;
realloc(void *ptr, size_t new_size) requires the given area of memory that ptr points to to be previously allocated by malloc(), calloc() or realloc() and not yet freed with free(), otherwise, the results are undefined.
Use realloc only with malloc, calloc or another realloc and clean it up with free.
In C++ use always new with delete and new[] with delete[].
To new is C++; To malloc is C; To mix them is sin - CodeProject
The right option is probably to use a container that does the work for you, like std::vector.
new and delete cannot resize, because they allocate just enough memory to hold an object of the given type. The size of a given type will never change. There are new[] and delete[] but there's hardly ever a reason to use them.
What realloc does in C is likely to be just a malloc, memcpy and free, anyway, although memory managers are allowed to do something clever if there is enough contiguous free memory available.
Use ::std::vector!
Type* t = (Type*)malloc(sizeof(T)*n)
memset(t, 0, sizeof(T)*m)becomes
::std::vector<T> t(n, 0);Then
t = (Type*)realloc(t, sizeof(T) * n2);becomes
t.resize(n2);If you want to pass pointer into function, instead of
Foo(t)use
Foo(&t[0])It it absolutely correct c++ code, because vector is a smart c-array.
dlleport should be the first key word for global function
#include <boost/algorithm/string.hpp>
iterator_range<string::iterator> it;
it = boost::ifind_first(strTgr, strPattern);
if (it.empty() == true)
cout<<"Not found"<<endl;
else
cout<<"Found It"<<endl;
class ComplexA
{
public:
ComplexA(int len):_l(len), _p(new char[_l]){cout<<"ComplexA::ComplexA"<<endl;}
~ComplexA(){cout<<"ComplexA::~ComplexA"<<endl; if (_p != nullptr) delete _p;}
private:
int _l;
char * _p;
};
class ComplexB
{
public:
ComplexB(int len):_l(len), _p(new char[_l]){cout<<"ComplexB::ComplexB"<<endl;}
~ComplexB(){cout<<"ComplexB::~ComplexB"<<endl; if (_p != nullptr) delete _p;}
private:
int _l;
char * _p;
};
class ComplexC
{
public:
ComplexC(int len):_l(len), _p(new char[_l]){cout<<"ComplexC::ComplexC"<<endl;}
~ComplexC(){cout<<"ComplexC::~ComplexC"<<endl; if (_p != nullptr) delete _p;}
private:
int _l;
char * _p;
};
class Wrapper
{
public:
Wrapper(int lenA, int lenB, int lenC):pA(new ComplexA(lenA)), pB(new ComplexB(lenB)), pC(new ComplexC(lenC)){cout<<"Wrapper::Wrapper"<<endl;}
~Wrapper(){cout<<"Wrapper::~Wrapper"<<endl; if (pA) delete pA; if (pB)delete pB; if (pC)delete pC;}
private:
ComplexA * pA;
ComplexB * pB;
ComplexC * pC;
};