【与C++的邂逅】--- 类与对象(下)

Welcome to 9ilk's Code World

(๑•́ ₃ •̀๑) 个人主页: 9ilk

(๑•́ ₃ •̀๑) 文章专栏：与C++的邂逅

本节我们继续学习类与对象下，下面给出本节内容大纲。

🏠 再谈构造

📌 构造函数体赋值

在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值。

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

虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称为对对象中成员变量的初始化，构造函数体中的语句只能将其称为赋初值，是一种"伪初始化"，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。

📌 初始化列表

class Stack
{
public:
	Stack(size_t capacity)
	{
		//..
	}
private:
	int _top;
	int _array;
	int _size;
};

class MyQueue
{
private:
	Stack _pushst;
	Stack _popst;
	int _size;
};

int main()
{
	MyQueue q;
	return 0;
}

对于MyQueue这样的类，我们建议构造时使用编译器默认生成的构造，此时对它的自定义类型成员调用默认构造，但是Stack类中由于显示实现了有参构造，此时没有默认构造，该如何对MyQueue类对象初始化呢？

初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。

此时可以利用初始化列表进行初始化,在初始化列表中显示对自定义类型调有参构造：

MyQueue(int n) //显示写构造
 :_pushst(n),
  _popst(n),
  _size(0)
{}

对于初始化列表我们需要了解以下几点：

每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)，初始化列表本质上可以理解为每个对象中成员定义的地方(毕竟类只能在定义的时候构造).

class MyQueue
{
public:
   MyQueue(int n) //显示写构造 定义的地方
    :_pushst(n),
     _popst(n),
     _size(0)
   {}

private:  //声明
	Stack _pushst;
	Stack _popst;
	int _size;
};

类中所有成员既可以在初始化列表初始化，也可以在函数体；但以下类型必须在初始化列表初始化：

1. const成员变量。(const修饰变量只有一次初始化机会，需要在定义时给他一个值)

2. 引用成员变量。(引用定义时需要给他一个值，而且不能改变指向)

3.无默认构造的自定义类型成员。(这类成员必须显示传参调构造)

尽量使用初始化列表初始化。因为不管你是否显示写，成员变量都会走初始化列表，自定义类型调用它的默认构造。

缺省值是给初始化列表准备的。

1. 内置类型有缺省值初始化列表用缺省值，没有的话不确定，看编译器，有的编译器会处理，有的不会处理。

2. 自定义类型成员初始化列表会调用默认构造(没有默认构造会编译报错)，自定义类型成员在声明时也可以给缺省，如果初始化列表显示调用该成员构造就不用这个缺省。

初始化列表对成员变量的初始化内容可以是变量，常量，表达式，函数调用等。

int fun()
{
	return 1;
}

MyQueue(int n =1)
 :_size(n+1), //表达式 也可以是_size(fun())
  _capacity(1),//常量
  _ptr((int*)malloc(8)) 
{}

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

次序无关。

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  随机值

本题正确答案为1。

由于声明顺序即初始化列表中初始化顺序，因此会先初始化a2，此时a1还未初始化，a2就被初始化为随机值，a1正常初始化为1.

实践中我们尽可能使用初始化列表初始化，不方便再用函数体初始化。

MyQueue()
 :_size(1),
  _ptr((int*)malloc(40))
{
   memset(_ptr,1,40); //此时适合用函数体
}

对于自定义类型使用初始化列表初始化列表可以提高效率。

class B
{
public:
	B(int ab= 9)
	{
		cout << "B()" << endl;
	}
private:
	int _b = 2; //用缺省值初始化
};


class A
{
public:
	A()
	:_b(2) //初始化列表初始化 
	{}

	A(int a) //不用初始化列表初始化
	{
		B hh;
		_b = hh;
	}
	
private:
	int _a2;
	int _a1;
	B _b;
};

说明：

用初始化列表对自定义成员进行初始化，此时只会调用一次构造，无论默认构造还是其他构造。
如果想在函数体内对自定义成员初始化，无论是否显示写，都会先对自定义成员调用默认构造，再在类内调用一次构造和拷贝构造，无疑是降低效率的。

对于内置类型成员，它走不走初始化列表初始化，其初始化和赋值成本相同，但是为了一致性最好也通过初始化列表初始化。

📌explic关键字

📒 隐式类型转换

单参数隐式类型转换

class A
{
public:
 A(int a  = 2)
    :_a(a)
 {}
private: 
  int _a;
};

int main()
{
  A aa1(1);
  //拷贝构造
  A aa2 = aa1;

 //单参数隐式类型转换  内置类型->自定义类型
  A aa3 = 3;
  return 0;
}

对于aa3这个对象，直接将int转化给A类型是转不过去的；它会先用3构造出一个临时对象，再对这个临时对象进行拷贝创建aa3.我们C语言阶段对变量的赋值，比如int d = n + 3，也会产生临时变量储存运算结果。

由于产生的临时对象具有“常性”，如果要用引用介绍的话需要用const引用。

const A& a1 = 3;

好处：方便和提高代码可读性。

