要考试了。记录下自己相对记得不熟的。

复数

#include<iostream>
#include<complex>
using namespace std;

void main() {
    complex<int>c1(1,2);
    cout<<c1.real()<<c1.imag()<<endl;
}

字符串

#include<iostream>
#include<string>
#include<cstring>
using namespace std;

void main() {
    string str1 = "123456";
    cout<<str1.substr(3,3)<<endl;
    string str2 = "abcd";
    str1.swap(str2);
    cout<<str1<<endl<<str2<<endl;
    cout<<str1.find("b")<<endl;
    cout<<str1.size()<<endl;
    char str3[5];
    size_t length = str1.copy(str3,2,1);
    str3[length] = '\0';
    cout<<length<<str3<<endl;   
    char str4[] = "abcde";
    cout<<strlen(str3)<<endl;
}

函数

参数传递方式

C 语言函数参数的传递方式只有传值一种，又分为传变量值和传变量地址值两种情况，而C＋＋的函数参数传递方式有两种：第一种和C语言一样，是传值；第二种是传引用，即传对象的地址，所以也称传地址方式。注意传地址值传递的是值，是以对象指针作为参数；而传地址传递的是地址，是以对象引用作为参数。

返回引用

函数可以返回一个引用，这样的目的是为了将该函数用在赋值运算符的左边，因为其他情况下，一个函数是不能直接用在赋值运算符左边的。

···

include<iostream>

using namespace std;

int& returnRef() {
static int a = 23;
return a;
}
int main() {
returnRef() = 123;
int b = returnRef();
cout<<b<<endl;
return 0;
}
···

当函数返回值为引用时，若返回栈变量，不能成为其他引用的初始值，不能作为左值使用
若返回静态变量或全局变量，可以成为其他引用的初始值，即可作为右值使用，也可作为左值使用

函数返回值

非void 类型的函数必须向调用者返回一个值，数组只能返回地址。

内联函数

inline 说明函数为内联函数，内联函数必须在程序中第一次调用此函数的语句出现前定义。具有循环语句、switch 不能说明为内联函数外，其他函数都可以说明为内联函数。内联函数可提高执行速度。但函数体语句过多，会增加程序代码量。

inline void print() {
    cout<<"inline"<<endl;
}

void main() {
    print();
}

重载

区别一是参数类型不同，二是参数个数不同，所以仅凭返回值不同或仅凭参数个数不同，均不能区分重载函数。

使用函数重载，指导程序运行时才能确定调用哪个函数，编译器的这种连接称为动态联编或迟后联编。

函数模板

函数在设计时没有使用实际的类型，而是使用虚拟的类型参数，故其灵活性得到加强。当用实际的类型来实例化这种函数时，就好像按照模板来制造新的函数一样，所以称这种函数为函数模板。将函数模板与某个具体数据类型连用，就产生了模板函数，又称这个过程为函数模板实例化，这种形式就是类型参数化。

template <class T> int max(T a,T b) {
    return a>b ?a:b;
}
template <class T1, class T2> void print(T1 a, T2 b) {
    cout<<a<<b<<endl;
}
void main() {
    cout<<max(1,2)<<endl;
    print(1,"1234");
}

这里的class可以替换成typename，比如写成template <class T1, typenameT2>。

对象

构造函数

没有任何构造函数的情况下，C++编译器会自动建立一个不带参数的构造函数。

若定义了有参数的构造函数，又存在需要建立对象数组进行赋值操作的情况，必须为它定义一个无参数的构造函数。

如果程序定义有参数构造函数，又想使用无参数形式的构造函数，解决的方法是将相应的构造函数全部使用默认参数设计。

复制构造函数，通过拷贝方式使用一个类已有的对象来建立该类的一个新对象。编译器会默认复制构造函数，如果你定义了就只调用你自定义的复制构造函数。

delete 与析构函数一起工作，使用运算符delete删除一个动态对象时，首先调用析构函数。再释放这个动态对象占用的内存，这和使用运算符new 建立 动态对象的过程正好相反。

