2026 | C++ 面向对象期末复习资料

C++ 基础差异
-> 函数增强
-> 类和对象
-> 数据共享与保护
-> 数组、指针、字符串、动态内存
-> 继承与派生
-> 多态与运算符重载
-> 模板和群体数据
-> STL、流、异常

#include <iostream>
using namespace std;

int main()
{
    cout << "Hello C++" << endl;
    return 0;
}

#include <iostream>

using namespace std;

std::cout << "Hello" << std::endl;

return 0;

cout << 输出内容;

int x = 10;
double pi = 3.14;

cout << x << endl;
cout << "pi = " << pi << endl;

10
pi = 3.14

cout << "a = " << a << ", b = " << b << endl;

cout << "hello" << endl;

cout << "hello\n";

cin >> 变量;

int a, b;
cin >> a >> b;
cout << a + b << endl;

3 5

8

namespace A
{
    int x = 10;
}

namespace B
{
    int x = 20;
}

cout << A::x << endl; // 10
cout << B::x << endl; // 20

using A::x;

using namespace A;

#include <iomanip>

cout << "(" << setw(5) << 100 << ")" << endl;

(  100)

cout << setw(5) << 1 << 2 << endl;

cout << left << setw(5) << 100 << endl;
cout << right << setw(5) << 100 << endl;

cout << setprecision(3) << 3.1415 << endl;

3.14

cout << fixed << setprecision(3) << 3.1415 << endl;

3.142

cout << dec << 100 << endl; // 十进制
cout << hex << 100 << endl; // 十六进制
cout << oct << 100 << endl; // 八进制

cout << hex << 100 << " " << 200 << endl;
cout << dec << 100 << endl;

setw 只管下一个
setprecision 会持续
hex/oct/dec 会持续
left/right 会持续

const 类型 常量名 = 初值;

const double PI = 3.1415926;

const int N; // 错，const 必须初始化
N = 100;     // 错，const 不能再赋值

#define PI 3.14
const double PI = 3.14;

int x = (int)y;

int x = int(y);

static_cast<int>(y);

static_cast<int>(3.14)

3

static_cast：正常转
dynamic_cast：继承转
const_cast：改 const
reinterpret_cast：危险转

auto 变量名 = 初值;

auto x = 1;      // int
auto y = 3.14;   // double
auto c = 'A';    // char

auto x; // 错，无法推断类型
x = 10;

auto a = 1, b = 2;   // 对，都是 int
auto x = 1, y = 2.0; // 错，一个 int 一个 double

for (auto x : v)
{
    cout << x << endl;
}

decltype(表达式) 变量名;

int i = 10;
decltype(i) j = 20; // j 是 int

auto：根据初始化值推断，并定义变量
decltype：只分析表达式类型，不执行表达式

int i = 0;
decltype(i) x = 1; // x 是 int

auto 看右边初值
decltype 看括号里的表达式类型

void f(int x)
{
    x = 10;
}

void change(int x)
{
    x = 100;
}

int main()
{
    int a = 5;
    change(a);
    cout << a << endl; // 5
}

void swapValue(int a, int b)
{
    int t = a;
    a = b;
    b = t;
}

int x = 5, y = 10;
swapValue(x, y);
cout << x << " " << y << endl; // 仍然是 5 10

值传递：复制一份，函数内改不到外面

void f(int *p)
{
    *p = 10;
}

void change(int *p)
{
    *p = 100;
}

int main()
{
    int a = 5;
    change(&a);
    cout << a << endl; // 100
}

void swapPointer(int *a, int *b)
{
    int t = *a;
    *a = *b;
    *b = t;
}

swapPointer(&x, &y);

地址传递：传地址，用 * 改原变量

void f(int &x)
{
    x = 10;
}

void change(int &x)
{
    x = 100;
}

int main()
{
    int a = 5;
    change(a);
    cout << a << endl; // 100
}

void swapRef(int &a, int &b)
{
    int t = a;
    a = b;
    b = t;
}