class Stack
{
public:
 void push(const A& aa)
 {
    //...
 }
//...
};

int main()
{
  Stack st;
  //以前是传对象
  A a1(1);
  st.push(a1);
  //现在用隐式类型转换更加清晰且减少代码量
  st.push(3);
}

多参数隐式类型转换

class A
{
public:
   A(int a1,int a2)
    :_a(0),
     _a1(a1),
     _a2(a2)
  {}

private:
   int _a;
   int _a1;
   int _a2;
};

int main()
{
 A aa1(1,2);
 A aa2 = {1,2};
 const A& aa3 = {1,2};
 return 0;
}

说明：

1. 对于aa1调用的其实是单参构造，因为逗号表达式返回的是括号最右边的结果。

2.对于aa2其实是进行了多参数的隐式类型转换，编译器用{1,2}调用了多参构造生成临时对象，再对这个临时对象进行拷贝创建新对象。

3. 对于aa3,由于临时对象具有常性，因此需要用const引用接收。

隐式类型转换与缺省值

我们前面知道缺省值是给初始化列表准备的，我们也可以在自定义类型成员声明时给缺省值，可以对他们进行隐式类型转换或者拷贝。

class B
{

private:
 A _a1 = 1; //单参隐式类型
 A _a2 = {1,2};//多参隐式类型转换
 A _a3 = _a2;//拷贝
};

📒 explicit关键字作用

我们若是想禁止构造函数的隐式转换，可以用关键字explicit来修饰构造函数。

class Date
{
public:
 // 1. 单参构造函数，没有使用explicit修饰，具有类型转换作用
 // explicit修饰构造函数，禁止类型转换---explicit去掉之后，代码可以通过编译
 explicit Date(int year)
 :_year(year)
 {}

 // 2. 虽然有多个参数，但是创建对象时后两个参数可以不传递，没有使用explicit修饰，具
有类型转换作用
 // explicit修饰构造函数，禁止类型转换
 explicit Date(int year, int month = 1, int day = 1)
   :_year(year)
   ,_month(month)
   ,_day(day)
 {}
 
 Date& operator=(const Date& d)
 {
  if (this != &d)
  {
   _year = d._year;
   _month = d._month;
   _day = d._day;
  }
  return *this;
 }

private:
 int _year;
 int _month;
 int _day;
};


void Test()
{
 Date d1(2022);
 // 用一个整形变量给日期类型对象赋值
 // 实际编译器背后会用2023构造一个无名对象，最后用无名对象给d1对象进行赋值
  d1 = 2023;
 // 将1屏蔽掉，2放开时则编译失败，因为explicit修饰构造函数，禁止了单参构造函数类型转
换的作用
}

🏠 static成员

📌static成员变量

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

静态成员不存在对象中，存在静态区

class A
{
public:
  A(){++_scount;}
  A(const A& t){ ++_scount;}
  ~A() {--_scount;}
private:
  int _a1;
  int _a2;
  static int _scount; //静态成员
};

int main()
{
  A aa1;
  cout << sizeof(aa1) << endl;
  return 0;
}

输出：8

结论：对象中只存非静态成员变量，不存静态成员和成员函数。

静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明。

class A
{
public:
  A(){++_scount;}
  A(const A& t){ ++_scount;}
  ~A() {--_scount;}
private:
  int _a1;
  int _a2;
  static int _scount; //静态成员
};

int A::_scount = 0; //定义

静态成员变量不能给缺省值，因为缺省值是给走初始化列表的成员准备的，静态成员变量不存在对象中，因此不走初始化列表，也就不能给缺省值。

静态成员也是类的成员，受public、protected、private 访问限定符的限制。
类静态成员即可用 类名::静态成员 或者 对象.静态成员来访问。

//前提是公有
//对象.静态成员
aa1._scount;
//类名::静态成员
cout << A::_scount << endl;

静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区。

应用：

//1.可以利用对象共享静态成员变量计数多少个对象被创建
A()
{
  ++_scount;
}

//2.计数有多少对象存活
~A()
{
  --_scount;
}

//3.方便我们查看是否拷贝
A(const A& t)
{
  ++_scount;
}

我们访问静态成员变量前提是它的访问权限是公有，如果它是私有，我们有什么方法对其进行访问呢？此时我们可以利用静态成员函数进行访问。

📌static成员函数

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

静态成员函数没有隐藏的this指针，不能访问任何非静态成员，它只能访问静态成员变量 。

class A
{
public:
	static int GetN()
	{
		return _n;
	}
private:
	static int _n;
};

int A::_n = 0;
int main()
{
	A a;
	cout << a.GetN() << endl; //1.通过对象调用成员函数进行访问
	cout << A().GetN() << endl; //2.通过匿名对象调用成员函数进行访问
	cout << A::GetN() << endl; //3.通过类名调用静态成员函数进行访问
	return 0;
}

注：静态成员函数能直接指定类域调用，是因为它没有this指针，不需要对象传指针。

【问题】

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

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

1. 不可以。因为非静态成员函数的第一个形参默认为this指针，而静态成员函数中没有this指针，故静态成员函数不可调用非静态成员函数。

