C++语法学习笔记

1.构造函数和析构函数

      构造函数的作用：保证对象在创建后马上初始化，编译器会自动调用，无须码农操心；同时又提供了手动初始化的方法。

      拷贝构造函数：自定义对象在赋值，传参，返回值时，只是进行的位拷贝，没有调用构造函数；可以理解为重载的一种方式。

      析构函数的作用：保证对象在消失前对对象所占的资源马上释放，编译器会自动调用，无须码农操心；同时又提供了手动释放的方法。

2.new 和delete

    new：分配内存(malloc),调用构造函数

                new找不到足够的内存，则会new-handler的特殊函数将被调用，默认产生一个异常；如果想自己创建一个函数，不能有参数，返回值

为void；set_new_handler(new-handler)

    delete：调用析构函数，释放内存(free)，如果delete后参数是void*指针，由于无法确认其类型，所以无法调用析构函数，只能释放内存；

                   delete []( void**)，无法嵌套释放内存，只能释放存放指针的内存，指针所指向的内存无法释放，需要码农处理;delete [] ，表示指针是

数组指针，且会在某个地方读取数组的大小，对所有的元素都释放资源。

#include<iostream>
#include<cstdlib>
#include<new>
using namespace std;
int count = 0;
void out_of_memory()
{
	cerr << "memory exhausted after" << count << "al"<< endl;
}
int main()
{
	set_new_handler(out_of_memory);
	while(1){
		count++;
		new int[1000];
	}
	return 0;
}

3.new和delete重载

     new和delete重载都是成对出现的，如果二者不匹配则会调用默认的delete；

     最一般的形式
          void* operator new(size_t sz) ;
          void operator delete(void* p) ;
      数组形式:
          void* operator new[](size_t sz);
          void operator delete[](void* p) ;
      placment 形式//这种形式还不是很了解
          void* operator new(size_t sz,某种类型的指针) ;
          void operator delete(void* p,某种类型的指针) ;

附上他人言论：

根本没有所谓的delete(temp) p;这样的显视调用placement delete的操作,之所以要自己实现一个placement delete是为了与placement new对应,以便在出错的时候处理:
一般都是这样子调用placement new的,比如:

<pre name="code" class="cpp">char *temp = (char*)malloc(sizeof(test));
test *p = new(temp)test;
p->~test();
free temp;

下面是比较好的例子

#include<iostream>
#include<cstdlib>
using namespace std;
void* operator new(size_t sz)
{
	cout<< "Operator new: " << sz << endl;
	void* v = malloc(sz);
	if(!v) cout << "out of memory!" << endl;
	return v;
}
void* operator new[](size_t sz)
{
	cout<< "Operator new[]: " << sz << endl;
	void* v = malloc(sz);
	if(!v) cout << "out of memory!" << endl;
	return v;
}
void* operator new(size_t sz,int* p)
{
	cout<< "Operator new,int* p: " << sz << endl;
	void* v = malloc(sz);
	if(!v) cout << "out of memory!" << endl;
	return v;
}
void operator delete(void* m)
{
	cout << "operator delete" << endl;
	free(m);
}
void operator delete[](void* m)
{
	cout << "operator []delete" << endl;
	free(m);
}
void operator delete(void* m,int* p)
{
	cout << "operator []delete,int* p" << endl;
	free(m);
}
class S{
	int i[100];
public:
	S(){cout << "S()"<<endl;}
	~S(){cout << "~S()"<< endl;}
};
int main()
{
	cout << "create and delete an int"<< endl;
	int* i = new int(6);
	delete i;
	cout << "create and delete an int,int* p"<< endl;
	int* p = new int(6);
	int* a = new(p)int(2);
	cout << "a= " << (*a) << endl;
	delete p;
	delete a;
	cout << "create and delete an int[]"<< endl;
	int* ii = new int[4];
	delete []ii;
	cout << "create and delete an S" << endl;
	S* s = new S();
	delete s;
	cout << "create and delete S[]" << endl;
	S* ss = new S[3];
	delete []ss;
}