swapRef(x, y);

void swapRef(int &a, int &b);

int a = 10;
int &r = a;

int &r;       // 错，未初始化
double &d = a; // 错，类型不匹配

引用传递：调用像值传递，效果像指针传递

inline

inline 返回值类型 函数名(参数列表)
{
    函数体;
}

inline int add(int a, int b)
{
    return a + b;
}

int x = add(3, 5);
cout << x << endl; // 8

调用函数 -> 跳到函数代码处执行 -> 返回原位置

inline int square(int x)
{
    return x * x;
}

int a = square(5);

int a = 5 * 5;

inline int maxNum(int a, int b)
{
    return a > b ? a : b;
}

class Student
{
private:
    int age;

public:
    int getAge()
    {
        return age;
    }
};

class Student
{
private:
    int age;

public:
    int getAge();
};

inline int Student::getAge()
{
    return age;
}

inline：建议编译器在调用处展开函数体，适合短小频繁调用的函数

返回值类型 函数名(类型 参数1, 类型 参数2 = 默认值);

int add(int x, int y = 5, int z = 6)
{
    return x + y + z;
}

cout << add(10, 20, 30) << endl; // 60
cout << add(10, 20) << endl;     // 36
cout << add(10) << endl;         // 21

int f(int x, int y = 1, int z = 2);

int f(int x = 0, int y, int z = 2);

int add(int x, int y = 5);

int add(int x, int y)
{
    return x + y;
}

int add1(int x, int y = 5, int z = 6); // 对
int add2(int x = 1, int y = 5, int z); // 错
int add3(int x = 1, int y, int z = 6); // 错

默认参数从右往左给，中间不能断

int add(int a, int b);
double add(double a, double b);
int add(int a, int b, int c);

int add(int a, int b)
{
    return a + b;
}

double add(double a, double b)
{
    return a + b;
}

cout << add(1, 2) << endl;       // 调 int 版本
cout << add(1.5, 2.5) << endl;   // 调 double 版本

int f(int x);
double f(int x); // 错，不能只靠返回值区分

void f(int x);
void f(int x, int y = 0);

f(1); // 二义性

重载看参数，不看返回值

class Clock
{
public:
    void setTime(int h, int m, int s);
    void showTime();

private:
    int hour;
    int minute;
    int second;
};

Clock c1;
Clock c2;

对象占的内存主要存数据成员
成员函数代码所有对象共享一份

class Student
{
private:
    int score;

public:
    void setScore(int s)
    {
        score = s;
    }

    int getScore()
    {
        return score;
    }
};

Student stu;
stu.score = 100; // 错，score 是 private

stu.setScore(100);
cout << stu.getScore() << endl;

private 藏数据
public 给接口

class A
{
public:
    int x;

protected:
    int y;

private:
    int z;
};

A a;
a.x = 1; // 对
a.y = 2; // 错
a.z = 3; // 错

class A
{
protected:
    int x;
};

int main()
{
    A a;
    a.x = 5; // 错，protected 对对象不可见
}

class Clock
{
public:
    void setHour(int h);

private:
    int hour;
};

void Clock::setHour(int h)
{
    hour = h;
}

void Clock::setHour(int h)

class Calendar
{
private:
    int year;
    int month;
    int day;

public:
    void SetDay(int year, int month, int day)
    {
        this->year = year;
        this->month = month;
        this->day = day;
    }
};

year = year;

return *this;

A& operator=(const A &rhs)
{
    ...
    return *this;
}

this 指向当前对象
this->x 是当前对象的数据成员 x
*this 是当前对象本身

class 类名
{
public:
    类名(参数列表);
};

class Clock
{
public:
    Clock(int h, int m, int s);

private:
    int hour;
    int minute;
    int second;
};

Clock::Clock(int h, int m, int s)
{
    hour = h;
    minute = m;
    second = s;
}

Clock c(8, 30, 0);

