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

简介: 【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;
}

说明:

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

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

特性:

  1. 友元关系是单向的,不具有交换性
    比如上述Time类和Date类,在Time类中声明Date类为其友元类,那么可以在Date类中直接
    访问Time类的私有成员变量,但想在Time类中访问Date类中私有的成员变量则不行。
  2. 友元关系不能传递
    如果C是B的友元, B是A的友元,则不能说明C时A的友元。
  3. 友元关系不能继承,在继承位置再给大家详细介绍。

四,内部类

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

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

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

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

特性:

  1. 内部类可以定义在外部类的public、protected、private都是可以的。
  2. 注意内部类可以直接访问外部类中的static成员,不需要外部类的对象/类名。
  3. 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;
}
目录
相关文章
|
2天前
|
设计模式 安全 编译器
【C++11】特殊类设计
【C++11】特殊类设计
22 10
|
7天前
|
C++
C++友元函数和友元类的使用
C++中的友元(friend)是一种机制,允许类或函数访问其他类的私有成员,以实现数据共享或特殊功能。友元分为两类:类友元和函数友元。类友元允许一个类访问另一个类的私有数据,而函数友元是非成员函数,可以直接访问类的私有成员。虽然提供了便利,但友元破坏了封装性,应谨慎使用。
39 9
|
2天前
|
存储 编译器 C语言
【C++基础 】类和对象(上)
【C++基础 】类和对象(上)
|
10天前
|
编译器 C++
【C++】string类的使用④(字符串操作String operations )
这篇博客探讨了C++ STL中`std::string`的几个关键操作,如`c_str()`和`data()`,它们分别返回指向字符串的const char*指针,前者保证以&#39;\0&#39;结尾,后者不保证。`get_allocator()`返回内存分配器,通常不直接使用。`copy()`函数用于将字符串部分复制到字符数组,不添加&#39;\0&#39;。`find()`和`rfind()`用于向前和向后搜索子串或字符。`npos`是string类中的一个常量,表示找不到匹配项时的返回值。博客通过实例展示了这些函数的用法。
|
10天前
|
存储 C++
【C++】string类的使用③(非成员函数重载Non-member function overloads)
这篇文章探讨了C++中`std::string`的`replace`和`swap`函数以及非成员函数重载。`replace`提供了多种方式替换字符串中的部分内容,包括使用字符串、子串、字符、字符数组和填充字符。`swap`函数用于交换两个`string`对象的内容,成员函数版本效率更高。非成员函数重载包括`operator+`实现字符串连接,关系运算符(如`==`, `&lt;`等)用于比较字符串,以及`swap`非成员函数。此外,还介绍了`getline`函数,用于按指定分隔符从输入流中读取字符串。文章强调了非成员函数在特定情况下的作用,并给出了多个示例代码。
|
10天前
|
C++
【C++】string类的使用④(常量成员Member constants)
C++ `std::string` 的 `find_first_of`, `find_last_of`, `find_first_not_of`, `find_last_not_of` 函数分别用于从不同方向查找目标字符或子串。它们都返回匹配位置,未找到则返回 `npos`。`substr` 用于提取子字符串,`compare` 则提供更灵活的字符串比较。`npos` 是一个表示最大值的常量,用于标记未找到匹配的情况。示例代码展示了这些函数的实际应用,如替换元音、分割路径、查找非字母字符等。
|
10天前
|
C++
C++】string类的使用③(修改器Modifiers)
这篇博客探讨了C++ STL中`string`类的修改器和非成员函数重载。文章介绍了`operator+=`用于在字符串末尾追加内容,并展示了不同重载形式。`append`函数提供了更多追加选项,包括子串、字符数组、单个字符等。`push_back`和`pop_back`分别用于在末尾添加和移除一个字符。`assign`用于替换字符串内容,而`insert`允许在任意位置插入字符串或字符。最后,`erase`函数用于删除字符串中的部分内容。每个函数都配以代码示例和说明。
|
10天前
|
安全 编译器 C++
【C++】string类的使用②(元素获取Element access)
```markdown 探索C++ `string`方法:`clear()`保持容量不变使字符串变空;`empty()`检查长度是否为0;C++11的`shrink_to_fit()`尝试减少容量。`operator[]`和`at()`安全访问元素,越界时`at()`抛异常。`back()`和`front()`分别访问首尾元素。了解这些,轻松操作字符串!💡 ```
|
10天前
|
存储 编译器 Linux
【C++】string类的使用②(容量接口Capacity )
这篇博客探讨了C++ STL中string的容量接口和元素访问方法。`size()`和`length()`函数等价,返回字符串的长度;`capacity()`提供已分配的字节数,可能大于长度;`max_size()`给出理论最大长度;`reserve()`预分配空间,不改变内容;`resize()`改变字符串长度,可指定填充字符。这些接口用于优化内存管理和适应字符串操作需求。
|
10天前
|
C++ 容器
【C++】string类的使用①(迭代器接口begin,end,rbegin和rend)
迭代器接口是获取容器元素指针的成员函数。`begin()`返回首元素的正向迭代器,`end()`返回末元素之后的位置。`rbegin()`和`rend()`提供反向迭代器,分别指向尾元素和首元素之前。C++11增加了const版本以供只读访问。示例代码展示了如何使用这些迭代器遍历字符串。