Welcome to 9ilk's Code World

       

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

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

---

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

---

🏠 再谈构造

📌 构造函数体赋值

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

。

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

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

<code>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.

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

<code>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引用。

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

}

📌 好处

<code>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析构

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

<code>A f2()

{

A aa;

return aa;

}

int main()

{

A ret1 = f2();

const A& ret2 f2();

}

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

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

<code>A f2()

{

A aa;

return aa;

}

int main()

{

A ret;

ret2 = f2();

cout << endl;

return 0;

}

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

🏠 再次理解类和对象

类是对某一类实体

(

对象

)

来进行描述的，描述该对象具有那

些属性，那些方法，描述完成后就形成了一种新的自定义类型，才用该自定义类型就可以实例化

具体的对象

。

---

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