Clock c;
c.Clock(1, 2, 3); // 错

Clock()
{
}

class A
{
public:
    A(int x);
};

A a; // 错，没有默认构造函数

A() {}

Clock c3();

构造函数：对象出生时自动调用
有参构造写了之后，默认构造不会自动生成
Clock c(); 是函数声明，不是对象

类名::类名(参数列表) : 成员1(初值1), 成员2(初值2)
{
}

Clock::Clock(int h, int m, int s)
    : hour(h), minute(m), second(s)
{
}

Clock::Clock(int h, int m, int s)
{
    hour = h;
    minute = m;
    second = s;
}

class A
{
private:
    const int SIZE;
    int &ref;

public:
    A(int s, int &r) : SIZE(s), ref(r)
    {
    }
};

class A
{
private:
    int x;
    int y;

public:
    A() : y(2), x(1) {}
};

初始化顺序看类内声明顺序，不看初始化列表书写顺序
const、引用、无默认构造成员必须用初始化列表

class X
{
private:
    string name;
    int code;

public:
    X(string n, int c) : name(n), code(c)
    {
    }

    X() : X("", 42)
    {
    }

    X(string s) : X(s, 0)
    {
    }
};

先执行被委托构造函数的初始化列表和函数体
再回到委托者自己的函数体

类名(const 类名 &对象名);

class Clock
{
private:
    int hour, minute, second;

public:
    Clock(const Clock &c)
    {
        hour = c.hour;
        minute = c.minute;
        second = c.second;
    }
};

Clock c1(8, 10, 20);
Clock c2(c1);
Clock c3 = c1;

void fun(Clock c)
{
}

fun(c1);

void fun(const Clock &c)
{
}

Clock makeClock()
{
    Clock c(1, 2, 3);
    return c;
}

复制构造：新对象诞生时，用旧对象初始化

~类名()
{
}

class A
{
public:
    ~A()
    {
        cout << "析构" << endl;
    }
};

void f()
{
    A a;
} // 离开作用域，a 析构

A *p = new A;
delete p; // delete 时调用析构

构造：出生
析构：死亡
new 出来的对象 delete 时才析构

class Point
{
private:
    int x, y;
};

class Line
{
private:
    Point p1;
    Point p2;
    double len;
};

先构造成员对象
再执行本类构造函数体

Line::Line(Point a, Point b) : p1(a), p2(b)
{
    // 这里执行时，p1 和 p2 已经构造好了
}

class Line
{
private:
    Point p1;
    Point p2;
};

先执行 Line 的析构函数体
再析构 p2
再析构 p1

Line::Line(const Line &L) : p1(L.p1), p2(L.p2)
{
    len = L.len;
}

组合构造：先人后己
组合析构：先己后人

class B;

class B;

class A
{
public:
    void f(B *b);
};

B *p;
B &r;

B obj; // 错，不知道 B 有多大

class B;

class A
{
public:
    void f(B *b)
    {
        b->g(); // 错，还不知道 B 里有没有 g
    }
};

struct S
{
    int x; // 默认 public
};

class C
{
    int x; // 默认 private
};

S s;
s.x = 1; // 对

C c;
c.x = 1; // 错

struct 默认 public
class 默认 private

union Mark
{
    char grade;
    bool pass;
    int percent;
};

union U
{
    int i;
    float f;
};

U u;
u.i = 10;
u.f = 2.2; // 此时 i 的值被覆盖

int x = 1; // 文件作用域

void f()
{
    int x = 2; // 局部作用域
    cout << x << endl; // 2
}

先声明，后使用
同一作用域不能重复声明同名变量
内层同名隐藏外层同名

int i = 5;

int main()
{
    {
        int i = 7;
        cout << i << endl; // 7
    }
    cout << i << endl; // 5
}

作用域：理论上有效的区域
可见性：当前位置实际能不能看见它

int g = 1;

void f()
{
    static int cnt = 0;
    cnt++;
}

