【C++】：类和对象(下)-阿里云开发者社区

一，再谈构造函数

这个语法其实是对前面的构造函数的补充。最重要的是初始化列表的使用，及其特性，隐式类型转换，还有当前阶段需要了解的 explicit 关键字。

1.初始化列表

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

1.1 初始化列表的使用

当我们实现一个MyQueue(用两个栈模拟一个队列)时，如果栈不具备默认构造，MyQueue也无法生成默认构造，此时MyQueue要显示实现默认构造。

如何实现呢？必须用初始化列表。

初始化列表的本质：可以理解为每个对象中成员定义的地方。

typedef int DataType;
class Stack
{
public:
  Stack(size_t capacity )
  {
    _array = (DataType*)malloc(sizeof(DataType) * capacity);
    if (NULL == _array)
    {
      perror("malloc申请空间失败!!!");
      return;
    }
    _capacity = capacity;
    _size = 0;
  }
  void Push(DataType data)
  {
    // CheckCapacity();
    _array[_size] = data;
    _size++;
  }
  ~Stack()
  {
    if (_array)
    {
      free(_array);
      _array = NULL;
      _capacity = 0;
      _size = 0;
    }
  }
private:
  DataType* _array;
  int _capacity;
  int _size;
};
class MyQueue
{
public:
    //初始化列表
  MyQueue(int n= 20)
    :_pushst(n)//自定义类型会调用构造函数
    , _popst(n)
    //, _size(0) //ok
  {
    //函数体内
    _size = 0;//ok
  }
private:
  //声明
  Stack _pushst;
  Stack _popst;
  int _size;
};
int main()
{
  MyQueue q1(10);
  MyQueue q2;//有缺省值时可以不用赋值，没传默认用缺省值
  return 0;
}

1.2 有些变量只能在初始化列表中初始化，不能在函数体中初始化。

(1) const 成员变量；

const 成员变量必须在定义的地方初始化，因为它只有一次初始化机会。或是在声明时用缺省值。

(2) 引用成员变量；

引用也必须在定义的时候初始化。

(3) 没有默认构造的自定义类型成员。

因为没有默认构造时，必须显式传参调用构造函数。

class MyQueue
{
public:
  MyQueue(int n,int& rr)//这里也可以写缺省值
    :_pushst(n)//自定义类型会调用构造函数
    , _popst(n)
    //, _size(0) //ok
    ,_x (1)
    ,_ref(rr)
  {
    //函数体内
    _size = 0;//ok
    //_x =1; //err
  }
private:
  //声明
  Stack _pushst;
  Stack _popst;
  int _size;
  //const变量必须在定义的时候初始化。因为它只有一次初始化的机会
  const int _x;
  const int _x = 10;//在这里给缺省值ok
    
  //引用变量必须在定义的时候初始化
  int& _ref;
};
int main()
{
  int xx = 0;
  MyQueue q1(10,xx);
  MyQueue q1(10);
  int& aa = xx;
  return 0;
}

1.3 初始化列表，不管你写不写，每个成员变量都会先走一遍，此时自定义类型的成员会调用默认构造(没有默认构造就编译报错)，内置类型看编译器，有点会处理，有的不会处理。

1.4 在C11中我们知道可以在成员变量声明时给缺省值，实际上这个缺省值就是给初始化列表用的。但是与此同时，如果在初始化列表中给定了值，就以列表中的为准，与缺省值无关。

class MyQueue
{
public:
  //实践总结：尽可能使用初始化列表初始化，不方便再使用函数体初始化
  MyQueue()
    :_pushst(10)
    ,_ptr((int*)malloc(40)) //ok
  {
    _size = 2;
  }
private:
  //声明
  Stack _pushst;
  Stack _popst;
  
    //这里的缺省值是1，但是初始化列表中是2，此时_size = 2
  int _size = 1;
  int* _ptr;
};

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

比如下面的代码，运行结果是：1 ，随机值。

这是因为先声明的是_a2 ，所以在初始化时会先走_a2(_a1)这条语句，而此时_a1没有初始化，是随机值，所以_a2是随机值。再初始化_a1。

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

2. 隐式类型转换的过程及其优化

隐式类型转换：把内置类型转换为自定义类型。

优化：在一个表达式中，编译器遇到构造 + 拷贝构造时，会优化成直接构造。

class A
{
public:
  //单参数构造函数
  A(int a)
    :_a(a)
  {
    cout << "A(int a)" << endl;
  }
  //拷贝构造
  A(const A& aa)
    :_a(aa._a)
  {
    cout << "A(const A& aa)" << endl;
  }
private:
  int _a;
};
int main()
{
  A aa1(1);
  //拷贝构造
  A aa2 = aa1;//ok
  
  //过程：先用3构造了一个A的临时对象，再用临时对象去拷贝构造给aa3
  //优化：在一个表达式中，编译器遇到构造 + 拷贝构造，会优化成直接构造
  A aa3 = 3;
  //A& raa = 4;//err
  
  //当用引用时，由于用3构造了一个临时对象，临时对象具有常性，所以加const
  //过程：这里只用3构造了一个临时对象，没有拷贝构造
  
  //raa引用的是类型转换中用3构造的临时对象
  const A& raa = 4;//ok
  return 0;
}

