C++ 类和对象（三）初始化列表，类作为对象成员和静态成员

男娘i 2022-12-21 15:50 219阅读 0赞

# C++ 类和对象（三） 初始化列表，类作为对象成员和静态成员 #

### 文章目录 ###

*  C++ 类和对象（三） 初始化列表，类作为对象成员和静态成员
 *   *  1. 初始化列表
     *  2. 类作为对象成员
     *  3. 静态成员
     *   *  1. 静态成员变量
         *  2. 静态成员函数

## 1. 初始化列表 ##

**作用：**

> C++提供初始化列表语法，来初始化属性  
> 类似构造函数也是提供初始化属性的作用一样

**语法**：

构造函数():属性1(值1), 属性2(值2) ... { 
    }

**注意：**

> 冒号的位置在构造函数的形参列表的后面，然后写属性，赋初值，属性，赋初值

**示例：**

//有参构造函数
        //Person(int age, string name)
        //{ 
        // m_age = age;
        // m_name = name;
        // cout << "调用有参构造函数" << endl;
        //}
        //列表初始化
        Person(int age, string name) : m_age(age), m_name(name)
        { 
            cout << "列表初始化" << endl;
        }

## 2. 类作为对象成员 ##

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

class A{ }
    class B
    { 
        A a;
    }

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

class Phone { 
    public:
        Phone(string brand): m_brand(brand) { 
            cout << "调用Phone 的构造函数" << endl;
        }
        ~Phone() { 
            cout << "调用Phone的析构函数" << endl;
        }
        string m_brand;
    };
    
    class Person { 
    public:
        //Phone m_brand = brand; //隐式转换法来初始化对象
        Person(string brand, int age, string  name) : m_p(brand), m_age(age), m_name(name) { 
            cout << "调用Person的构造函数" << endl;
        }
        ~Person() { 
            cout << "调用Person析构函数" << endl;
        }
        Phone m_p;
        int m_age;
        string m_name;
    };
    void func()
    { 
        Person p("apple", 18, "Jerry");
        cout << p.m_name << "is " << p.m_age << ", have a " << p.m_p.m_brand << endl;
    }

![在这里插入图片描述][20201116224553702.png_pic_center]

## 3. 静态成员 ##

静态成员就是再成员变量和成员函数前加上关键字 static， 成为静态成员

**静态成员分为：**

*  静态成员变量

1.  所有对象共享同一份数据
2.  在编译阶段分配内存
3.  类内声明， 类外初始化

*  静态成员函数

1.  所有对象共享同一个函数
2.  静态成员函数只能访问静态成员变量

### 1. 静态成员变量 ###

class Person { 
    public:
    	//1. 类内声明， 类外初始化
    	 static int m_a;
    };
    int Person::m_a = 100;
    
    void func()
    { 
    	Person p;
    	p.m_a = 100;
    	cout << p.m_a << endl;
    	//2. 所有对象访问的是用一个数据
    	Person p1;
    	p1.m_a = 200;
    	cout << p.m_a << endl;
    }

![在这里插入图片描述][20201116224652903.png_pic_center]  
**静态成员的访问方式:**  
• 通过对象进行访问  
• 通过类名进行访问

void func1()
    { 
    	//静态成员变量不属于某一个对象，所有对象共享同一份数据
    	//所以静态成员变量的访问方式有： 
    	//1. 通过对象进行访问
    	//2. 通过类进行访问
    	Person p;
    	cout << p.m_a << endl;
    	cout << Person::m_a << endl;
    }

> 同其他成员变量一样，静态成员也是有访问权限的。

### 2. 静态成员函数 ###

**两种访问方式：**  
• 通过对象  
• 通过类名

void func()
    { 
    	//两种调用方式：
    	//1. 通过对象
    	Person p;
    	p.test();
    	//2. 通过类名
    	Person::test();
    }

> 静态成员函数访问静态成员变量，  
> 但不可以访问非静态成员变量，**因为它不知道该变量是属于哪个对象的成员的**

class Person { 
    public:
    	static void test() { 
    		m_a = 100; //静态成员函数可以访问静态成员变量
    		//m_b = 100; //报错， 不能访问非静态成员变量， 以为不知道是哪个对象的成员
    		cout << "调用静态成员函数" << endl;
    	};
    
    	static int m_a;
    	int m_b;
    };
    
    int  Person::m_a = 10;

[20201116224553702.png_pic_center]: /images/20221120/ebd961704a1e4091b6bda1b4b1d6f8e4.png
[20201116224652903.png_pic_center]: /images/20221120/9e421ee40adb4dd6a212c9b61ce4097c.png