Cpp

C++重载运算与类型转换

运算符重载

重载的运算符是具有特殊名字的函数，除函数调用运算符外，其他重载运算符不能含有默认实参。

  • 一个运算符函数，或者类的成员，或者至少含有一个类类型的参数。也就是说不能为内置类型重载运算符。
  • 只能重载已有的运算符。
  • 一个重载的运算符，其优先级和结合律与对应的内置运算符保持一致。
  • 由于使用重载的运算符本质上是函数调用，因此对象求值顺序的规则无法应用到重载的运算符上。尤其是&&，||和,，两个运算对象总是会被求值。
  • 通常情况下，不应该重载&&，||，&和,，运算符。
  • 一般来说，提供了某个重载运算符，也应该提供与此运算符相关的一系列运算符，如：算术运算符->对应的复合赋值运算符。

成员或者非成员

  • =，[]，()和->运算符**必须是成员。

  • 复合赋值运算符一般来说应该是成员，但非必须。

  • 改变对象状态或与给定类型密切相关的运算符，应该是成员。如：递增、解引用。

  • 具有对称性的运算符可能转换任意一端的运算对象，通常应该是非成员。如：算术、相等性、关系和位运算符。如果想提供含有类对象的混合类型表达式，运算符必须是非成员函数。

    1
2

    string s = "world";
string u = "hi" + s; // 如果是成员函数，则"hi".operator+(s)，错误

对于友元要注意，在类内部虽然有友元声明，但这并非真正意义上的函数声明，因此在类外部还需要有函数声明。

输入输出运算符

«

  • ostream &operator<<(ostream &os, const Sales_data &item);
  • 必须是非成员函数，否则左侧运算对象将是类的一个对象 就算要是某个类的成员，也只能是istream或ostream的，然而并不能为标准库中的类添加成员，因此只能是非成员函数
  • 不应该打印换行符

»

  • istream &operator>>(istream &is, Sales_data &item);

  • 必须处理输入可能失败的情况

     1
 2
 3
 4
 5
 6
 7
 8
 9
10

    istream& operator>>(istream &is, Sales_data &item) {
  double price = 0.0;
  is >> item.bookNo >> item.units_sold >> price;
  if (is) {
    item.revenue = price * item.units_sold;
  } else {
    item = Sales_data();
  }
  return is;
}

  • 有时需要标识流的条件状态

算术和关系运算符

  • 通常把算术和关系运算符定义为非成员函数，使得左侧或右侧的运算对象可以转换

    1
2

    string s = "world";
string u = "hi" + s; // 如果是成员函数，则"hi".operator+(s)，错误

  • 这些运算符一般不需要改变运算对象的状态，所以形参是常量引用

  • 一般使用复合赋值来实现算术运算符

==

  • 相等运算符应该具有传递性
  • 定义了==，也应该定义!=

关系运算符

关系运算符应该，

  1. 定义顺序关系，且与关联容器中对关键字的要求一致
  2. Define a relation that is consistent with == if the class has both operators. In particular, if two objects are !=, then one object should be < the other.

如果存在唯一一种逻辑可靠的<语义，才考虑定义<运算符。如果类同时还包含==，则当且仅当<的定义和==产生的结果一致时才定义<运算符。

=

  • 必须为成员函数
  • 必须先释放当前内存空间
  • 如果不是拷贝赋值运算符和移动赋值运算符，则不必检查自赋值的情况。

[]

  • 必须为成员函数
  • 返回元素的引用
  • 通常定义const和非const版本

递增递减运算符

由于改变了对象的状态，一般应为成员函数，且应该同时定义前置版本和后置版本。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 返回递增或递减后对象的引用
StrBlobPtr &operator++();
StrBlobPtr &operator--();

// 返回对象的原值
StrBlobPtr operator++(int); // 形参不会被使用，仅仅是和前置版本进行区分
StrBlobPtr operator--(int);

p.operator--(0); // 调用后置版本的
p.operator--(); // 调用前置版本的

成员访问运算符

1
2
3
4
5
6

string &StrBlobPtr::operator*() const {
  auto p = check(curr, "deference past end");
  return (*p)[curr];
}

string *StrBlobPtr::operator->() const { return &this->operator*(); }
  • ->必须是类成员，*非必需，但通常也是。
  • 定义为const是因为获取一个元素并不会改变对象的状态。
  • 虽然可以让解引用返回任何想要的值或打印（不建议），但箭头运算符必须有成员访问的含义。重载箭头运算符时，可以改变的是箭头从哪个对象中获取成员。

函数调用运算符

函数调用运算符必须是成员函数。如果类定义了调用运算符，那么该类的对象叫做函数对象。调用函数对象实际上是在运行重载的调用运算符。

lambda是函数对象

编写lambda后，编译器将生成一个未命名类的未命名对象。这个类中有一个重载的函数调用运算符，且默认情况下这个成员是const（lambda不能改变捕获的变量），除非lambda被声明为mutable。

  • 引用捕获 由程序确保lambda执行时所引用的对象确实存在，生成的类中无须保存为数据成员。

  • 值捕获 生成的类中需建立对象的数据成员，同时创建构造函数，用捕获的变量来初始化数据成员。

