【c++】——类和对象(下) 万字解答疑惑

class Date
{
public:
	Date(int year, int month, int day)
		:_year(year)
		,_month(month)
		,_day(day)
	{
 
	}
private:
	int _year;
	int _month;
	int _day;
};

为什么要有初始化列表呢？——是因为有些成员必须在初始化列表初始化。所以衍生出了初始化列表。

【注意】

1. 每个成员变量在初始化列表中最多只能出现一次(初始化只能初始化一次).

2. 类中包含以下成员，必须放在初始化列表位置进行初始化：(必须在定义的时候初始化）

• 引用成员变量

• const成员变量

成员变量实际上是在声明，在main函数中创建对象B bb(10,1)其实就是定义的过程，但是这个定义对所有的成员变量都定义了，没有给单个成员变量定义

那在哪对成员进行定义呢？？

那么我们就衍生了初始化列表：对象的成员定义的位置。（记住：有且仅一次初始化）

class B
{
public:
	//初始化列表：对象成员定义的地方
	B(int a, int ref)	
		:_n(1)
		,_ref(ref)
	{
	}
private:
	//声明
	const int _n; // const 
	int& _ref; // 引用
};
int main()
{
	//对象整体定义
	B bb(10, 1);
	return 0;
}

• 自定义类型成员(且该类没有默认构造函数时)

我们之前就学过了，自定义类型成员会自动调用默认构造函数，内置类型不会进行处理，会给个随机值

我们也可以给内置成员变量打个补丁，int x=1;这里的1是缺省值，缺省值是给初始化列表的

如果我们给x初始化，那么编译器就不会用缺省值，缺省值在大部分学c++的人叫成备胎，初始化了那么就不需要缺省值，没有初始化就需要缺省值。

如果自定义类型的成员没有默认构造函数，那么自定义类型的成员就会报错，没有合适的构造函数可用，这就需要给自定义类型的成员初始化了。

在没有默认构造函数给初始值，我们就需要在初始化列表进行定义

如果有默认构造，我们能不能再初始化列表中定义呢？——当然可以

只不过初始化列表优先处理。其实本质上默认构造里的参数也是缺省参数，如果我们给了缺省参数 ，但是初始化列表初始化了，就不需要缺省值来初始化了。所以默认构造函数(隐式）或者初始化列表(显式)都是一种初始化，但是在后来的初始化都是利用初始化列表进行初始化。

3. 尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。

自定义类型是一定要调用构造函数的，有默认构造函数没有初始化列表，就会调用默认构造函数，没有默认构造函数，就必须要使用初始化列表初始化。

所以这里的自定义类型成员变量前提是没有默认构造函数，则一定要用初始化列表初始化。

注意：初始化列表是构造函数的一部分，初始化列表严格说替代了构造函数体内赋值，以后我们就可以开始用初始化列表来初始化了。

但是我们要知道，初始化列表并不能完成初始化所有的内容，比如我们要开辟一个空间，malloc，可以这样写 :a((int*)malloc(capacity*sizeof(int)） 但是我们是不是得检查一下是否开辟空间成功？

Stack(int capacity=10)
:_a((int*)malloc(capacity*sizeof(int)))
,_top(0)
,_capacity(capacity)
{
  if(_a==nullpter)
 {
   perror("malloc fail\n");
   return -1;
 }
}

所以我们需要在函数内进行检查，初始化列表能帮我们完成95%的内容，但是还剩5%是初始化列表无法完成，上面的例子就是。

还有给数组初始化一下，我们就需要memset，calloc也需要检查.....等等

还有更多复杂的过程，就无法让初始化列表来完成的。

函数体分工就是初始化列表不方便做的。

class A
{
public:
	A(int a)
		:_a1(a)
		, _a2(_a1)
	{}
 
	void Print() {
		cout << _a1 << " " << _a2 << endl;
	}
private:
	int _a2;
	int _a1;
};
int main() {
	A aa(1);
	aa.Print();
}
 
A. 输出1 1
B.程序崩溃
C.编译不通过
D.输出1 随机值

4. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关

为什么选D呢？按照上面的特点，声明的次序就是初始化列表中的初始化顺序，成员变量就是声明的过程，所以先声明_a2，那么就先初始化_a2为_a1,那么_a1就是1，_a2就是随机值了。

就比如在上面对_a开辟空间之后，里面的_capacity就是一个随机值，随后的声明的是_capacity就会变得很大，导致了程序的崩溃，所以我们必须以后声明顺序和初始化顺序相同。

class A
{
public:
	A(int a)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}
	A(const A& aa)
		:_a(aa._a)
	{
		cout << "A(const A& aa)" << endl;
	}
private:
	int _a;
};
int main()
{
	A aa1(1);//拷贝构造
	A aa2 = 2;
	return 0;
}

int b=10;
double d=b;

A aa2=2;

class A
{
public:
 A() { ++_scount; }
 A(const A& t) { ++_scount; }
 ~A() { --_scount; }
 static int GetACount() { return _scount; }
private:
 static int _scount;
};
int A::_scount = 0;
void TestA()
{
 cout << A::GetACount() << endl;
 A a1, a2;
 A a3(a1);
 cout << A::GetACount() << endl;
}

这里就很好理解，a1,a2俩个对象，然后拷贝构造又创建一个对象，总共三个对象。

int _scount = 0;
class A
{
public:
	A() { ++_scount; }
	A(const A& t) { ++_scount; }
	~A() { --_scount; }
private:
	//static int _scount;
};
 
A aa0;
 
A Func(A aa)
{
	cout << __LINE__ << ":" << _scount << endl;
	return aa;
}
 
int main()
{
	cout << __LINE__ << ":" << _scount << endl;
	A aa1;
	static A aa2;
	Func(aa1);
	cout << __LINE__ << ":" << _scount << endl;
	return 0;
}

那上面的这段代码怎么统计呢？

那我们再来感受一下？

int _scount = 0;
class A
{
public:
	A() { ++_scount; }
	A(const A& t) { ++_scount; }
	~A() { --_scount; }
private:
	//static int _scount;
};
 
A aa0;
 
void Func()
{
	static A aa2;
	cout << __LINE__ << ":" << _scount << endl;
}
 
int main()
{
	cout << __LINE__ << ":" << _scount << endl;
	A aa1;
	Func();
	Func();
	return 0;
}

但是我们有没有发现_scount的值是可以随意修改的，这是全局变量的劣势：任何地方都是可以修改的。

那么如何让_scount封装一下呢？——就是再类中封装

我们首先要区分一下成员变量和静态成员变量的区别。

• 成员变量：属于每一个类的对象，存储在对象里面

    int _a1 = 1;
    int _a2 = 2;

• 静态成员变量——属于类，属于类的每一个对象共享。----存储在静态区

    static int _scount;

///int _scount = 0;
class A
{
public:
	A() { ++_scount; }
	A(const A& t) { ++_scount; }
	~A() { --_scount; }
 
//没有this指针，指定类域和访问限定符就可以访问
	static int GetACount() { return _scount; }
private:
	//成员变量：属于每一个类的对象，存储在对象里面
	int _a1 = 1;
	int _a2 = 2;
 
	//静态成员变量——属于类，属于类的每一个对象共享。----存储在静态区
	static int _scount;
};
 
//全局位置，类外面定义
int A::_scount = 0;
 
A aa0;
 
void Func()
{
	static A aa2;
	cout << __LINE__ << ":" <<A::GetACount()<< endl;
}
 
int main()
{
	cout << __LINE__ << ":" << A::GetACount() << endl;
	A aa1;
	Func();
	Func();
	return 0;
}

相比全局变量，静态成员就是用类来封装，让数据更规范一些。

🎓特性

• 1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区
• 2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明
• 3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问
• 4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
• 5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制
• 6.静态成员变量是不能设置缺省值的，为什么成员变量可以设置缺省值，因为成员变量有初始化列表来接收，要么初始化列表来初始化，要么缺省值给初始化然后给初始化列表，而静态成员变量没有初始化列表，所以不能给缺省值。

【问题】(非)静态调用(非)静态

• 1. 静态成员函数可以调用非静态成员函数吗？

• ---

  2. 非静态成员函数可以调用类的静态成员函数吗？

学了上面的知识我们可以看看这个题目：很好的复习了静态成员变量和静态成员函数的知识。

【题目】累加

思路：我们累加到n，那么我们就创建一个类Sum,然后我们创建n个Sum类对象，都知道，出了作用域数据就会被销毁，全局变量可以随意修改，那么我们就可以用静态成员变量来记录值。 记住：成员变量在类里声明，在类外定义。但是由于静态成员变量是私有的，我们就需要一个静态成员函数来获取该值。所以这就照应了为什么静态成员变量和静态成员函数是成套出现的，因为静态成员变量需要静态成员函数来获取。

为什么需要静态成员函数？

静态成员函数属于类，而不是对象。
由于私有静态成员无法类外访问。
有了静态成员函数之后。
在访问私有静态成员时，可以在创建对象前，通过类的静态成员函数访问静态成员

类里面不受类域和访问限定符的限制，类里面就是一个大家庭，所以调用静态是完全可以的或者访问私有函数也是可以的，所以我们就需要静态成员函数来调用了。

class Sum
{
public:
    Sum()
    {
        _ret+=_i;
        _i++;
    }
    //因为 _ret是私有的，那么我们就要用静态成员函数获取_ret的值
    static int Getret()
    {
        return _ret;
    }
private:
    static int _i;
    static int _ret;
};
 
//静态变量在类里声明，类外定义
int Sum::_i=1;
int Sum::_ret=0;
 
class Solution {
public:
    int Sum_Solution(int n) {
        Sum a[n];
        return Sum::Getret();
    }
};

我们看下面一段代码，就知道上面的一段话是什么意思了。

我们来分析一下这段代码，ostream是cout的类，我们给ostream创建一个对象_cout，我们需要_cout<

所以我们该如何改进呢？——如果我们要将operator重载成全局函数，这是非静态成员函数，那么无法访问到类中的私有成员，所以这时候我们就引入了友元的知识了。

class Date
{
	friend ostream& operator<<(ostream& _cout, const Date& d);
public:
	Date(int year, int month, int day)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
 
 
private:
	int _year;
	int _month;
	int _day;
};
 
ostream& operator<<(ostream& _cout, const Date& d)
{
	_cout << d._year << "-" << d._month << "-" << d._day << endl;
	return _cout;
}
 
int main()
{
	Date d1(2003, 10, 5);
	cout << d1 << endl;
	return 0;
}

友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。

说明 :

• 友元函数可访问类的私有和保护成员，但不是类的成员函数
• 友元函数不能用const修饰
• 友元函数可以在类定义的任何地方声明，不受类访问限定符限制
• 一个函数可以是多个类的友元函数
• 友元函数的调用与普通函数的调用原理相同

---

🎓友元类

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。

• 友元关系是单向的，不具有交换性。 比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time 类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。

class Time
{
	friend class Date; // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量
public:
	Time(int hour = 0, int minute = 0, int second = 0)
		: _hour(hour)
		, _minute(minute)
		, _second(second)
	{}
private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
 
	void SetTimeOfDate(int hour, int minute, int second)
	{
		// 直接访问时间类私有的成员变量
		_t._hour = hour;
		_t._minute = minute;
		_t._second = second;
	}
 
private:
	int _year;
	int _month;
	int _day;
	Time _t;
};

Time类没有访问Date类私有成员的权限，因为Time类声明了Date类朋友可以访问我的，但是Date类没有声明Time类可以访问。

• ---

  友元关系不能传递。 比如如果B是A的友元，C是B的友元，则不能说明C时A的友元。
• 友元关系不能继承，在继承位置再给大家详细介绍。

---

🚩内部类

概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。（就可以相较于一个工程师给画了一个图纸，工程师给另一个家庭一个福利我可以在图纸里画一下你的家里构造，不占据空间）

注意：内部类就是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。

class A
{
private:
	static int k;
	int h;
public:
	class B // B天生就是A的友元
	{
	public:
		void foo(const A& a)
		{
			cout << k << endl;//OK
			cout << a.h << endl;//OK
		}
	};
};
int A::k = 1;
int main()
{
	A::B b;
	b.foo(A());
 
	return 0;
}

特性：

• 1. 内部类可以定义在外部类的public、protected、private都是可以的。 但是如果定义在public中可以用A::访问限定符给B类创建对象，然后访问其中的私有成员，但如果内部类定义在private中是完全不可以访问任何成员变量和成员函数的，是死死封装住的。

特性一🍭内部类定义在public中：

内部类是定义在public中的
 
class A
{
private:
	static int k;
	int h;
public:
	class B // B天生就是A的友元
	{
	public:
		B()
			:m(1)
			,n(1)
		{
		}
		void foo()
		{
			cout << m << "-" << n << endl;
		}
	private:
		int m;
		int n;
	};
};
 
int A::k = 1;
int main()
{
	A::B b;
	b.foo();
	return 0;
}

特性一🍭内部类定义在private中

是完全不能访问的，是任何对象都不可以访问的

• ---

  2. 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
• 3. sizeof(外部类)=外部类，和内部类没有任何关系。

特性三🍭类大小

class A
{
private:
	static int k;
	int h;
public:
	class B // B天生就是A的友元
	{
	public:
		void foo()
		{
		}
	};
};
int A::k = 1;
int main()
{
	cout << sizeof(A) << endl;
	return 0;
}

c++很少用内部类，但是java经常用。

---

🚩匿名对象

匿名对象可以理解为没有名字的对象。

特性一🍭生命周期

有名对象 -- 生命周期在当前函数局部域   匿名对象 -- 生命周期在当前行

using namespace std;
class A
{
public:
    A(int a = 0)
        :_a(a)
    {
        cout << "A(int a)" << endl;
    }
 
    ~A()
    {
        cout << "~A()" << endl;
    }
private:
    int _a;
};
 
class Solution {
public:
    int Sum_Solution(int n) {
        cout << "Sum_Solution" << endl;
        //...
        return n;
    }
};
 
int main()
{
    A aa(1);//有名对象
    A(2);//匿名对象
 
    Solution s1;
    s1.Sum_Solution(2);//有名调用函数
 
    Solution().Sum_Solution(3);//匿名调用函数
    
    return 0;
}

A &ra=A(1);

这样就成功了

const A&ra=A(1);

你的大部分时间投入到哪里，你大概率就会成为怎样的人!