3. 隐式类型转换的使用

在C++初阶，隐式转换使用的较少，但是在以后是很有用的，使用起来很方便，简洁。

class A
{
public:
  A(int a)
    :_a1(a)
    , _a2(_a1)
  {}
  void Print()
  {
    cout << _a1 << " " << _a2 << endl;
  }
private:
  int _a2;
  int _a1;
};
class Stack
{
public:
  //方式1：ok
  //void Push(A& aa)
  //{
  //  //.......
  //} 
  //方式2：ok
  void Push(const A& aa)
  {
    //....
  }
  //.....
};
int main()
{
  Stack st;
  //方式1：会进行先构造，后拷贝构造
  A a1(1);
  st.Push(a1);
  //方式2：10进行了隐式类型转换，时代码更简洁
  st.Push(10);
  return 0;
}

4. explcit关键字

作用：禁止构造函数的隐式转换。

看看下面的代码，如果在构造函数前加上explcit，运行结果：

class A
{
public:
  //单参数构造函数
  explicit A(int a)
  //A(int a)
    :_a(a)
  {
    cout << "A(int a)" << endl;
  }
  //拷贝构造
  A(const A& aa)
    :_a(aa._a)
  {
    cout << "A(const A& aa)" << endl;
  }
private:
  int _a;
};
int main()
{
  A aa1(1);
  //拷贝构造
  A aa2 = aa1;
  A aa3 = 3;
  const A& raa = 4;
  return 0;
}

5. 单参数和多参数构造函数的隐式类型转换

多参数构造函数的隐式类型转换的过程与第2点中解释的单参数类似。

class A
{
public:
  //单参数构造函数
  //explicit A(int a)
  A(int a)
    :_a(a)
  {
    cout << "A(int a)" << endl;
  }
  //多参数构造函数
  A (int a1,int a2)
    :_a(0)
    ,_a1(a1)
    ,_a2(a2)
  {}
  //拷贝构造
  A(const A& aa)
    :_a(aa._a)
  {
    cout << "A(const A& aa)" << endl;
  }
private:
  int _a;
  int _a1;
  int _a2;
};
int main()
{
  A aaa1(1, 2);
  A aaa2 = { 1,2 };//传参时要用花括号
  const A& aaa3 = { 3,2 };
  return 0;
}

二，static成员

对象中只存成员变量，不存静态成员变量，静态成员变量在静态区，也不存函数，函数指针，它们在代码段。

1.静态成员变量

特性：

(1) 静态成员变量在静态区，不在对象中；

(2) 静态成员变量不能给缺省值，因为缺省值是给初始化列表用的，它在静态区，不在对象中，不走初始化列表；

(3) 静态成员变量的定义在全局，如果只有声明，没有定义，会报错！

当用sizeof计算对象的大小时，结果是：8

这就说明 aa1 对象中只有_a1，_a2，没有 _scount。

class A
{
public:
  A()
  {
    cout << "A()" << endl;
  }
  A(const A& t)
  {
    cout << "A(const A& t)" << endl;
  }
  ~A()
  {
    cout << "~A()" << endl;
  }
private:
  //声明
  int _a1;
  int _a2;
public:
  //在静态区，不在对象中
  //不能给缺省值，因为缺省值是给初始化列表用的
  //它在静态区，不在对象中，不走初始化列表
  static int _scount;
};
//静态成员变量的定义(如果只有声明，没有定义，会报错！)
int A::_scount = 1;
int main()
{
  A aa1;
  cout << sizeof(aa1) << endl;//8
  //如果它是公有的，就可以按如下访问
  //aa1._scount++;
  //cout << A::_scount << endl;
  return 0;
}

静态成员变量的特点：它属于整个类，属于所有对象。

使用静态成员变量可以统计一共创建了多少个类对象：

因为所有的对象都要走构造或者拷贝构造：在它们之中++，统计累计创建了多少个类对象；

当走完析构函数：统计现在还有多少对象存活。

代码实现如下：

class A
{
public:
  A()
  {
    ++_scount;
  }
  A(const A& t)
  {
    ++_scount;
  }
  ~A()
  {
    --_scount;
  }
private:
  //声明
  int _a1;
  int _a2;
public:
  static int _scount;
};
int A::_scount = 0;
int main()
{
  A aa1;
  //cout << sizeof(aa1) << endl;//8
  A aa2;
  A aa3;
  cout << A::_scount << endl;
  return 0;
}

2.静态成员函数

第1点中对静态变量的使用都是它在公有的前提下，那么它在私有时该如何访问呢？就要使用静态成员函数了。

特点：static修饰成员函数，没有this指针，意味着只能访问静态成员，不能访问其他的成员变量。