void f()
{
    int x = 0;
} // x 在这里结束

static 活到程序结束
普通局部变量活到块结束

class A
{
private:
    static int count;
};

int A::count = 0;

class A
{
private:
    int count;
};

static int count;

A::count;
obj.count;
p->count;

int A::count = 0;

class A
{
public:
    static void show();
};

void A::show()
{
}

A::show();

A a;
a.show();

class A
{
private:
    int x;
    static int y;

public:
    static void f()
    {
        y = 1; // 对
        x = 2; // 错，没有 this，不知道是哪个对象的 x
    }
};

static void f(A a)
{
    cout << a.x << endl;
}

static void f() const; // 错

class Point
{
private:
    double x, y;

public:
    friend double dist(Point &a, Point &b);
};

double dist(Point &a, Point &b)
{
    double dx = a.x - b.x;
    double dy = a.y - b.y;
    return sqrt(dx * dx + dy * dy);
}

dist(p1, p2);

p1.dist(p2);

class A
{
    friend class B;

private:
    int x;
};

class A
{
    friend class B;
private:
    int x;
};

class B
{
public:
    void set(A &a, int v)
    {
        a.x = v;
    }
};

不传递
不对称
不继承

const 类名 对象名(参数);

const Point p(1, 2);

class Point
{
public:
    int getX() const;
    void setX(int x);
};

const Point p;
p.getX(); // 对
p.setX(1); // 错

返回类型 函数名(参数列表) const;

class Point
{
private:
    int x;

public:
    int getX() const;
};

int Point::getX() const
{
    return x;
}

int Point::getX() const
{
    x++; // 错
    return x;
}

void setX(int v);

int getX() const
{
    setX(1); // 错
}

void print();
void print() const;

常对象只能调常函数
常函数不能改对象
声明和定义都写 const

class A
{
private:
    const int SIZE;

public:
    A(int size) : SIZE(size)
    {
    }
};

A::A(int size)
{
    SIZE = size; // 错，函数体里是赋值，不是初始化
}

const 类型 &引用名 = 对象;

void printPoint(const Point &p)
{
    cout << p.getX() << endl;
}

Point p;
const Point &r = p;

const Point cp;
const Point &r = cp;

Point &r = cp; // 错

类对象参数优先考虑 const 引用

ClassName.h      类声明
ClassName.cpp    类成员函数定义
main.cpp         使用类

#ifndef POINT_H
#define POINT_H

class Point
{
private:
    int x, y;
public:
    Point(int x, int y);
    int getX() const;
};

#endif

#include "Point.h"

Point::Point(int x, int y) : x(x), y(y)
{
}

int Point::getX() const
{
    return x;
}

#include <iostream>
#include "Point.h"
using namespace std;

int main()
{
    Point p(1, 2);
    cout << p.getX() << endl;
}

#include <iostream>
#include "Point.h"

#define PI 3.14

const double PI = 3.14;

#ifdef DEBUG
cout << "debug info" << endl;
#endif

#ifndef POINT_H
#define POINT_H

// 头文件内容

#endif

#ifndef 没定义才进入
#define 定义宏
#endif 结束

void change(int a[])
{
    a[0] = 100;
}

int main()
{
    int x[3] = {1, 2, 3};
    change(x);
    cout << x[0] << endl; // 100
}

void f(int a[][4], int n)
{
}

数组名传参 = 传首地址
二维数组参数要写后面的维度

类名 数组名[大小];

Clock c[2];

Point p[2] = {Point(1, 2), Point(3, 4)};

Point p[2] = {Point(1, 2)};

class A
{
public:
    A(int x);
};

A a[10]; // 错，每个元素都需要默认构造，但没有

int *p[10];

int (*p)[3];

int *p[10];   // [] 优先，p 先和 [] 结合，所以 p 是数组
int (*p)[10]; // p 先和 * 结合，所以 p 是指针

int *p[10]：十个 int 指针
int (*p)[10]：一个指向十个 int 数组的指针