2. 可以。因为静态成员函数和非静态成员函数都在类中，在类中不受访问限定符的限制。

构造是特殊的成员函数，静态成员函数也不能调用构造，但能间接调用。

class A
{
public:
  static A func()
 {
   return A();
 }

};

注：这里并不是在静态成员函数里调用非静态成员函数，而是通过定义一个对象间接调用构造，定义对象并不需要this指针。

🏠 友元

友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。

📌友元函数

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

class Date
{
 friend ostream& operator<<(ostream& _cout, const Date& d); //友元声明
 friend istream& operator>>(istream& _cin, Date& d);
public:
 Date(int year = 1900, int month = 1, int day = 1)
 : _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;
 return _cout; 
}
istream& operator>>(istream& _cin, Date& d)
{
 _cin >> d._year;
 _cin >> d._month;
 _cin >> d._day;
 return _cin;
}

友元函数可访问类的私有和保护成员，但不是类的成员函数。
友元函数不能用const修饰。

这是因为友元函数并不是类的成员函数，类的成员函数含有this指针，this指针才需要被const修饰。

友元函数可以在类定义的任何地方声明，不受类访问限定符限制。
一个函数可以是多个类的友元函数。
友元函数的调用与普通函数的调用原理相同。

📌友元类

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

友元关系是单向的，不具有交换性。

比如Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。

友元关系不能传递。

如果C是B的友元， B是A的友元，则不能说明C时A的友元。

友元关系不能继承。

🏠 内部类

📌概念

如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，

它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。

📌特性

内部类可以定义在外部类的public、protected、private都是可以的。
内部类和外部类是两个平行的类， 内部类并不是它的成员，内部类是个独立的类， 它仅仅是受到外部类的类域限制。

class A
{
private:
 static int k;
 int h;
public:
 void fun()
 {}
//内部类
 class B
 {
  public:
   void foo(const A & a)
   { //...}
 private:
    int _b; 
 };

};

int main()
{
  cout << sizeof(A) << endl;
  A::B b1;
}

由于内部类是独立的所以sizeof(外部类)和内部类没有任何关系，由于内部类声明在外部类，因此创建内部类对象时，需要指明外部类的类域。

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

内部类可以直接访问外部类中的static、枚举成员，不需要外部类的对象/类名。

🏠 匿名对象

📌 特点

匿名对象不需要对象名，且生命周期很短，创建完即销毁。

class Test
{
public:
 ~Test()
{
  cout << "~Test()" << endl;
}

Test()
{
 cout << "Test()" << endl;
}


};

int main()
{
 Test();
 cout << "111111111" <<endl;
}

📌 好处

void f1(const A& aa)
{}

int main()
{
//传值传参
 A aa1;
 f1(aa1);
//匿名对象
f1(A());
}

在这种场景下使用匿名对象就方便不少。

注：匿名对象也具有类似临时对象的"常性"，也需要用const引用接收。

🏠 拷贝里的编译器优化

在传参和传返回值的过程中，一般编译器会做一些优化，减少对象的拷贝，这个在一些场景下还是非常有用的。

一个表达式中，连续构造+拷贝构造->优化为一个构造。(多个式子则不会优化)

class Test
{
public:
	Test(int t = 10)
		:_t(t)
	{
		cout << "Test()" << endl;
	}
	Test(const Test& t)
	{
		cout << "Test(const Test& t)" << endl;
	} 

	~Test()
	{
		cout << "~Test()" << endl;
	}

private:
	int _t;
};

void f1(Test t)
{}

int main()
{
	Test t1;
	f1(t1);
	cout << endl;

	f1(Test(2));
	cout << endl;

	f1(2);
	cout << "111111111" << endl;
}

输出结果：

//不是一个连续表达式不优化

Test()
Test(const Test& t)
~Test()

//优化

Test()
~Test()

//优化

Test()
~Test()
111111111
~Test() //t1析构

一个表达式中，连续拷贝构造+拷贝构造->优化一个拷贝构造

A f2()
{
  A aa;
  return aa;
}

int main()
{
 A ret1 = f2();
 const A& ret2 f2();
}

注：对于ret1是一个表达式中进行连续的拷贝构造+拷贝构造会进行优化，而ret1由于是传引用传参所以不会优化。

一个表达式中，连续拷贝构造+赋值重载->无法优化

A f2()
{
  A aa;
  return aa;
}

int main()
{
  A ret;
  ret2  = f2();
  cout << endl;
  return 0;
}

此时是连续的拷贝构造+拷贝赋值重载，两者不是一个性质，所以无法进行优化。

🏠 再次理解类和对象

类是对某一类实体 ( 对象 ) 来进行描述的，描述该对象具有那 些属性，那些方法，描述完成后就形成了一种新的自定义类型，才用该自定义类型就可以实例化 具体的对象 。

本节我们更深刻关于构造函数对成员的初始化机理，以及学习了特殊的stactic成员，内部类，匿名对象和友元技术，通过这些我们更能理解类和对象之间的关系。