类和对象下篇

最新推荐文章于 2024-06-09 20:18:37 发布

ing.u

最新推荐文章于 2024-06-09 20:18:37 发布

阅读量1.6k

点赞数 2

分类专栏： C++ 文章标签：开发语言 c++ 1024程序员节

本文链接：https://blog.csdn.net/qq_54717101/article/details/127515923

版权

C++ 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

内容大纲：

再谈构造函数

构造函数体赋值

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

class Date
{
public:
   // 构造函数
   Date(int year = 0, int month = 1, int day = 1)
   {
       _year = year;
       _month = month;
       _day = day;
   }
private:
   int _year;
   int _month;
   int _day;
};

注：构造函数只是为变量赋初值，并不是初始化，初始化只有一次，而构造函数体内可以进行多次赋值。

初始化列表

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

class Date
{
public:
   //初始化列表
   Date(int year = 0, int month = 1, int day = 1)
       :_year(year)
       , _month(month)
       , _day(day)
   {}

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

注意：

1.每个成员变量只能在初始化列表出现一次，变量的初始化只有一次

2.类中以下几种变量，必须在初始化列表初始化。

①const修饰的成员变量，定义时必须初始化。

const int a = 10;//correct 创建时就初始化

const int b;//error 创建时未初始化

②引用成员变量,定义时必须初始化

int& b = a; //correct
int& c;//erro

class Date
{
public:
   //初始化列表

   Date(int i = 1, int d = 2)
       :_i(i)
       , _d(d)
   {
       //_i = 1;//erro,左值指定const对象,这里报错说明到构造函数体内时，成员变量已经定义出来了
   }
private:
   const int _i;
   int& _d;
};

③没有默认构造函数的自定义类型

默认构造函数：1.用户没写编译器默认生成的 2.用户写的无参的构造函数 3.用户写的全缺省构造函数

class A
{
public:
   A(int val) //这个不是默认构造函数，需要传参调用
   {
       _val = val;
   }
private:
   int _val;
};

class B
{
public:
   B()
   :_a(2021) //必须使用初始化列表对其进行初始化
   {}
private:
   A _a; //自定义类型成员且没有默认构造函数
};

3.尽量使用初始化列表初始化

初始化列表就是当你实例化一个对象时，该对象的成员变量定义的地方，无论用否，编译器都会走这个过程。

①对于内置类型，随便哪种方式都可以

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

class Time
{
public:
   Time(int hour = 0)
   {
       _hour = hour;
   }
private:
   int _hour;
};
class Test
{
public:
   // 使用初始化列表
   Test(int hour)
       :_t(12)// 只需要调用一次Time类的构造函数
   {}
private:
   Time _t;
};

使用了初始化列表，在实例化过程中只调用了一次Time类的构造函数。

若不使用初始化列表

class Time
{
public:
   Time(int hour = 0)
   {
       _hour = hour;
   }
private:
   int _hour;
};

class Test
{
public:

   Test(int hour)
   { //初始化列表调用一次Time类的构造函数（不使用初始化列表但也会走这个过程）
       Time t(hour);// 调用一次Time类的构造函数
       _t = t;// 调用一次Time类的赋值运算符重载函数
   }
private:
   Time _t;
};

在实例化过程中会先在初始化列表时调用一次Time类的构造函数，然后在实例化t对象时调用一次Time类的构造函数，最后还需要调用了一次Time类的赋值运算符重载函数，效率就不高

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

这道题的答案是什么？

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();
   return 0;
}

A . 输出 1 1

B . 程序崩溃

C . 编译不通过

D . 输出 1 随机值

答案是D，这就说明 成员变量在类中声明的次序就是其在初始化列表中的初始化顺序，这里先声明的是_a2,所以_a2先进行初始化，此时_a1是随机值，然后_a1通过a初始化，所以_a1=1，_a2=随机值。

建议读者声明与初始化列表时变量顺序保持一致。

explicit关键字

构造函数不仅可以构造和初始化对象，对于单个参数的构造函数，还支持隐式类型转换。

class Date
{
public:
Date(int year = 1)
       :_year(year)
   {

   }
   void Print()
   {
       cout << _year << endl;
   }
private:
   int _year;
};
int main()
{
   Date d1 = 2022;
   d1.Print();
   return 0;
}

在语法上，代码中Date d1 = 2022相当于以下两句代码：

Date tmp(2022);//2022构造赋值给一个临时对象

Date d1(tmp);//在调用一次拷贝构造函数

不过这是以前编译器的处理方式，现在的编译器做了优化，直接这样处理：Date d1(2022), 这也是隐式类型转换。

int a = 10;

double d = a;//这就是经典隐式类型转换。

const int& c = d;//这里引用变量c必须用const修饰，临时变量具有常性

在这个过程中，编译器会先构建一个double类型的临时变量接收a的值，然后再将该临时变量的值赋值给b

