Skip to main content

对象数组,动态对象与静态成员

对象数组​

对象数组：本质是数组，数组的每个元素是对象

class A
{
public:
    int mA;
public:
    A()
    {
        mA = 0;
        cout << "无参构造函数" << endl;
    }
    A(int a)
    {
        mA = a;
        cout << "有参构造函数" << endl;
    }
    ~A()
    {
        cout << "析构函数" << endl;
    }
};

int main()
{
    // 对象数组的每一个元素，都会自动调用构造和析构函数
    // 对象数组不初始化 每个元素 调用无参构造
    A arr1[5];

     // 对象数组的初始化，必须显示使用有参构造 逐个元素初始化
     // 析构顺序与构造顺序相反
     A arr2[5] = {A(10), A(20), A(30), A(40), A(50)}; 
     int n = sizeof(arr2)/sizeof(arr2[0]);
     int i = 0;
     for(i = 0; i < n; i ++)
     {
        cout << arr2[i].ma << " ";
     }
     cout << endl;
}

动态对象​

动态对象的创建​

当我们创建数组的时候，总是需要提前预定数组的长度，然后编译器分配预定长度的数组空间，在使用数值的时候，会有这样的问题，数组也许空间太大了，浪费空间，也许空间不足，所以对于数组来讲，如果能根据需要来分配空间就再好不过了，所以动态的意思意味着不确定性。

C++的方式创建动态数组​

当你创建一个 C++对象的时候会发生两件事

1、为对象分配内存空间

2、调用构造函数来初始化那块内存，第一步我们能保证实现，需要我们确保第二部一定能发生。C++ 强迫我们这样做是因为使用未初始化的对象是程序出错的一个重要原因。C 动态分类内存方法为了在运行时候动态分类内存，C在他的标准库中提供了一些函数，malloc 以及它的变种 calloc 和 realloc ，释放空间的函数是 free 。但是这些函数并不能自动的调用 C++ 类对象的构造函数和析构函数，所以 C++ 提供了 new 和 delete 运算符来代替 malloc 和 free 。new 和 delete 运算符的工作方式和 malloc 和 free 函数类似，但是它们会自动的调用构造函数和析构函数。

class Person{
public:
    Person()
    {
        pName = NULL;
        mAge = 0;
    }
    Person(char * name, int age)
    {
        pName = new char[strlen(name) + 1];
        strcpy(pName, name);
        mAge = age;
    }
    ~Person()
    {
        if(pName != NULL)
        {
            delete [] pName;
            pName = NULL;
        }
    }
public:
    char* pName;
    int mAge;
};

void test()
{
    Person person[] = {Person("张三", 10), Person("李四", 20), Person("王五", 30)};
    cout << person[0].pName << endl;

    // 创建堆上对象数组必须提供构造函数
    Person* workers = new Person[3];
    delete [] workers;
}

静态成员​

在类定义中，它的成员（包括成员变量和成员函数），这些成员可以用关键字 static 声明为静态的，称为静态成员。不管这个类创建了多少个对象，静态成员只有一个拷贝，这个拷贝被所有属于这个类的对象共享。

静态成员变量和函数​

static 修饰的静态成员，属于类而不是对象。

class Data
{
    int a; // 普通成员变量
    int b;
    static int d; // 静态成员变量
};

int Data::d = 100; // 不用加static


int main()
{
    // 静态成员数据，通过类名称直接访问
    cout << Data::b << endl;
    // d1 和 d2 都可以访问静态成员变量 d，且 d 只有一个拷贝
    Data d1, d2;

    d1.d = 10;;
    cout << d2.d << endl;
}

static 修饰的成员，定义类的时候 必须分配空间

static 修饰的静态成员数据，必须类中定义，类外初始化

tip

静态成员变量可以用来统计类的对象个数

// 用一个静态成员函数来统计类对象的个数
class Data
{
public:
    Data()
    {
        // 每次创建一个对象就加1
        count++; 
    }
    ~Data()
    {
        // 每次创建一个对象就减1
        count--;
    }
    static int getCount()
    {
        return count;
    }
private:
    static int count;
};