C++笔记--面向对象（OOP）编程基础(new/delete、类的静态成员、C++编译器对象管理模型分析)(3-2)

目录

new/delete

类的静态成员 static关键字

C++编译器对象管理模型分析

---

new/delete

1. new delete 操作符号c++的关键字
   malloc free函数
2. new 在堆上分配内存 delete
   new 可以分配基础类型/分配数组类型/分配对象

new基础类型 

    //new基础类型
    int *pInt1 = (int *) malloc(sizeof(int));
    *pInt1 = 1;
    free(pInt1);

    int *pInt2 = new int;
    *pInt2 = 2;
    delete pInt2;

 new数组类型

  //new数组类型
    int *pIntArr1 = (int *) malloc(10*sizeof(int));
    for(int i=0; i<10; i++) {
        pIntArr1[i] = i;
    }
    free(pIntArr1);

    int *pIntArr2 = new int(10);
    for(int i=0; i<10; i++) {
        pIntArr2[i] = i;
    }
    delete []pIntArr2;

 new对象类型

class Test {
    private:
        int a, b;
    public:
        Test(int a, int b) {
            this->a = a;
            this->b = b;
        }
        int getA() {
            return this->a;
        }
};


Test t(1, 2); //临时区分配内存
//new 对象类型 返回一个 内存首地址
//new 操作符也会自动的调用这个类的构造函数 、
//delete 自动的调用这个类的析构函数
//相当于我们程序员可以手工控制类的对象的生命周期
Test *p = new Test(1, 2);
cout << "a=" << p->getA() << endl;

注：

1. new 操作符也会自动的调用这个类的构造函数 ，delete 自动的调用这个类的析构函数 ，相当于我们程序员可以手工控制类的对象的生命周期

2. 如果通过malloc/free初始化/释放对象，则不会调用构造和析构函数

类的静态成员 static关键字

静态成员函数是属于整个类,给静态变量初始化要在类的外部

class BB {
    private:
        static int a;
        int b;
    public:
        void setA(int a) {
            this->a = a;
        }
        int getA() {
            return this->a;
        }
        static int getStaticA() {
            return a;
        }
        static void setStaticA(int _a) {
            a = _a;
        }
};
int BB::a = 1;

int main() {

    BB b1;
    BB b2;

    cout << "a=" << b1.getA() << endl;
    cout << "a=" << BB::getStaticA() << endl;

    b1.setA(2);
    cout << "a=" << b1.getA() << endl;
    cout << "a=" << BB::getStaticA() << endl;

    BB::setStaticA(3);
    cout << "a=" << b1.getA() << endl;
    cout << "a=" << BB::getStaticA() << endl;

    return 0;
}

结果  static修饰的变量，是属于类，，所有的对象都能共享用

a=1
a=1
a=2
a=2
a=3
a=3

C++编译器对象管理模型分析

1）C++类对象中的成员变量和成员函数是分开存储的

成员变量：

普通成员变量：存储于对象中，与struct变量有相同的内存布局和字节对齐方式

静态成员变量：存储于全局数据区中

成员函数：

存储于代码段中。

问题出来了：很多对象公用一块代码？代码是如何区分具体对象的那？（函数指针）

虚函数表

换句话说：int getK() const { return k; }，代码是如何区分，具体obj1、obj2、obj3对象的k值？

C++中类的普通成员函数都隐式包含一个指向当前对象的this指针。

class Test {
    
    private:
        int a;
        int b;
    public:
        Test(int a, int b) {
            this->a = a;
            this->b = b;
        } 
};

int main() {

    Test t(1, 2); // ===>Test(this, 1, 2) ===> Test(&t, 1, 2)
   
    return 0;
}

总结

1、C++类对象中的成员变量和成员函数是分开存储的。C语言中的内存四区模型仍然有效！

2、C++中类的普通成员函数都隐式包含一个指向当前对象的this指针。

3、静态成员函数、成员变量属于类