类名 *指针名;

Point p(1, 2);
Point *ptr = &p;

ptr->getX();

(*ptr).getX();

对象.成员
对象指针->成员

int Point::*p = &Point::x;

Point a;
a.*p = 10;

Point *pa = &a;
pa->*p = 20;

int (Point::*pf)() = &Point::getX;

(a.*pf)();
(pa->*pf)();

int *p = new int;
*p = 10;
delete p;

int *p1 = new int;    // 未初始化
int *p2 = new int();  // 初始化为 0
int *p3 = new int(5); // 初始化为 5

int *a = new int[10];
delete[] a;

int *a = new int[10]();

int *p = new int[10];
delete p; // 错，应该 delete[]

Student *s = new Student;
delete s;

new 和 delete 一对一
new[] 和 delete[] 一对一

#include <vector>

vector<元素类型> 名字(大小);

vector<int> a(10);

vector<int> b(10, 1);

a[0] = 5;
cout << a.size() << endl;

class A
{
    int x;
    double y;
};

class Array
{
private:
    int *p;
    int size;
};

a.p 和 b.p 指向同一片内存

class Array
{
private:
    int *p;
    int size;

public:
    Array(const Array &a)
    {
        size = a.size;
        p = new int[size];
        for (int i = 0; i < size; i++)
        {
            p[i] = a.p[i];
        }
    }
};

a.p 指向一片内存
b.p 指向另一片内存
内容相同，但空间独立

#include <string>

string s1;
string s2("China");
string s3 = "Wust";
string s4(s2);

s1 = "hello";
s2 = s1;

string s = s1 + s2;
s += "!";

cin >> s; // 遇到空格停止

getline(cin, s);

getline(cin, s, ',');

s[0] = 'H';
s.at(1) = 'e';

class 派生类名 : 继承方式 基类名
{
};

class Person
{
public:
    void eat();
};

class Student : public Person
{
public:
    void study();
};

Student s;
s.eat();
s.study();

吸收基类成员
改造基类成员
添加新成员

class B : public A {};
class C : protected A {};
class D : private A {};

公保公不变
私私保保
私不访

class Base {};
class Derived : public Base {};

Base b;
Derived d;

b = d;
Base &rb = d;
Base *pb = &d;

Derived *pd = &b; // 错

pb->baseFunc(); // 对
pb->derivedFunc(); // 错，pb 类型是 Base*

Derived d;
Base b = d;

b.display();

指针/引用保留动态类型
对象赋值会切片

Derived::Derived(参数) : Base(基类参数), member(成员参数)
{
    // 派生类新增成员初始化
}

class Base
{
public:
    Base(int x);
};

class Derived : public Base
{
private:
    int y;

public:
    Derived(int x, int y) : Base(x), y(y)
    {
    }
};

基类构造函数
成员对象构造函数
派生类构造函数体

class D : public B1, public B2 {};

派生类析构函数体
成员对象析构函数
基类析构函数

class Base
{
public:
    ~Base() { cout << "Base" << endl; }
};

class Derived : public Base
{
public:
    ~Derived() { cout << "Derived" << endl; }
};

Derived d;

Derived
Base

构造从上到下
析构从下到上

class Base
{
public:
    void f(int);
};

class Derived : public Base
{
public:
    void f(double);
};

Derived d;
d.f(3.14); // Derived::f(double)
d.f(1);    // 仍可能调用 Derived::f(double)，基类 f 被隐藏

d.Base::f(1);

重载：同一作用域，函数名相同，参数不同
隐藏：基类和派生类不同作用域，派生类同名成员挡住基类成员

class A
{
public:
    void f();
};

class B
{
public:
    void f();
};

class C : public A, public B
{
};

C c;
c.f(); // 错，不知道是 A::f 还是 B::f

c.A::f();
c.B::f();

class C : public A, public B
{
public:
    void f();
};

c.f(); // 调 C::f，无二义

