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

本文主要是介绍【与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. 内置类型有缺省值初始化列表用缺省值，没有的话不确定，看编译器，有的编译器会处理，有的不会处理。

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

说明：

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

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

📌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; //定义

//前提是公有
//对象.静态成员
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;
}

这是因为友元函数并不是类的成员函数，类的成员函数含有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;
}

• 内部类可以直接访问外部类中的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;
}

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

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

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

🏠 再次理解类和对象

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

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

这篇关于【与C++的邂逅】--- 类与对象(下)的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！