对于单参数的自定义类型来说，Date d1 = 2021这种代码的可读性不是很好，我们若是想禁止单参数构造函数的隐式转换，可以用关键字explicit来修饰构造函数。

static成员

概念：声明为static的类成员称为类的静态成员。用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化。

1.静态成员变量必须在类外定义，定义时不添加static关键字

class Pride
{
private:
static int _a;
};

int Pride::_a = 1;

静态成员变量虽然是私有，但是我们在类外突破类域直接对其进行了访问，这是唯一一个不受访问限定符的限制，否则就没办法对静态成员变量进行定义和初始化了。

2.静态成员为所以类对象所共享，不属于某个具体的对象

class Pride
{
private:
   int _b;
   static int _a;
};
int main()
{
   Pride p;
   cout << sizeof(p) << endl;//打印结果为4，不是8
}

说明静态成员变量属于整个类或者对象，计算类的大小或是类对象的大小时，静态成员并不计入其总大小之和。

3.静态成员函数没有隐藏的this指针，不能访问任何非静态成员

class Pride
{
public :
   static void PrintVal()
   {
       cout << _a;//静态成员函数仅仅可以访问静态成员变量
       cout << _b;//非静态成员变量不能访问
   }
private:
   int _b;
   static int _a;
};

说明：含有静态成员变量的类，一般含有一个静态成员函数，用于访问静态成员变量

访问静态成员变量的方法

1.当静态成员变量为公有时，有以下几种访问方式：

class Pride
{
public:
   static int _a;
};
int Pride::_a = 1;//初始化静态变量
int main()
{
   Pride p;
   cout << p._a << endl;//通过实例化对象来访问
   cout << Pride()._a << endl;//通过匿名对象来访问
   cout << Pride::_a << endl;//通过类名来访问
}

2. 当静态成员变量为私有时，有以下几种访问方式：

class Pride
{
public :
static int GetVar()
   {
       return _a;
   }
private:
   static int _a;
};
int Pride::_a = 1;
int main()
{
   Pride p;
   p.GetVar();//通过实例化对象调用成员函数访问
   Pride().GetVar();//通过匿名对象调用成员函数访问
   Pride::GetVar();//通过类名调用静态成员函数进行访问
}

静态成员和类的普通成员一样，也有public、private和protected这三种访问级别，所以当静态成员变量设置为private时，尽管我们突破了类域，也不能对其访问。

注意区分两个问题：
1.静态成员函数可以调用非静态成员函数吗？不能
2.非静态成员函数可以调用静态成员函数吗？能

原因：

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

第二问：因为静态成员函数和非静态成员函数都在类中，在类中不受访问限定符的限制。

C++11中成员初始化的新玩法

C++11支持非静态成员变量在声明时进行初始化赋值，但是要注意这里不是初始化，这里是给声明的成员变量一个缺省值。

class Pride
{
private:
int _a = 10;
int _c = 20;//缺省值
};

这就是对构造函数不处理内置类型打的一个补丁（用缺省值）

初始化列表才是成员变量定义初始化的地方，你若是给定了值，就用你所给的值对成员变量进行初始化，你若没有给值，则用缺省值进行初始化，若是没有缺省值，则内置类型的成员就是随机值。

友元

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

友元函数

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

对于之前实现的日期类，我们现在尝试重载operator<<及operator>>,但是我们并不能在类里面实现，因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置：this指针默认是第一个参数，即左操作数，但是实际使用中cout需要是第一个形参对象才能正常使用。如果在类里面实现，那么调用只能这样d<<cout，

所以我们实现成全局函数，但是全局函数不能访问类中私有成员变量，这时候就需要实现成友元函数。

class Data
{
   // 友元函数的声明，可以在类的随意位置

friend ostream& operator<<(ostream& out, const Data& d);

   friend istream& operator>>(istream& in, Data& d);
public:
   Data(int year = 0, int month = 1, int day = 1)
   {
       _year = year;
       _month = month;
       _day = day;
   }
private:
   int _year;
   int _month;
   int _day;
};
// <<运算符重载
ostream& operator<<(ostream& out, const Date& d)
{
   out << d._year << "-" << d._month << "-" << d._day<< endl;
   return out;
}
// >>运算符重载
istream& operator>>(istream& in, Date& d)
{
   in >> d._year >> d._month >> d._day;
   return in;
}

其中cout是ostream类的一个全局对象，cin是istream类的一个全局变量，<<和>>运算符的重载函数具有返回值是为了实现连续的输入和输出操作。

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

友元类

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

class A
{
   // 声明B是A的友元类
   friend class B;
public:
   A(int n = 0)
       :_n(n)
   {}
private:
   int _n;
};

class B
{
public:
   void Test(A& a)
   {
       // B类可以直接访问A类中的私有成员变量
       cout << a._n << endl;
   }
};