C++类和动态内存分配

1、动态内存和类

静态数据成员在类声明中声明，在包含类方法的文件中初始化。初始化时使用作用域运算符来指出静态成员所属类。如果静态成员是整形或枚举型const，则可以在类声明中初始化。

在构造函数中使用new来分配内存时，必须在相应的析构函数中使用delete来释放内存。如果使用new[]来分配内存，则应使用delete[]来释放内存。

class StringBad
{
private:
	char *str;
	int len;
	static int num_strings;
public:
	StringBad(const char* s);
	StringBad();
	~StringBad();
	friend std::ostream &operator<<(std::ostream &os, const StringBad &st);
};
 
int StringBad::num_strings = 0;
 
StringBad::StringBad(const char*s) {
	len = strlen(s);
	str = new char[len + 1];
	strcpy(str, s);
	num_strings++;
}
 
StringBad::StringBad()
{
	len = 4;
	str = new char[4];
	strcpy(str, "C++");
	num_strings++;
}
 
StringBad::~StringBad()
{
	num_strings--;
	delete[] str;
}
 
ostream& operator<<(ostream &os, const StringBad &st)
{
	os << st.str;
	return os;
}

上面是一个不完整的类，下面将会用这个类来做实验。

	{
		StringBad s1("headline11");
		StringBad s2 = s1;
	}

StringBad s2 = s1用的是哪个构造函数呢？不是默认构造函数，也不是const char*的构造函数。上面那种形式的初始化等效于下面的语句：

StringBad s2 = StringBad(s1);

当使用一个对象来初始化另一个对象时，编译器将自动生成上述构造函数（复制、拷贝构造函数），为它创建对象的一个副本，但是自动生成的构造函数并不知道需要更新静态变量num_string，因此会把计数搞乱，析构时会两次销毁同一块内存。

2、特殊成员函数

C++自动提供了以下成员函数：

2.1、默认构造函数

如果没有定义构造函数，编译器将会提供默认构造函数。带参数的构造函数也可以是默认构造函数，只要所有的参数都是默认值，例如如果有定义如下：

class Klunk {
public:
	Klunk() { ct = 0; };
	Klunk(int n = 0) { ct = n; };
private:
	int ct;
};
 
Klunk a(1);
Klunk b;     // error

2.2、默认析构函数

2.3、复制构造函数

如果没有定义复制构造函数，那么编译器会提供一个默认复制构造函数。复制构造函数用于将一个对象复制到新创建的对象中，它用于初始化过程中，而不是常规的赋值过程中，原型通常如：Class_name(const Class_name&)。新建一个对象并将其初始化为同类现有对象，复制构造函数将被调用，以下几种声明都会调用复制构造函数：
 

	StringBad s1;
	StringBad s2(s1);
	StringBad s3 = s2;
	StringBad s4 = StringBad(s3);
	StringBad *s5 = new StringBad(s4);

当程序产生对象副本时，都将使用复制构造函数。按值传递会创建原始变量的一个副本，所以也会调用到复制构造函数，所以传递类时应该使用引用传递。

默认复制构造函数将逐个复制非静态成员（浅复制），复制的是成员的值，所以拷贝构造函数等价如下：静态变量属于整个类，不受影响。

		StringBad s1("headline11");
        // StringBad s2 = s1;
		StringBad s2;
		s2.len = s1.len;
		s2.~StringBad = s1.str;

但是浅复制并不能解决12.1中发生的两次释放同一块内存的问题，这需要定义一个显式赋值构造函数来解决问题（深复制）。

StringBad::StringBad(const StringBad& st)
{
	num_strings++;
	len = st.len;
	str = new char[len + 1];
	strcpy(str, st.str);
}

定义复制构造函数的原因在于，一些类成员是使用new初始化的、指向数据的指针，而不是数据本身。

2.4、赋值运算符

如果没有定义赋值运算符，那么编译器会提供一个默认赋值运算符，原型如下：

Class_name & Class_name::operate=(const Class_name &)

