[C++基础]-类和对象(下)

前言

作者：小蜗牛向前冲

名言：我可以接受失败，但我不能接受放弃

如果觉的博主的文章还不错的话，还请 点赞，收藏，关注👀支持博主。如果发现有问题的地方欢迎❀大家在评论区指正。

本期学习内容：深入学习构造函数，重点学习Static成员，了解什么是友元，内部类，匿名对象；清楚拷贝对象时编译器会做那些优化

一、深入学习构造函数

1 构造函数赋值体

我们对一个类创建对象的时候，编译器会通过调用构造函数，给对象中每个成员变量一个合适的初始值，虽然在调用构造函数后，对象中已经有了一个初始值，但是我们不能将这称之为对对象成员的初始化，只能将其称之为赋初始值，这是因为初始化只能初始化一次，而构造函数体内可以多次赋值。

那么在类中到底怎么进行初始化呢？这就不得不提我们的初始化列表。

2 初始化列表

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

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

这里我们知道什么是初始化列表，但是在到底有什么用了，下面我们将细节讨论一下，要用初始化列表的3种情况。

3 使用初始化列表的三种情形

cosnt修饰的成员变量

对于cosnt修饰的变量只能初始化一次，而且在定义的时候必须初始化。

这里我在类A中写了构造函数，但是没有写初始化列表，编译器就报错了说我们没有对_a进行初始化，这也就说明构造函数(没有初始化列表)只能是是赋值能不能说是初始化。

引用成员变量

对于引用的成员变量，也在定义的时候要进行初始化，而仅仅简单的默认构造不能满足这个要求，所以就必须使用初始化列表来进行初始化。

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

在思考下面代码前，我们来理解一下什么是默认构造：

1 全缺省的构造函数

2 无参数的默认构造

3 我们没写编译器生成的

这里我们用下面代码来说明：

class A
{
public:
 A(int a)
 :_a(a)
 {}
private:
 int _a;
};
class B
{
public:
 B(int a, int ref)
 :_aobj(a)
 ,_ref(ref)
 ,_n(10)
 {}
private:
 A _aobj;  // 没有默认构造函数
 int& _ref;  // 引用
 const int _n; // const 
};

在类B中我定义了自定义类型A，那要对自定义类型A初始化，就要调用A的默认构造，但是我们发现A类中并没有默认构造(析构函数是半缺省的析构函数)，所以我们必须要用初始化列表对A进行初始化，否则会报错。

在知道上面这种情况必须使用初始化列表，下面我们在来看一段代码：

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

这里会出现上面结果呢?

这里我们发现_a被初始化为了1，但是_b确是随机值，这是为什么呢?

首先我们要明白，成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后 次序无关。

其次,我们上面在声明的时候是先声明_a2在声明_a1,而在初始化也要先初始化_a2,这里我们是用_a1初始化_a2的，但此时_a1是没有进行初始化自然是随机值，所以导致初始化后的_a2也是随机值，在初始化_a1的时候我们是传了一个1过去，所以_a1被初始化为1。

总结

1. 三种情况必须用初始化列表，所以我们在定义的类的时候最好写是初始化列表，一个类最好提供默认构造最好是全缺省。
2. 如果在声明的时候写了缺省值和初始化列表，初始列表优先起作用。
3. 当没有初始化列表的时候，对于内置类型有缺省值用缺省值，没有就用随机值初始化，而自定义类型就要调用默认构造函数，没有就会报错。    

4 explicit关键字

构造函数不仅可以构造与初始化对象，对于单个参数或者除第一个参数无默认值其余均有默认值 的构造函数，还具有类型转换的作用。而关键字explicit具有禁止类型转换的作用。

单参数的构造

为了更好的理解，下面我们继续来看一下代码：

   Date d1(2023);
    //隐式类型的转换
    Date d2 = 2023;
    const Date& d3 = 2023;

其中我们知道d1会调用他的构造函数进行初始化，但是d2这是怎么回事呢？

还能这样的吗？

看到这里我们很容易联想到拷贝构造的二种形式：

    //这里是拷贝构造的二种形势
    Date d4(d1);
    Date d5 = d1;

但是这里我们要区分好，其实d2就是一个直接构造得来的，这里发生隐式类型的转换(先将2023转换为日期类，然后在进行拷贝构造)，但这里编译器会进行优化为直接构造。而d3也是类似形成的。

如果我们不想发生隐式类型的转换就可以在构造函数的前面加上关键字explicit

多参数的构造（c++11支持）

int main()
{
    Date d1 = { 2022, 10, 12 };
  // 等价于
  Date d2(2022, 10, 12 );
  const Date& d3 = { 2022, 10, 12 };
  return 0;
}

但我们的构造函数有多个参数的时候，也可以写成d1上面的形式，发生隐式类型的转换。

如果我们不想发生隐私类型的转换同样可以加上explicit。