class A {
    int x;
    int y;
    public:
        A(int a=1) {
            x = a;
            y = 2;
        }
        A(int a, int b):x(a),y(b) {
            cout<<"construct"<<endl;
        }
        void display() {
            cout<<"display: x="<<x<<",y="<<y<<endl;
        }
        A(const A& a) {
            x = a.x;
            y = a.y;
            cout<<"copy construct"<<endl;
        }
        ~A() {
            cout<<"destruct"<<" x="<<x<<",y="<<y<<endl;
        }
};
int main() {
    A a = A(1,2);
    a.display();
    A a1 = A();
    a1.display();
    A a2[3];
    a2[1].display();
    A b = a;
    b.display();
    A* c = new A(3, 4);
    c->display();
    delete c;
    return 1;
}

静态成员

静态数据成员只能说明一次，类外对静态数据成员进行初始化。类外不能使用static。静态数据成员是类的成员，初始化必须使用作用域运算符“::”限定它所属的类。

const 对象。类中可用const关键字定义数据成员和成员函数。const对象只能访问const成员函数，否则产生编译错误。

常量成员包括静态常数数据成员、常数据成员和常引用，前者保留静态成员特征，需要在类外初始化，后两者只能通过初始化列表获得初值。

class A {
    static int z;
    const int i;
    static const int j;
    const int& k;
    int x;
    int y;
    public:
    A(int a, int b):x(a),y(b),i(a),k(y) {

    }
    void display() {
        cout<<"display: x="<<x<<",y="<<y<<",z="<<A::z<<",i="<<i<<", j="<<A::j<<", k="<<k<<endl;
    }
    void display() const {
        cout<<"display const: x="<<x<<",y="<<y<<",z="<<A::z<<", i="<<i<<", j="<<A::j<<", k="<<k<<endl;
    }
};
int A::z = 23;
const int A::j = 24;
int main() {
    A a = A(1, 2);
    a.display();
    A const a1 = A(2, 4);
    a1.display();
    return 0;
}

数组和类

class A {
    private:
        int x;
        int y;
    public:
        A(int a = 1) {
            x = a;
            y = 1;
            
        }
        A(int a, int b) {
            x = a;
            y = b;
        }
        void display(){
            cout<<"x="<<x<<", y="<<y<<endl;
        }
};

int main() {
    A a[3];
    a[1].display();
    A a1[2] = {A(1,2), A(2,4)};
    a1[1].display();
    A a2[2] = {3,5},*p;
    a2[1].display();
    p = a2;
    for(int i = 0; i < 2; i++,p++)
    {
        p->display();
    }
}

继承、抽象、多态（动态联编、静态联编）

#include<iostream>

using namespace std;

class Car {
    int wheel;
    string name;
    public:
    virtual void drive()=0;
    void desc() {
        cout<<"car"<<endl;
    }

};

class Automobile : Car { // 汽车
public:
    void drive() {
        cout<<"drive automobile"<<endl;
    }   
    void desc() {
        cout<<"automobile"<<endl;
    }
};
class Suv: public Automobile {
public:
    void drive() {
        cout<<"drive suv"<<endl;
    }
    void desc() {
        cout<<"suv"<<endl;
    }
};
class Truck: public Automobile {
    public:
    void drive() {
        cout<<"drive truck "<<endl;
    }
    void desc() {
        cout<<"truck"<<endl;
    }
    
};
class ElectricCar: Car { // 电动车
public:
    void drive() {
        cout<<"drive electric car"<<endl;
    }
    void desc() {
        cout<<"electric car"<<endl;
    }
};
void print(Automobile *a) {
    a->drive();
    a->desc();
}
void main() {
    Suv s = Suv();
    Truck t = Truck();
    s.drive();
    s.desc();
    t.drive();
    t.desc();
    print(&s);
    print(&t);
}

输出

drive suv
suv
drive truck
truck
drive suv
automobile
drive truck
automobile

友元函数，友元类

a(1)

#include<iostream>

using namespace std;

class A {
    int a;
public:
    A(int x) {
        a = x;
    }
    friend class B;
    friend void printA(A&a);
};
void printA(A&a) {
    cout<<a.a;
}
class B {
public:
    void printA(A&);
};
void B::printA(A& a) {
    cout<<a.a;
}

int main() {
    A a(1);
    B b = B();
    b.printA(a);
    printA(a);
    return 0;
}

参考资料：

• 《C++ 函数的返回值是引用》https://blog.csdn.net/error0_dameng/article/details/81739333