【C++】总结5

初始化列表

• 在构造函数中，我们可以给对象一个初始值，但是不能将其称作为类对象成员的初始化，构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值
• 初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个成员变量后面跟一个放在括号中的初始值或表达式
• 注意：
• • 每个成员变量在初始化列表中只能出现一次（初始化只能初始化一次）
  • 引用成员变量、const成员变量、自定义类型成员必须放在初始化列表位置进行初始化
  • 尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化
  • 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关

explicit和mutable

• explicit关键字用于修饰类的单参构造函数，被修饰的构造函数的类，不能发生相应的隐式类型转换，只能以显式的方式进行类型转换。注意：

• • explicit 关键字只能用于类内部的构造函数声明上
  • 被explicit修饰的构造函数的类，不能发生相应的隐式类型转换

• 示例代码

  class MyClass {
      public:
          explicit MyClass(int value) : data(value) {}
  
          int getData() const {
              return data;
          }
  
      private:
          int data;
      };
  
      void doSomething(MyClass obj) {
          int value = obj.getData();
          std::cout << "Value: " << value << std::endl;
      }
  
      int main() {
          MyClass obj1(42);//显式构造
          doSomething(obj1);
  
          // 使用 explicit 构造函数进行显式类型转换是允许的
          MyClass obj2 = MyClass(100);//显式构造
          doSomething(obj2);
  
          // 下面的代码会报错，因为 explicit 构造函数不能隐式调用
          // doSomething(200);//将200隐式转换为Myclass类型，发生错误
  
          return 0;
      }

• 在C++中，mutable是为了突破const的限制而设置的。被mutable修饰的变量，将永远处于可变的状态，即使在一个const函数中。有些时候，我们需要在const函数里面修改一些跟类状态无关的数据成员，那么这个函数就应该被mutable来修饰。

  class MyClass {
  public:
  	MyClass(int value) : data(value) {}
  
  	// 常量成员函数，使用 mutable 修饰成员变量
  	int getValue() const {
  		counter++; // 在常量成员函数中修改 mutable 变量
  		return data;
  	}
  
  private:
  	int data;
  	mutable int counter = 0; // 使用 mutable 修饰成员变量
  };
  
  int main() {
  	const MyClass obj(42);
  	int value = obj.getValue(); // 调用常量成员函数，可以修改 mutable 变量
  	return 0;
  }

友元

• 友元函数

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

  友元函数实现类之间数据共享，减少系统开销，提高效率

  什么时候使用友元函数：

  • 运算符重载的某些场合需要使用友元，例如对<<和 >>的重载：

示例代码：

class Date
{
	friend ostream& operator<<(ostream& _cout, const Date& d);
	friend istream& operator>>(istream& _cin, Date& d);
public:
	Date(){}
	Date(int year, int month, int day)
		: _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;
}

执行结果：

2023 07 27
2023-7-27

• 两个类要共享数据的时候

说明：

• 友元函数不能用const修饰，在类中，const修饰函数是修饰函数的this指针，友元函数没有this指针，当然也就不能用const来修饰了

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

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

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

• 友元类

  友元类是一个类可以访问另一个类的私有成员和保护成员。友元类的所有成员函数都可以是另一个类的友元函数

• 友元的优缺点：

  • 优点：提高了程序运行效率
  • 缺点：破坏了类的封装性和隐藏性

• 友元关系是单向的，不具有交换性

• 友元关系不能传递 如果B是A的友元，C是B的友元，则不能说明C时A的友元。

内部类

• 概念：：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。注意此时这个内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去调用内部类。外部类对内部类没有任何优越的访问权限。
• 内部类就是外部类的友元类。内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。
• 特征：
• • 内部类可以定义在外部类的public、protected、private都是可以的
  • 注意内部类可以直接访问外部类中的static、枚举成员，不需要外部类的对象/类名
  • sizeof(外部类)=外部类，和内部类没有任何关系