lambda产生的类中，不包含默认构造函数、赋值运算符和默认析构函数，默认拷贝和默认移动构造函数视捕获的数据成员类型而定。

标准库定义的函数对象

标准库规定的函数对于指针同样适用。直接比较两个无关的指针将产生未定义的行为，但通过标准库定义的函数对象来比较是定义良好的。

关联容器使用less<key_type>对元素排序，因此可以直接定义一个指针的set或map，而无须声明less。

function

C++中的可调用对象多种有，它们的类型是不同的，

  • 函数和函数指针 类型由返回值类型和实参类型决定
  • lambda表达式 每个lambda有唯一的未命名类类型
  • bind创建的对象
  • 重载了函数调用运算符的类

类型不同的可调用对象可能共享同一种调用形式。调用形式指明了调用返回的类型以及传递给调用的实参类型。一种调用形式对应一个函数类型。

定义funcion类型时，需要指明调用形式。

1
2
3
4
5

  map<string, function<int(int, int)>> binops = {{"+", plus<int>()},
                                                 {"-", minus<int>()},
                                                 {"*", multiplies<int>()},
                                                 {"/", divides<int>()},
                                                 {"%", modulus<int>()}};

重载、类型转换

如果构造函数只接受一个实参，则它实际上定义了转换为此类型的隐式转换机制，这种构造函数叫做转换构造函数。

转换构造函数和类型转换运算符共同定义类类型转换，也叫用户定义的类型转换。

编译器一次只能执行一个用户定义的类型转换。

隐式类型转换运算符

  • operator int() const; 从类类型转换为int
  • 无显示的返回类型和形参
  • 返回一个对应类型的值
  • 必须定义为成员函数
  • 通常不应该改变转换对象的内容，一般被定义为const
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

class S {
 public:
  S(int i = 0) : val(i) { cout << "construct" << endl; }
  S(const S &s) : val(s.val) { cout << "copy" << endl; }
  S(S &&s) : val(s.val) { cout << "move" << endl; }
  S &operator=(const S &s) {
    cout << "copy assign" << endl;
    val = s.val;
    return *this;
  }
  S &operator=(S &&s) {
    cout << "move assign" << endl;
    val = s.val;
    return *this;
  }
  operator int() const {
    cout << "conversion->int" << endl;
    return val;
  }

 private:
  size_t val;
};

S s; // construct
s = 4; // construct， move assign
s + 3; // conversion->int
s - s; // conversion->int, conversion->int

S虽然没有定义-，但隐式转换为int，可以执行内置的-。

虽然编译器一次只能执行一个用户定义的类型转换，但隐式的用户定义类型转换可以至于一个标准（内置）类型转换之前或之后。

1
2
3
4

// double->int->S
s = 3.14; // construct， move assign
// S->int->double
s + 3.14; // conversion->int

显式类型转换运算符

explicit operator int() const;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

class S {
 public:
  S(int i = 0) : val(i) {}
  explicit operator int() const { return val; }

 private:
  size_t val;
};

S s;
s + 3; // 错误
static_cast<int>(s) + 3;

if (s) {
  // ...
}

但是当表达式作为条件时，编译器会将显式类型转换自动应用于它（仅仅是自动应用explicit operator bool() const，以转换为bool）。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

class S {
 public:
  S(int i = 0) : val(i) {}
  explicit operator bool() const { return val; }

 private:
  size_t val;
};

S s;
if (s) {
}

避免有二义性的类型转换

必须确保类类型和目标类型之间只存在唯一一种转换方式。无法通过使用强制类型转换来解决二义性问题，强制类型转换也会面临二义性问题。

多重转换路径可能由于，

  • 两个类提供相同的类型转换

  • 类定义了一组类型转换，它们的转换源（或者转换目标）类型本身可以通过其他类型转换联系在一起，由于所有算术类型转换的级别都一样，选择转换序列时会有多个转换序列，将会导致二义性。

     1
 2
 3
 4
 5
 6
 7
 8
 9
10

    class S {
 public:
  S();
  operator int() const;
  operator double() const;
};

S s;
int a = s; // 精确匹配
float b = s; // 两个“可行函数”

如果已经定义了一个转换为算术类型的类型转换，不要再定义接受算术类型的重载运算符。在不定义以后，如果用户需要使用这样的运算符，则类型转换操作会转换此类型的对象，然后使用内置的运算符。

重载函数与转换构造函数

当调用重载的函数时，如果两个或多个类型转换都提供了可行的匹配，则这些类型转换一样好。

重载函数与用户定义的类型转换

当调用重载的函数时，如果两个或多个类型用户定义的转换都提供了可行的匹配，则这些类型转换一样好。此时，不考虑任何可能出现的标准类型转换级别。

只有当重载函数能通过同一个类型转换函数得到匹配时（所有可行函数都请求同一个用户定义的类型转换），才考虑标准类型转换级别。

函数匹配与重载运算符

表达式中运算符的候选函数集包括成员函数和非成员函数。

如果对同一个类既提供了转换目标是算术类型的类型转换，也提供了重载的运算符，则将会遇到重载运算符和内置运算符的二义性问题。

comments powered by Disqus