C++核心编程-类和对象III-深浅拷贝、初始化列表、静态成员、静态成员函数

深浅拷贝

浅拷贝:简单的赋值拷贝操作

深拷贝：在堆区重新申请空间，进行拷贝操作

 

class Person{
public:
    Person(int age,int height){
        m_age=age;
        m_height=new int (height);
    }
    Person(const Person &p){
        m_age=p.m_age;
        //m_height=p.m_height;编译器默认实现
        m_height=new int (*p.m_height);//深拷贝操作
    }
    int m_age;
    int *m_height;
};

！！如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题

初始化列表   初始化属性

语法： 构造函数():属性1(值1)，属性2(值2)...{}

Person(int a,int b,int c):m_A(a),m_B(b),m_C(c){}

类对象作为类成员  称该成员为对象成员

#include <iostream>
#include <string>
using namespace std;
class Phone{
public:
    Phone(string Pname){
        m_Pname=Pname;
    }
    string m_Pname;
};
class Person{
public:
    //Phone m_phone =Pname  隐式转换法
    Person(string name ,string Pname):m_name(name),m_phone(Pname){

    }
    string m_name;
    Phone m_phone;
};

void test01(){
    Person p("sansa","iphone");
    cout<<p.m_name<<p.m_phone.m_Pname<<endl;
}
int main(){
    test01();
}

当其他类对象作为本类成员，构造时先构造类对象，再构造自身；

析构顺序与构造相反。

静态成员

静态成员就是在成员变量和成员函数前加上static

静态成员变量：所有变量共享同一份数据

                         在编译阶段分配内存

                         类内声明，类外初始化

#include <iostream>
#include <string>
using namespace std;
class Person{
public:
    static int m_A;
    //静态成员变量是有访问权限的
private:
    static int m_B;
};
int Person::m_A=100;//类内声明，类外初始化
int Person::m_B=200;//类外无法访问私有静态成员变量
void test01(){
    Person p;
    cout<<p.m_A<<endl;
    Person p2;
    p2.m_A=200;//所有对象共享同一数据
    cout<<p.m_A<<endl;
}
void test02(){
    //静态成员变量 不属于某个对象上，所有对象共享同一份数据
    //因此静态成员变量有两种访问方式
    //1.通过对象进行访问
    //Person p;
    //cout<<p.m_A<<endl;
    //2.通过类名进行访问
    cout<<Person::m_A<<endl;
}
int main(){
    //test01();
    test02();
}

静态成员函数

所有对象共享同一个函数

静态成员函数只能访问静态成员变量

#include <iostream>
#include <string>
using namespace std;
class Person{
public:
    static void func(){
        m_A=100;//静态成员函数可以访问静态成员变量
        m_B=200;//静态成员函数不可以访问非静态成员变量，无法区别为哪个对象的属性
        cout<<"static void func调用"<<endl;
    }
    static int m_A;
    int m_B;
    
};
int Person::m_A=0;
void test01(){
    //1.通过对象访问
    //Person p;
    //p.func();
    //2.通过类名访问
    Person::func();
}
int main(){
    test01();
}
//静态成员函数也是有访问权限的，类外访问不到私有静态成员函数