explicit Date(int year, int month, int day)//不发生隐式类型的转换
{}

二、static成员

1 定义

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

class A
{
    //静态成员函数
    static int Geta()
    {
 
    }
private:
    //静态成员变量
    static int _a;
};
//静态成员变量的初始化
int A:: _a= 1;

2 特性

那我们为什么要定义静态的成员变量和成员函数呢?

其实就是因为静态的成员变量和成员函数会有他自己的特点：

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

      这也就说明他不需要多次的创建，减少了不必要的消耗。

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

3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问

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

5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制

应用场景：要求类对象只能在栈上面

// 要求类对象只能在栈上面
class A
{
public:
  static A GetObj(int a = 0)
  {
    A aa(a);
    return aa;
  }
 
private:
  A(int a = 0)
    :_a(a)
  {}
 
private:
  int _a;
};
 
int main()
{
  A aa3 = A::GetObj(10);
  return 0;
}

三.、友元

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

简单的说友元是为了解决，类的私有变量在类外不能访问的问题。

1、友元函数

这里我们可以想到我们在实现日期类对于<<和>>的重载的时候就用到了友元，当时尝试去重载operator<<，然后发现没办法将operator<<重载成成员函数。因为cout的 输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作 数了。但是实际使用中cout需要是第一个形参对象，才能正常使用。所以要将operator<<重载成 全局函数。但又会导致类外没办法访问成员，此时就需要友元来解决。operator>>同理。

  // 友元声明（类的任意位置）
  friend ostream& operator<<(ostream& out, const Date& d);
  friend istream& operator>>(istream& in, Date& d);

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

2、友元类

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类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。 友元关系不能传递 如果C是B的友元， B是A的友元，则不能说明C时A的友元。 友元关系不能继承。

四、内部类

概念：

如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类， 它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越 的访问权限。

注意：

内部类就是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象参数来访 问外部类中的所有成员。但是外部类不是内部类的友元 ，也就是当B是A的内部类，B可以通过A的对象访问A的成员，而反过来就不可以。

特性：

1.  内部类可以定义在外部类的public、protected、private都是可以的。
2.  注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
3.  sizeof(外部类)=外部类，和内部类没有任何关系。（这里也就是说求外部类的大小时候，不包含内部类的大小）

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

五、匿名对象

C++中的匿名对象是指在创建对象时，没有将其赋值给任何变量，也没有使用任何名称引用它的对象。这种对象通常只在单个语句中使用，并且在该语句执行完成后被销毁。因为它们没有名称，所以它们只能通过创建它们的表达式来访问。例如，在以下代码中：

class A
{
public:
  A(int a = 0)
    :_a(a)
  {
    cout << "A(int a)" << endl;
  }
 
  ~A()
  {
    cout << "~A()" << endl;
  }
private:
  int _a;
};
 
int main()
{
  // 有名对象
  A aa0;
  A aa1(1);
  A aa2 = 2;
  // 匿名对象 --声明周期当前这一行
  A();
  A(3);
}

这里我们要注意，匿名对象的声明周期就在当前行，如果出来当前行就要被销毁。

那匿名对象有什么用吗？

总的来是就二点：

1 可以触发编译器的优化(下面会分析)

2 让代码看起来根据合理

  A f2()
  {
    //A aa(11);
    //return aa(11);
    //用匿名对象触发优化
    return A(11);
  }

class Solution {
public:
  int Sum_Solution(int n) {
    //...
    return n;
  }
};
 
int main()
{
  //Solution so;
  //so.Sum_Solution(10);
  //用匿名对象写起来更加舒服
  Solution().Sum_Solution(10);
  return 0;
}

六、拷贝对象时的一些编译器优化

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

下面代码的类A假设已经定义好了

场景1

int main()
{
  // 优化场景1
  A aa1 = 1;  // A tmp(1) + A aa1(tmp) -> 优化 A aa1(1)
  return 0;
}

场景1本应该先发生对1进行隐式类型转换，在进行拷贝构造，但是编译器直接优化为拷贝构造，因为隐式类型的提升也是要消耗资料的。

但是我们要注意：下面怎么写就不能进行优化了。

int main()
{
  // 优化场景1
  A aa1;
  aa1 = 10;
  return 0;
}

场景2

void f1(A aa)
{}
 
A f2()
{
  A aa;
  return aa;
}
 
A f3()
{
  /*A aa(10);
  return aa;*/
  return A(10);
}
 
int main()
{
  f1(A(1));  // 构造 + 拷贝构造  -> 优化 构造
  f1(1);  // 构造 + 拷贝构造  -> 优化 构造
  f2();   // 构造+拷贝构造
  A ret = f2(); // 构造+拷贝构造+拷贝构造 ->优化 构造+拷贝构造
  A ret = f3();  //  构造+拷贝构造+拷贝构造 -> 优化 -> 构造
  return 0;
}