C++(五)类和对象part 3

1.再探构造函数

        之前实现构造函数时，初始化成员变量主要使用函数体内赋值，构造函数初始化还有一种方式，就是初始化列表。具体写法：（在构造函数后）

#include<iostream>
using namespace std;
class Date
{
public:
    /*构造函数，初始化列表*/
	Date(int year = 1, int month = 1, int day = 1):_year(year),_month(month),_day(day)
	{}
	
	void Print() const
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
	
private:
	// C++11
	// 声明，缺省值->初始化列表用的
	int _year = 1;
	int _month = 1;
	int _day;
};
	
int main()
{
	Date d1(2024, 7, 14);
	d1.Print();
	
	return 0;
}

使用初始化列表时需注意：

1.  每个成员变量在初始化列表中只能出现一次，语法理解上初始化列表可以认为是每个成员变量定义初始化的地方。
2. 初始化列表中按照成员变量在类中声明顺序进行初始化，不是按初始化列表的顺序。
3.   引用成员变量，const成员变量，没有默认构造的类类型变量，必须放在初始化列表位置进行初始化，否则会编译报错。
4.  C++11支持在成员变量声明的位置给缺省值，这个缺省值主要是给没有显示在初始化列表初始化的成员使用的。
5.   尽量使用初始化列表初始化，因为那些你不在初始化列表初始化的成员也会走初始化列表，如果这个成员在声明位置给了缺省值，初始化列表会用这个缺省值初始化。如果你没有给缺省值，对于没有显示在初始化列表初始化的内置类型成员是否初始化取决于编译器，C++并没有规定。对于没有显示在初始化列表初始化的自定义类型成员会调用这个成员类型的默认构造函数，如果没有默认构造会编译错误。

      具体必须要使用初始化列表初始化变量的情况如下：

#include<iostream>
using namespace std;
class Time
{
public:
	Time(int hour):_hour(1)
	{
		cout << "Time()" << endl;
	}
private:
	int _hour;
};

class Date
{
public:
	Date(int& xx, int year, int month, int day)
		:_year(year)
		,_month(month)
		,_day(day)
		,_n(1)		//成员变量必须在初始化列表中初始化，因为它们的值一旦设定就不能改变
		,_ref(xx)	//引用必须在初始化时被绑定到一个对象，并且一旦绑定后不能再改变它所引用的对象。所以必须在初始化列表初始化
		,_t(1)		//Time类 在上面没有默认构造函数，构造函数必须传值，所以需要初始化列表
		,_ptr((int*)malloc(12))
	{
		if (_ptr == nullptr)
		{
			perror("malloc fail");
		}
		else
		{
			memset(_ptr, 0, 12);
		}
	}

private:/*声明*/
	int _year;
	int _month;
	int _day;

	// error C2512: “Time”: 没有合适的默认构造函数可用
	// error C2530 : “Date::_ref” : 必须初始化引用
	// error C2789 : “Date::_n” : 必须初始化常量限定类型的对象
	const int _n;
	int& _ref;
	Time _t;

	int* _ptr;
};

列表初始化总结：

        每个构造函数都有初始化列表:（只是显示写和不写的区别）

                每个成员都要走初始化列表
                1、在初始化列表初始化的成员 (显示写)
                2、没有在初始化列表的成员 (不显示写)
                        a、声明的地方有缺省值用缺省值
                        b、没有缺省值的情况：
                                x:内置类型，不确定，看编译器，大概率是随机值

                                y:自定义类型，调用默认构造，没有默认构造就编译报错

                3、引用 const 没有默认构造自定义 必须在初始化列表初始化

2.static成员

概念：

        用static修饰的成员变量，称之为静态成员变量。

        用static修饰的成员函数，称之为静态成员函数。

特性：

 <静态成员变量>

1. 一定要在类外进行初始化。
2. 静态成员变量为所有类对象所共享，不属于某个具体的对象，不存在对象中，存放在静态区。

<静态成员函数>

1. 静态成员函数没有this指针。
2. 静态成员函数中可以访问其他的静态成员，但是不能访问非静态的，因为没有this指针。
3. 非静态的成员函数，可以访问任意的静态成员变量和静态成员函数。
4. 突破类域就可以访问静态成员，可以通过类名::静态成员 或者 对象,静态成员 来访问静态成员变量和静态成员函数。

 <静态成员函数>用法说明： 

• 内存占用情况

先来看看静态成员变量在类的实例中是否占用内存：

_scount是正常成员变量：

#include<iostream>
using namespace std;
class A
{
public:
	A(){//构造
		++_scount;
	}
	int _scount=1;//正常成员变量
	int _a = 1;
};


int main()
{
	A a1;
	
	cout << sizeof(A) << endl;
}

 

_scount是静态成员变量： 

#include<iostream>
using namespace std;
class A
{
public:
	A(){//构造
		++_scount;
	}
	// 类里面声明
	static int _scount;    //声明静态成员变量
	int _a = 1;
};
int A::_scount=15;        //静态成员变量初始化

int main()
{
	A a1;
	cout << sizeof(A) << endl;
}

 

 

证明：静态成员变量在类的实例中不占用内存

