类的设计

一、构造函数：简单的类不需要构造函数，它们的结构就是它们的接口。复杂的类需要构造函数来隐藏它们内部工作方式。

二、数据成员：数据成员应该设置为私有，通过共有接口来修改、读取私有成员变量。如：

template<class T> class Vector
{
public:
	int get_length() const;
	int set_length();

private:
	int length;
}

三、无参构造函数：如果一个类有了构造函数，而你想声明该类的对象可以不必显示地初始化它们，则必须显示的写一个无参的构造函数。

四、析构函数：不是所有的类都需要析构函数，如果该类分配了资源，而这些资源又不会由成员函数自动释放，此时需要有析构函数，特别是构造函数里包含new表达式的类。

五、虚析构函数：派生类对象的基类指针执行delete表达式，基类就需要一个虚析构函数。如：

#include<iostream>
#include<string>
using namespace std;

class B{
public:
	B(){cout<<"B constucting...";}
	virtual ~B(){cout<<"B destructing....";}
private:
	string s;
};
class D:public B{
public:
	D(){cout<<"D constucting...";}
	virtual ~D(){cout<<"D destructing....";}
private:
	string t;
};
void main()
{
	B *pt=new D;
	delete pt;
}

六、复制构造函数：

1、是否需要复制构造函数，关键在于：复制该类的对象是否就相当于复制其数据成员和基类对象，如果并不相当，就需要复制构造函数。

2、 如果该类的构造函数中有分配资源，则需要一个显式的复制构造函数来管理资源。如果不是用复制构造函数，如果复制一个类的成员对象（数据成员分配资源，指针），两 个对象将会指向同一个内存，，当着两个对象销毁时，这个内存就会销毁两次。

3、如果不想用户能够复制类的对象，就声明复制构造函数（可能还有赋值操作符）为私有。如：

class Thing{
public:
	//...
private:
	Thing(const Thing&);
	Thing& operator=(const Thing&);
};

七、赋值操作符：类X的赋值由X::operator=来定义。通常，operator=应该返回一个X&,并且由return *this;结束，以保证与内建的复制操作符一致。

 赋值的过程：“先释放旧值，再赋值”。

#include<string>
class String{
public:
	String& operator=(const String& s);
private:
	char* data;
};
//方法一：避免赋值给本身
String& String::operator=(const String& s)
{
	if(&s != this)
	{
		delete[] data;
		data = new char[strlen(s.data)+1];
		strcpy(data,s.data);
	}
	return *this;
}
//方法二：将旧的目标值保存下来，直到原值赋值完成
String& String::operator=(const String& s)
{
	char* newdata = new char[strlen(s.data)+1];
	strcpy(newdata,s.data);
	delete[] data;
	data = newdata;
	return *this;
}

注：一个成员函数确定不需要修改它的对象，就应该定义为const;

八、构造函数的单件模式：对于某些用途的类，必须确保在程序运行过程中最多只有一个实例。单件模式很适合这种场合。
单件模式实现的技巧是将构造函数私有化，这样就禁止了直接定义对象变量和用new生成对象。但将构造函数设为私有的话，又如何去生成那个唯一的对象呢？

class Singleton{
    private:
        Singleton(){
            // more code
        }
        static Singleton *thisInstance;
        // more code
    public:
        static Singleton *getInstance();
        // more code
};
Singleton *Singleton::thisInstance=NULL;
Singleton *Singleton::getInstance(){
    if (thisInstance==NULL)
        thisInstance=new Singleton();
    return thisInstance;
}

如此一来，要取得Singleton的实例，只能用getInstance函数。getInstance函数必须是静态（Static）的，这样才能在还没有实例的时候使用这个函数。而getInstance又是Singleton类里的函数，当然是可以在其中使用new来生成对象了。所以说虽然将类的构造函数私有化了，但构造函数本身还是有意义的，它会在构建第一个，也是唯一一个实例的时候执行。同时，保证了不会出现多于一个的实例。