class A
{
public:
  A()
  {
    ++_scount;
  }
  A(const A& t)
  {
    //但是非静态的可以调用静态的
    GetCount();//ok
    ++_scount;
  }
  ~A()
  {
    --_scount;
  }
  //特点：static修饰成员函数，没有this指针，意味着只能访问静态成员
  //不能访问其他的成员变量
  static int GetCount()
  {
    return _scount;
  }
private:
  //声明
  int _a1;
  int _a2;
  static int _scount;
};
int A::_scount = 0;
int main()
{
  A aa1;
  A aa2;
  A aa3;
  //调用方式
  cout << A::GetCount() << endl;
  return 0;
}

3. static 成员的应用

代码实现如下：

#include <regex>
class Sum
{
public:
    Sum()
    {
       _ret += _i;
       _i++;
    }
    
    //由于静态成员变量是私有的，要拿到它们的值，
    //就要使用静态成员函数
    static int GetRet()
    {
        return _ret;
    }
private:
    static int _i;
    static int _ret;
};
//静态成员变量要在全局定义，要指定类域
int Sum::_i = 1;
int Sum::_ret = 0;
class Solution {
public:
    int Sum_Solution(int n) {
        //变长数组
        //定义一个Sum类的数组，调用n次构造函数
        Sum arr[n];
        return Sum::GetRet();
    }
};

三，友元

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

3.1 友元函数

问题：

现在尝试去重载operator<<，然后发现没办法将operator<<重载成成员函数。

原因：

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

class Date
{
public:
 Date(int year, int month, int day)
     : _year(year)
     , _month(month)
     , _day(day)
 {}
 
// d1 << cout; -> d1.operator<<(&d1, cout); 不符合常规调用
 // 因为成员函数第一个参数一定是隐藏的this，所以d1必须放在<<的左侧
 ostream& operator<<(ostream& _cout)
 {
     _cout << _year << "-" << _month << "-" << _day << endl;
     return _cout;
 }
private:
 int _year;
 int _month;
 int _day;
};

友元函数可以直接访问类的私有成员，它是定义在类外部的全局函数，不属于任何类，但需要在类的内部声明，声明时需要加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;
}
int main()
{
   Date d;
   cin >> d;
   cout << d << endl;
   
     return 0;
}

说明:

友元函数可访问类的私有和保护成员，但不是类的成员函数;

友元函数不能用const修饰，因为const修饰this指针;

友元函数可以在类定义的任何地方声明，不受类访问限定符限制;

一个函数可以是多个类的友元函数;

友元函数的调用与普通函数的调用原理相同

3.2 友元类

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

class Time
{
   //声明 Date是Time的友元
   //则在Date中可以访问Time中的私有，但是反过来不行
   friend class Date; 
   
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的友元。

友元关系不能继承，在继承位置再给大家详细介绍。

四，内部类

概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。

内部类是一个独立的类，它不属于外部类，它仅仅是受到外部类域的限制，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。

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

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

特性：

内部类可以定义在外部类的public、protected、private都是可以的。

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

sizeof(外部类)=外部类，和内部类没有任何关系。

五，匿名对象

匿名对象的生命周期只在当前这一行，即用即销毁。

class A
{
public:
 A(int a = 0)
 :_a(a)
 {
   cout << "A(int a)" << endl;
 }
 
 ~A()
 {
   cout << "~A()" << endl;
 }
private:
 int _a;
 
};
class Solution {
public:
 int Sum_Solution(int n) 
 {
   //...
   return n;
 }
};
int main()
{
   A aa1;
   
   // 不能这么定义对象，因为编译器无法识别下面是一个函数声明，还是对象定义
   //A aa1();
   
   // 但是我们可以这么定义匿名对象，匿名对象的特点不用取名字，
   // 但是他的生命周期只有这一行，我们可以看到下一行他就会自动调用析构函数
   A();
   A aa2(2);
   
   // 匿名对象在这样场景下就很好用，当然还有一些其他使用场景，这个我们以后遇到了再说
   Solution().Sum_Solution(10);
 
     return 0;
}

【C++】：类和对象(下)

一，再谈构造函数

1.初始化列表

2. 隐式类型转换的过程及其优化

3. 隐式类型转换的使用

4. explcit关键字

5. 单参数和多参数构造函数的隐式类型转换

二，static成员

1.静态成员变量

2.静态成员函数

3. static 成员的应用

三，友元

3.1 友元函数

3.2 友元类

四，内部类

五，匿名对象

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

【C++】：类和对象(下)

一，再谈构造函数

1.初始化列表

2. 隐式类型转换的过程及其优化

3. 隐式类型转换的使用

4. explcit关键字

5. 单参数和多参数构造函数的隐式类型转换

二，static成员

1.静态成员变量

2.静态成员函数

3. static 成员的应用

三，友元

3.1 友元函数

3.2 友元类

四，内部类

五，匿名对象

热门文章

最新文章

相关课程

相关电子书

相关实验场景