• 类对象共享

  #include<iostream>
  using namespace std;
  class A
  {
  public:
  	A()
  	{
  		++_scount;
  	}
  
  	int GetACount()
  	{
  		return _scount;
  	}
  private:
  	// 类里面声明
  	static int _scount;
  	int _a = 1;
  };
  
  // 类外面初始化
  int A::_scount = 15;
  
  int main()
  {
  	A a1;                                //a1调用构造，_scount ++  ，16
  	cout << a1.GetACount() << endl;    
  	A a2;                                //a2调用构造，_scount ++  也就是17
  	cout << a2.GetACount() << endl;
  	
  }

  

结果表明：a1和a2是共享_scount变量的。

关于生命周期：

• 静态成员变量的生命周期与程序的整个运行时间相同。它们在程序启动时创建，并在程序终止时销毁。（类似全局变量，但它比全局变量先销毁）
• 由于静态成员变量的存在时间贯穿程序的整个执行过程，它们不受对象的创建和销毁的影响。

 <静态成员函数>用法说明：

#include<iostream>
using namespace std;
class A
{
public:
	A()
	{
		++_scount;
	}
	//静态成员函数没有this指针
	static int GetACount()
	{
		_a++;    //尝试在静态成员函数访问非静态变量
		return _scount;
	}
private:
	// 类里面声明
	static int _scount;
	int _a = 1;
};

// 类外面初始化
int A::_scount = 15;

int main()
{
	A a1; 
	cout << a1.GetACount() << endl;
	A a2;
	cout << a2.GetACount() << endl;
}

上面这段代码编译是过不了的！！！！

会报错下面正确版本

#include<iostream>
using namespace std;
class A
{
public:
	A()
	{    /*非静态的成员函数，可以访问任意的静态成员变量和静态成员函数*/
		++_scount;
	}

	//静态成员函数没有this指针
	static int GetACount()
	{
		return _scount;
	}
private:
	// 类里面声明
	static int _scount;
	int _a = 1;
};

// 类外面初始化
int A::_scount = 15;

int main()
{
	A a1; 
	cout << a1.GetACount() << endl;
	A a2;
	cout << a2.GetACount() << endl;
}

注释了_a的访问，编译正常，结果正确。

3.友元

• 友元提供了一种突破类访问限定符封装的方式，友元分为:友元函数和友元类，在函数声明或者类声明的前面加friend，并且把友元声明放到一个类的里面。
• 外部友元函数可访问类的私有和保护成员，友元函数仅仅是一种声明，他不是类的成员函数。
• 友元函数可以在类定义的任何地方声明，不受类访问限定符限制。
• 一个函数可以是多个类的友元函数。
• 友元类中的成员函数都可以是另一个类的友元函数，都可以访问另一个类中的私有和保护成员。友元类的关系是单向的，不具有交换性，比如A类是B类的友元，但是B类不是A类的友元友元类关系不能传递，如果A是B的友元，B是C的友元，但是A不是B的友元。
• 有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。

使用情况如下：（简单演示）

#include<iostream>
using namespace std;

//前置声明，都则A类中 的 友元函数声明编译器不认识B（第二参数是B类引用）
class B;

class A
{
	// 友元声明
	friend void func(const A& aa, const B& bb);
private:
	int _a1 = 1;
	int _a2 = 2;
};

class B
{
	// 友元声明
	friend void func(const A& aa, const B& bb);
private:
	int _b1 = 3;
	int _b2 = 4;
};

//func函数需要用到A和B中的成员变量
void func(const A& aa, const B& bb)
{
	cout << aa._a1 << endl;
	cout << bb._b1 << endl;
}

int main()
{
	A aa;
	B bb;
	func(aa, bb);

	return 0;
}

 

简单演示，因为友元本身不复杂，也建议少用，所以不做过多赘述。

4.内部类 

• 如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，跟定义在全局相比，他只是受外部类类域限制和访问限定符限制，所以外部类定义的对象中不包含内部类。（就是 类中再定义一个类，类的嵌套）
• 内部类默认是外部类的友元类。
• 内部类本质也是一种封装，当A类跟B类紧密关联，A类实现出来主要就是给B类使用，那么可以考虑把A类设计为B的内部类，如果放到private/protected位置，那么A类就是B类的专属内部类，其他地方都用不了。

演示：

内部类的大小：

• 内部类 B 在类 A 的定义内部，但它作为独立的类存在。因此，B 的大小不会直接影响 A 的内存大小。
• B 的对象大小和内存布局是独立于 A 的。你可以创建 B 的对象并使用它，但 B 的存在不会增加 A 的对象的内存占用。

外部类的内存大小：

• 外部类 A 的内存大小由它的成员变量决定，包括静态成员变量（_k）和非静态成员变量（_h）。
• 静态成员变量（_k）不占用每个对象的内存，因为它们属于整个类，而不是单个对象。
• 非静态成员变量（_h）则会占用每个 A 对象的内存。

内部类的内存分配：

• B 的对象内存分配和 A 的对象内存分配是独立的。
• B 对象的大小由它自己的成员变量（如 _b）决定。

#include <iostream>
using namespace std;

class A
{
private:
    static int _k;
    int _h = 1;
public:
    // 内部类
    class B
    {
    public:
        void foo(const A& a)
        {
            cout << _k << endl;     // OK, 访问静态成员变量
            cout << a._h << endl;     // OK, 访问外部类的成员变量
        }
    private:
        int _b = 1;
    };
};
int A::_k = 1;

int main()
{
    cout << sizeof(A) << endl;     // 打印外部类 A 的大小
    A::B b;                        // 创建内部类 B 的对象

    A aa;
    b.foo(aa);
    return 0;
}