class D : public B1, public B2
{
public:
    using B1::fun;
    using B1::nV;
};

class B
{
public:
    void fun();
};

class D : public B
{
public:
    using B::fun;
    void fun(int);
};

D d;
d.fun();  // B::fun
d.fun(1); // D::fun(int)

class B0 {};
class B1 : public B0 {};
class B2 : public B0 {};
class D : public B1, public B2 {};

class B0 {};
class B1 : virtual public B0 {};
class B2 : virtual public B0 {};
class D : public B1, public B2 {};

虚基类
非虚基类
成员对象
派生类自身

菱形继承怕多份共同基类
virtual 让共同基类只保留一份

重载：编译时决定
虚函数：运行时决定

返回类型 operator 运算符(参数列表)
{
}

class Complex
{
private:
    double real, imag;

public:
    Complex operator+(Complex c)
    {
        return Complex(real + c.real, imag + c.imag);
    }
};

c3 = c1 + c2;

c3 = c1.operator+(c2);

运算符重载本质是函数重载

Complex Complex::operator+(Complex c)
{
    return Complex(real + c.real, imag + c.imag);
}

class Complex
{
    friend Complex operator+(Complex a, Complex b);
};

Complex operator+(Complex a, Complex b)
{
    return Complex(a.real + b.real, a.imag + b.imag);
}

Clock& operator++()
{
    // 修改自己
    return *this;
}

Clock operator++(int)
{
    Clock old = *this;
    ++(*this);
    return old;
}

++a; // 先加，再用
a++; // 先用，再加

friend ostream& operator<<(ostream &out, const Complex &c);

ostream& operator<<(ostream &out, const Complex &c)
{
    out << "(" << c.real << "," << c.imag << ")";
    return out;
}

friend istream& operator>>(istream &in, Complex &c);

istream& operator>>(istream &in, Complex &c)
{
    in >> c.real >> c.imag;
    return in;
}

cout << c1 << c2;
cin >> c1 >> c2;

类名& operator=(const 类名 &rhs);

String& String::operator=(const String &rhs)
{
    if (this != &rhs)
    {
        delete[] s;
        s = new char[strlen(rhs.s) + 1];
        strcpy(s, rhs.s);
    }
    return *this;
}

a = b = c;

析构函数
复制构造函数
赋值运算符

class String
{
private:
    char *s;

public:
    String(const char *str);
    String(const String &rhs);
    String& operator=(const String &rhs);
    ~String();
};

有 new，就想 Big Three

String a("hello");
String b = a;
String c(a);

String a("hello");
String b("world");
b = a;

新对象诞生：复制构造
老对象改值：赋值运算符

String String::operator+(const String &rhs)
{
    ...
    return ans;
}

String& String::operator+=(const String &rhs)
{
    ...
    return *this;
}

s1 += s2 += s3;

char& String::operator[](int i)
{
    return s[i];
}

s[0] = 'A';

class Base
{
public:
    virtual void display();
};

class Derived : public Base
{
public:
    void display();
};

Base *p;
Derived d;
p = &d;
p->display(); // 调 Derived::display

Base b = d;
b.display();

虚函数：基类指针/引用看实际对象类型

class Base
{
public:
    virtual ~Base()
    {
    }
};

class Derived : public Base
{
public:
    ~Derived()
    {
    }
};

Base *p = new Derived;
delete p;

virtual 返回类型 函数名(参数列表) = 0;

class Shape
{
public:
    virtual double area() = 0;
};

Shape s; // 错

Shape *p;
Shape &r = circle;

class Circle : public Shape
{
private:
    double r;

public:
    double area()
    {
        return 3.14 * r * r;
    }
};

class A
{
public:
    virtual ~A() = 0;
};

A::~A()
{
}

= 0 表示纯虚
有纯虚函数就是抽象类
抽象类不能实例化，但可以有指针和引用

template <typename T>
返回类型 函数名(参数列表)
{
}

