类与对象作为类成员

C++类中的成员可以是另一个类的对象，我们称该成员为 对象成员

class A{}
class B {
    A a;
}

B类中对象A作为成员，A为对象成员

那么当创建B对象时，A与B的构造和析构的顺序？

在之前的类里，先构造的后析构，后构造的先析构

#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;
};

int main() {
    Person p("张三","苹果");
    
    cout << p.m_Name << " " <<p.m_Phone.m_PName ;
}

 

当其他类对象作为本类成员，构造时候先构造类对象，再构造自身；析构的顺序：先构造的后析构  

静态成员

静态成员就是在成员变量和成员函数前加上关键字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 = 10;

int main() {
    Person p1;
    cout << p1.m_A << endl;; //100
    
    Person p2;
    p2.m_A = 200;
    cout << p1.m_A << endl; //200
    //静态成员变量 不属于某个对象上，所有对象都共享同一份数据
    //访问方式有两种
    //1、 通过对象访问（如上） 
    //2、 通过类名访问
    cout << Person::m_A << endl; //200 
    
    //cout << Person::m_B << endl; //无法访问 
}

静态成员函数

 

#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;

int main() { 
//    Person p;
//    p.func(); //通过对象访问
    Person::func(); //通过类名访问 （不需要创建对象） 
}