将已有的对象赋给一个另一个对象时，将使用重载的赋值运算符。

	{
		StringBad s1("headline11");
		StringBad s2;
		s2 = s1;
        // StringBad s3 = s1;  // 拷贝构造
	}

s2 = s1使用的就是重载后的赋值运算符，而StringBad s3 = s1属于初始化，用到的拷贝构造函数。

上面的赋值运算符同样也会出问题，因为其隐式实现也是对各个成员进行逐个复制，解决的办法是提供深度复制的赋值运算符，实现方式与复制构造函数类似，但是也有差别：

由于目标对象可能引用了以前分配的数据，所以应使用delete来释放这些数据；函数应当避免将对象赋给自身，否则给对象重新赋值前，释放内存操作可能删除对象的内容；函数返回一个指向调用对象的引用。
 

StringBad& StringBad::operator=(const StringBad &st)
{
	if (this == &st)
		return *this;
	if (str != NULL)
	{
		delete[] str;
		str = NULL;
	}
	str = new char[st.len + 1];
	len = st.len;
	strncpy(str, st.str, len+1);
	return *this;
}

2.5、地址运算符

默认返回this指针指向的值

3、有关返回对象的说明

当成员函数或独立的函数返回对象时，有几种返回方式可供选择：

3.1、返回指向const对象的引用

使用const引用的常见原因旨在提高效率，如果函数返回传递给他的对象，可以通过返回引用来提高效率。返回对象将调用复制构造函数，但是返回引用并不会，所以下面例子中第二个效率会更高。

StringBad MaxLen(const StringBad& st1, const StringBad& st2)
{
	if (st1.len > st2.len)
		return st1;
	else
		return st2;
}
 
const StringBad& MaxLen2(const StringBad& st1, const StringBad& st2)
{
	if (st1.len > st2.len)
		return st1;
	else
		return st2;
}

3.2、返回指向非const对象的引用

两种常见的返回非const对象的情形是，重载赋值运算符和重载与cout一起使用的<<运算符：

StringBad& StringBad::operator=(const StringBad &st)
{
	if (this == &st)
		return *this;
	if (str != NULL)
	{
		delete[] str;
		str = NULL;
	}
	str = new char[st.len + 1];
	len = st.len;
	strncpy(str, st.str, len+1);
	return *this;
}
 
s3 = s2 = s1;

上面是一个返回非const对象引用的例子，可以通过引用避免调用复制构造函数创建一个新的对象。

3.3、返回对象

如果被返回的对象是被调用函数中的局部变量，则不应该按引用的方式返回它，因为被调用函数执行完成后，局部对象将调用其析构函数，引用指向的对象将不再存在。

StringBad operator+(const StringBad& st1, const StringBad& st2)
{
	StringBad ret;
	ret.len = st1.len + st2.len;
	if (ret.str != NULL)
	{
		delete[] ret.str;
		ret.str = NULL;
	}
	ret.str = new char[ret.len + 1];
	strncpy(ret.str, st1.str, st1.len);
	strncpy(ret.str+st1.len, st2.str, st2.len+1);
	return ret;
}
 
	{
		StringBad s1("HELLO WORLD");
		StringBad s2(" OK");
		StringBad s3;
		s3 = s1 + s2;
		cout << s3.str;
	}

上述代码创建一个临时变量ret，返回时将会调用复制构造函数创建一个调用程序能够访问的对象，接着调用赋值运算符来给s3赋值。

3.4、返回const对象

上述返回对象的代码也可如下使用：

		StringBad s1("HELLO WORLD");
		StringBad s2(" OK");
		StringBad s3;
        s1 + s2 = s3;

但这是不符合预期的，应该将+运算符重载为如下：

const StringBad operator+(const StringBad& st1, const StringBad& st2)

再进行一次总结，如果方法想要返回局部对象，则应返回对象，而不是指向对象的引用。这种情况下，将使用复制构造函数来生成返回的对象。如果方法要返回一个没有公有复制构造函数的类的对象，它必须返回一个指向这种对象的引用。如果方法可以返回对象也可以返回引用，那么首选引用。