template <typename T>
T myAbs(T x)
{
    return x < 0 ? -x : x;
}

cout << myAbs(-5) << endl;     // T 是 int
cout << myAbs(-3.14) << endl;  // T 是 double

template <class T>

模板 = 类型参数化
用到具体类型时才生成具体函数

template <typename T1, typename T2>
T1 myMin(const T1 &a, const T2 &b)
{
    return a < b ? a : b;
}

myMin<int, double>(3, 5.0);
myMin<int>(3, 5.0);
myMin<double>(3, 5.0);

template <class T>
class Store
{
private:
    T item;

public:
    void PutElem(T x);
    T GetElem();
};

template <class T>
void Store<T>::PutElem(T x)
{
    item = x;
}

template <class T>
T Store<T>::GetElem()
{
    return item;
}

Store<int> s1;
Store<double> s2;
Store<Student> s3;

template <class T>
class Array
{
private:
    T *list;
    int size;

public:
    Array(int sz = 50);
    Array(const Array<T> &a);
    ~Array();
    Array<T>& operator=(const Array<T> &rhs);
    T& operator[](int i);
    int getSize() const;
    void resize(int sz);
};

template <class T>
Array<T>::Array(int sz)
{
    size = sz;
    list = new T[size];
}

template <class T>
Array<T>::~Array()
{
    delete[] list;
}

template <class T>
Array<T>::Array(const Array<T> &a)
{
    size = a.size;
    list = new T[size];
    for (int i = 0; i < size; i++)
    {
        list[i] = a.list[i];
    }
}

template <class T>
Array<T>& Array<T>::operator=(const Array<T> &rhs)
{
    if (this != &rhs)
    {
        delete[] list;
        size = rhs.size;
        list = new T[size];
        for (int i = 0; i < size; i++)
        {
            list[i] = rhs.list[i];
        }
    }
    return *this;
}

template <class T>
T& Array<T>::operator[](int i)
{
    return list[i];
}

a[3] = 10;

operator 类型()
{
    return 某个该类型的值;
}

template <class T>
Array<T>::operator T*()
{
    return list;
}

T* operator T*(); // 错

operator T*();

template <class T>
class Node
{
private:
    Node<T> *next;

public:
    T data;
    void InsertAfter(Node<T> *p);
    Node<T>* DeleteAfter();
};

template <class T>
void Node<T>::InsertAfter(Node<T> *p)
{
    p->next = next;
    next = p;
}

template <class T>
Node<T>* Node<T>::DeleteAfter()
{
    Node<T> *temp = next;
    if (next == NULL)
    {
        return NULL;
    }
    next = temp->next;
    return temp;
}

后进先出 LIFO

template <class T, int SIZE = 50>
class Stack
{
private:
    T list[SIZE];
    int top;
};

先进先出 FIFO

front = (front + 1) % SIZE;
rear = (rear + 1) % SIZE;

#include <vector>
#include <algorithm>

vector<int> a = {3, 1, 2};
sort(a.begin(), a.end());

vector<int> v;
set<int> s;
map<string, int> mp;

vector<int> v = {1, 2, 3};

for (vector<int>::iterator it = v.begin(); it != v.end(); ++it)
{
    cout << *it << endl;
}

for (auto it = v.begin(); it != v.end(); ++it)
{
    cout << *it << endl;
}

把容器和算法连接起来

sort(v.begin(), v.end());

struct Greater
{
    bool operator()(int a, int b)
    {
        return a > b;
    }
};

sort(v.begin(), v.end(), Greater());

#include <functional>
greater<int>()
less<int>()
negate<int>()

#include <iostream>

#include <fstream>

ofstream fout;
fout.open("out.txt");

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

int main()
{
    ofstream fout("out.txt");
    if (!fout)
    {
        cout << "Error opening file" << endl;
        return -1;
    }

    fout << "hello" << endl;
    fout.close();
    return 0;
}

包含头文件
定义文件流对象
打开文件
检查是否成功
读写数据
关闭文件

