C++类的静态成员、动态内存分配和复制构造函数

1.C++类

• 静态成员        

C++类中使用静态成员需要注意一下内容：

        1）在类中将成员生命为静态存储，则无论创建多少个对象，程序只创建一个静态变量副本。即类的所有对象共享一个静态成员。

2）不能在类声明中初始化静态成员变量。因为声明描述如何分配内存，但并不分配内存，需要在类声明之外使用单独的语句进行初始化，静态成员是单独存储的，而不是对象的组成部分,且初始化时，使用作用域运算符来指出静态成员所属的类。如果静态成员是const整数类型或枚举型，则可以在类声明中初始化。

例：

在类A头文件中声明静态成员number。

#include<iostream>
class A {
    private:
        static int number;
        char* str;
        int len;

    public:
        A();
        A(const char* s);
        ~A();
        friend std::ostream &operate<<(std::ostream& os, const A& m);
};

number的初始化只能在类A的源文件中初始化。

#include“a.h”
using std::cout;
int A::number = 0;

A::A()
{
    len = 4;
    str = new char[len + 1];
    std::strcpy(str, "C++");
    number++;
}

A::A(const char* s)
{
    len = std::strlen(s);
    str = new char[len + 1];
    std::strcpy(str, s);
    number++;
}

A::~A()
{
    --number;
    delete [] str;
}

std::ostream& operate<<(std::ostream &os, const A& m)
{
    os << m.str;
    return os;
}

2.内存分配 

        在构造函数中，使用strcpy()将传递的字符串复制到新的内存中，并更新对象计数。在这个过程中，必须知道字符串并不保存在对象中，单独保存在堆内存中，对象仅保存了指出到哪里去查找字符串的信息。不能按下面形式做：

str = s;

这种做法只保存了地址，而没有创建字符串副本。 且在析构函数中释放创建的内存。删除对象可以释放对象本身占用的内存，但并不能自动释放属于对象成员的指针指向的内存。在构造函数中使用new分配内存时，必须使用delete释放内存；如果使用new[]来分配内存，则应使用delete[]来释放内存。

3.复制构造函数        

        对上述类A创建一个tem对象。

A tem("i am a tem");

        现在对其执行如下操作：

A test = tem;

        这一步操作，使用的既不是默认构造函数，也不是带参数的构造函数。以上操作等同于：

A b = A(tem);

        因此产生的构造函数原型如下：

A（const A &）;

        当使用一个对象初始化另一个对象时，编译器将自动生成上述构造函数，即复制构造函数，可以创建一个对象的副本。 自动生成的复制构造函数将不执行其他操作，因此，可能出现意想不到的问题，例如，上面的操作将不会使number增加，便会导致实际的类的实例个数大于number显示的个数。

        在如下几种情形将会出现与类设计不符的行为,即C++自动提供了下面这些成员函数：

• 默认构造函数，如果没有定义构造函数；
• 默认析构函数，如果没有定义；
• 复制构造函数，如果没有定义；
• 赋值运算符，如果没有定义；
• 地址运算符，如果没有定义。

例如，将一个对象赋值给另一个对象，编译器将提供赋值运算符定义。 

        复制构造函数用于将一个对象，复制到新创建对象中，用于初始化过程，而不是常规的赋值过程。

        复制构造函数原型一般如下：

      class_name(const class_name &); 

        新建一个对象并将其初始化为同类现有对象时，复制构造函数都将被调用。例如，将新对象初始化为现有的对象。当程序生成了对象副本时，编译器都将使用复制构造函数。当函数按值传递对象或函数返回对象时，都将使用复制构造函数。编译器生成临时对象时，也将使用复制构造函数。

        在上面讲tem初始化给类A的实例b时，调用默认复制构造函数。默认的复制构造函数不说明其行为，因此，它不指出创建过程，也不增加计数值。 所以，需要定义一个显示复制构造函数来完成上面的创建过程。

        如果类的静态数据成员在新对象创建时会发生改变，则应该提供一个显示复制构造函数来完成其改变过程。

        在上面复制过程中，对于b.str = tem.str;复制的并不是字符串，而是一个指向字符串的指针。即通过 “A b = tem;”这个初始化过程，默认的复制构造函数将会导致有两个指向同一个字符串的指针，这将会导致，释放其中一个指针，将会释放字符串的存储地址，另一个未被释放的指针仍然指向该处，将会导致未被释放的指针有异常。因此，上面的过程需要定义一个现实复制构造函数：

A::A(const A& t)
{
    number++;
    len = t.len;
    str = new char[len + 1];
    std::strcpy(str, t.str);
}

         如果类中包含了使用new初始化的指针成员，应当定义一个复制构造函数，以复制指向的数据，而不是指针，称为深度复制。

         在构造函数中使用new时，需要注意以下几点：

• 如果在构造函数中使用new来初始化指针，则应在析构函数中使用delete。
• new和delete必须相互兼容。new对应delete，new[]对应delete[]。
• 如果有多个构造函数，则必须以相同的方式使用new，要么都带中括号，要么都不带。因为只有一个析构函数，所有构造函数必须兼容它。
• 应定义一个复制构造函数，通过深度复制将一个对象初始化为另一个对象。
• 应定义一个赋值运算符，通过深度复制将一个对象复制给另一个对象。