C++ 中的结构体结合了类，于是就有很多很有意思的写法。

构造函数

1
2
3
4
5
6
7
8
struct teamS {
       int s; //solved
       int p; //penalty
       teamS() {};
       teamS(int _s = 1, int _p = 2):s(_s), p(_p){}
};

teamS s(6,66);

重载 [] 使结构变为类似于数组的形式

起初是看到 map 在这么用，试了一下，发现没有报错，有点香。

对一维数组重载，记得使用引用 &。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
struct triple
{
    int first;
    int second;
    int third;
    int & operator [](int i)
    {
        switch (i)
        {
        case 0: return first;
        case 1:return second;
        case 2:return third;
        }
    }
}

对二维数组的重载，使用的是指针 *，就不需要引用了。

1
2
3
4
5
6
7
8
9
10
struct matrix
{
    long long v[3][3] = { 0 };
    long long * operator[](int i)
    {
        return v[i];
    }
}m;

m[1][2] == m.v[1][2];

运算符重载

C++引入了运算符重载，并有以下规则：

  1. 只能重载已有的运算符，已有的少部分也不能重载（::、# 等）；
  2. 重载以后的优先级不变。

运算符重载的格式为：

1
2
3
4
5
6
7
8
9
10
class Complex
{
    double real, imagine;
    public: /*...*/
        Complex() {};
    	Complex(int r = 0, int i = 0) {};
        Complex operator + (Complex num) { /* */ }
}c1,c2;
c1 = c2 + 1;
c1 = c2.operator+(1);

但是无法使用 c1 = 1 + c2，因为重载的 + 是属于 Complex 类的，而不是 int。

正确的使用方法是：把该重载声明为 Complex 类以外的函数（如果函数需要访问 Complex 的 private 成员，注意使用友元关键字）

1
friend Complex operator + (Complex num, Complex C) {/* */}

这样，编译器就能愉快的把 int 转换为 Complex 了。

下面写几个值得一提的特殊的运算符重载。

类型转换函数

把 int 当作一个一元操作符可还行。

1
2
3
4
5
6
7
8
struct teamS {
    int s; //solved
    int p; //penalty
    operator int()
    {
        return s * 100 - p;
    }
};

重载 ++ 自增运算符

转自：https://blog.csdn.net/anye3000/article/details/6618495

我写类的时候，重载了 ++ 运算符，然后 date++ VS 报错。查了以后，才意识到，++ 分了前置/前缀形式和后置重载/后缀形式。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class A
{
private:
    int m_i;
public:

    //++i
    A& operator++()
    {
        ++m_i;
        return *this;
    }
    //i++
    const A operator++(int)
    {
        A tmp = *this;
        ++(*this);
        return A(tmp);
    }
}

注意：

  1. 为了区分前后，用 ++() 表示前自增，用 ++(int)后自增。
  2. **前自增应该返回引用 A&**，因为按照前自增的标准定义，应该支持 ++++a 的语法，而且两次前自增都应该是对 a 对象的自身操作。如果返回A类型，那第二次前自增调用的是临时对象的前自增操作，和定义也不同；
  3. 后自增应该返回 const，这可以防止形如 a++++ 的用法。不能返回 const &，因为实现里面返回的是临时的 temp，不能返回临时的指针。所以就涉及到了复制构造（Copy Construction）的问题了额。还是多用前自增吧……
  4. 一般通过前自增操作来实现后自增操作符函数。

重载等于 =

重载 = 和拷贝构造函数很相似，于是放在拷贝构造函数一节。

从基类派生出结构

有点不可信，但确实可以。

In C++, a structure’s inheritance is the same as a class except the following differences: When deriving a struct from a class/struct, the default access-specifier for a base class/struct is public. And when deriving a class, the default access specifier is private.2009年6月11日
– Struct inheritance in C++ - Stack Overflow

结构和类的区别真就只有 private 和 public 了？