ifstream fin("in.txt");

string s;
getline(fin, s);

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

int main()
{
    ifstream fin("in.txt");
    if (!fin)
    {
        cout << "open failed" << endl;
        return -1;
    }

    string line;
    while (getline(fin, line))
    {
        cout << line << endl;
    }

    fin.close();
}

#include <sstream>

istringstream iss("1 56.7");
int a;
double b;
iss >> a >> b;

ostringstream oss;
oss << "a = " << 10;
string s = oss.str();

throw 异常;

try
{
}
catch (...)
{
}

try
{
    // 可能出错的代码
    throw 表达式;
}
catch (异常类型 变量名)
{
    // 处理异常
}

try
{
    int milk = 0;
    int biscuits = 10;
    if (milk <= 0)
    {
        throw biscuits;
    }
}
catch (int e)
{
    cout << e << " biscuits, and no milk" << endl;
}

进入 try
遇到 throw
停止 try 中后续语句
寻找匹配 catch
执行 catch
继续 catch 后面的代码

try
{
    ...
}
catch (int e)
{
}
catch (const char *s)
{
}
catch (...)
{
}

class A
{
public:
    ~A()
    {
        cout << "~A" << endl;
    }
};

void f()
{
    A a;
    throw 1;
}

void fun() throw(A, B, C);
void fun() throw();

基类
成员对象
本类

本类
成员对象
基类

虚基类
非虚基类
成员对象
本类

A b = a; // 复制构造
A b(a);  // 复制构造
b = a;   // 赋值，前提是 b 已存在

void f(A x);
f(a); // 复制构造

void f(const A &x);
f(a); // 不复制

Base b = derived;
b.f();

a + b       -> a.operator+(b) 或 operator+(a, b)
++a         -> a.operator++()
a++         -> a.operator++(0)
cout << a   -> operator<<(cout, a)
a[i]        -> a.operator[](i)

String String::operator+(const String &rhs)
{
    char *tmp = new char[strlen(s) + strlen(rhs.s) + 1];
    strcpy(tmp, s);
    strcat(tmp, rhs.s);
    String ans(tmp);
    delete[] tmp;
    return ans;
}

String& String::operator+=(const String &rhs)
{
    char *tmp = new char[strlen(s) + strlen(rhs.s) + 1];
    strcpy(tmp, s);
    strcat(tmp, rhs.s);
    delete[] s;
    s = tmp;
    return *this;
}

char& String::operator[](int i)
{
    return s[i];
}

ostream& operator<<(ostream &out, const String &str)
{
    out << str.s;
    return out;
}

template <class T>
T& Array<T>::operator[](int i)
{
    assert(i >= 0 && i < size);
    return list[i];
}

template <class T>
const T& Array<T>::operator[](int i) const
{
    assert(i >= 0 && i < size);
    return list[i];
}

inline：短小频繁函数，建议编译器展开
默认参数：从右往左给，中间不能断
函数重载：看参数，不看返回值
构造函数：对象出生时自动调用
析构函数：对象死亡时自动调用
复制构造：新对象用旧对象初始化
赋值运算符：两个旧对象之间赋值
初始化列表：const、引用、无默认构造成员必须用
static 数据成员：类内声明，类外定义
static 成员函数：无 this，不能直接访问非 static 成员
friend：单向、不传递、不继承
常对象：只能调用常成员函数
new/delete 配对，new[]/delete[] 配对
浅复制：复制指针地址
深复制：重新分配空间复制内容
继承权限：公保公不变，私私保保，私不访
对象切片：派生类赋给基类对象，只保留基类部分
虚函数：通过基类指针/引用调用，看实际对象
虚析构：多态基类最好写 virtual 析构
纯虚函数：=0，有纯虚函数就是抽象类
operator[] 返回引用，才能作为左值
operator<< 返回 ostream&
模板：类型参数化，定义通常放头文件
异常：try -> throw -> catch