1
2
3
//相当于创建一个 static_cast<double>类型的匿名对象赋值给 d2
double d2 = static_cast<double>(i);
int* p2 = static_cast<int*>(i);//无法转换，会报错

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <bits/stdc++.h>
using namespace std;
class Base {
   public:
    void f(int a) { cout << "base:" << a << endl; }
};
class Child : public Base {
   public:
    void f() { cout << "extend" << endl; }
};
int main() {
    Base b;
    b.f(1);
    Child c;
    c.f();
    c.f(1); // 编译错误
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <bits/stdc++.h>
using namespace std;
template <class T>
T add(T p, T q) {
    return p + q;
}

class Point {
   public:
    int x, y;
    Point(int x, int y) : x(x), y(y) {}
    Point operator+(Point b) { return Point(x + b.x, y + b.y); }
};
int main() {
    Point a(1, 2);
    Point b(2, 1);
    Point c(1, 0);
    c = add(a, b);
    cout << c.x << " " << c.y << endl;
    cout << add(1, 3) << endl;
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <bits/stdc++.h>
using namespace std;
void print() { cout << "empty" << endl; }
template <class T, class... Args>
void print(T header, Args... rest) {
    cout << "header " << header << endl;
    print(rest...);
}

int main() {
    // print();
    // print(1);
    print(1, 2, 3);

    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <iostream>
using namespace std;
class Animal {
   public:
    // 如果下面这行没有 virtual, 则最终只会输出两遍'animal'
    virtual void bark() { cout << "animal" << endl; };
};
class Cat : public Animal {
   public:
    void bark() { cout << "miao~" << endl; }
};
class Dog : public Animal {
   public:
    void bark() { cout << "wang!" << endl; }
};
// 父类指针
void getSound(Animal& animal) { animal.bark(); }
int main() {
    Dog dog;
    Cat cat;
    getSound(dog); // wang!
    getSound(cat); // miao~
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
try
{
   // 保护代码，中间含有 throw, 用以抛出异常
}catch( ExceptionName e1 )
{
   // catch 块
}catch( ExceptionName e2 )
{
   // catch 块
}catch( ExceptionName eN )
{
   // catch 块
}catch(...){
    // 捕获任意异常
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// 实例
#include <iostream>
using namespace std;
int division(int a, int b) {
    if (b == 0) {
        throw "Division by zero condition!";
    }
    return a / b;
}
int main() {
    int x = 100;
    int y = 0;
    try {
        cout << division(100, 2) << endl;
        division(x, y);
        cout << division(100, 2) << endl;
    } catch (const char *s) {
        std::cerr << s << '\n';
    }

    return 0;
}

1
2
3
// func 可能拋出 int 型、double 型以及 A、B、C 三种类型的异常。
void func() throw (int, double, A, B, C); 
void func() throw (int, double, A, B, C){...}

1
2
3
4
// func 函数不会拋出任何异常。
void func() throw ();
// c++11 中使用 noexpection 表示不抛出任何异常
void func() noexcept; 

1
2
3
4
5
6
7
8
enum <类型> {<枚举常量表>}

// 定义枚举类型 week, 默认是 0 1 2 3 ... 6
enum week {Sun, Mon, Tue, Wed, Thu, Fri, Sat}; 

// 若指定一个元素的值，则后续（如果没有指定的话）的值会根据其值+1
// 如下代码就得到 7 1 2 3 4 5 6
enum week {Sun=7, Mon=1, Tue, Wed, Thu, Fri, Sat};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdio.h>
 
void main()
{
    // 在 release 模式下，编译器会自动优化，对于没有 volatile 修饰的 i, 读取完 i 之后，会把 i 的值存在寄存器中，然后从寄存器赋值给 b
    int i = 10;
    // 如果换成下面这一句，那么 最后答案就是 10,32, 否则就是 10,10
    // volatile int i = 10;
    int a = i;
 
    printf("i = %d", a);
 
    // 下面汇编语句的作用就是改变内存中 i 的值为 32
    // 但是又不让编译器知道
    __asm {
        mov dword ptr [ebp-4], 20h
    }
 
    int b = i;
    printf("i = %d", b);
}

1
2
3
4
5
6
7
8
9
x = y = 0;

// 以下在线程 1 进行
x = 1;
r1 = y;

// 以下在线程 2 进行
y = 1;
r2 = x;

1
2
3
4
5
6
7
8
9
x = y = 0;

// 以下在线程 1 进行
r1 = y;
x = 1;

// 以下在线程 2 进行
y = 1;
r2 = x;

1
2
3
4
5
6
7
8
9
10
11
12
// static 成员必须得在类外进行初始化，否则初次使用时会报链接错误 (undefined reference)
#include <bits/stdc++.h>
using namespace std;
class Student {
   public:
    static int count;
};
int Student::count = 0;
int main() {
    cout << Student::count << endl;
    return 0;
}

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
#include <bits/stdc++.h>
using namespace std;
const char* inFile = "./FileForIOTest/in.txt";
const char* outFile = "./FileForIOTest/out.txt";

void TestFstream() {
    /* 写文件流 */
    // 也可写成 ifstream is(infile);
    ifstream is;
    is.open(inFile, ios::in);
    if (!is) {
        cout << "打开失败" << endl;
    } else {
        string buff;
        getline(is, buff);
        cout << buff << endl;

        char a[100];
        is.getline(a, sizeof a);
        cout << a << endl;

        // is.read()
        char ch[100];
        is.read(ch, sizeof ch);
        cout << ch << endl;

        // 这种方式会被空格和回车分开
        char b[100];
        is >> b;
        cout << b << endl;
        //  记得关闭文件流
        is.close();
    }

    /*读文件流*/
    ofstream os;
    os.open(outFile, ios::out);
    if (!os) {
        cout << "打开失败" << endl;
    } else {
        char a[100] = "some words in line";
        os.write(a, strlen(a));

        os << "Write one line" << endl;

        os.close();
    }
}
void TestFopen() {
    // 文件指针，使用 fopen fscanf fprintf
    FILE* fpr = fopen(inFile, "r");
    char s[100];
    fscanf(fpr, "%s", s);
    cout << s << endl;
    fclose(fpr);

    FILE* fpw = fopen(outFile, "a");
    fprintf(fpw, "writen by fopen\n");
    fclose(fpw);
};
void TestFreopen() {
    // 注：此重定向不可逆
    // 发生了一个迷惑行为，如果注释掉 TestFstream, 则一切正常，如果不注释
    freopen(inFile, "r", stdin);
    if (freopen(outFile, "a", stdout) == NULL) {
        fprintf(stderr, "error redirecting stdout\n");
    }
    // printf 可以，但是 cout 不行，即使不用 endl, 改成、n 也不行，原因尚未查明
    cout << "From Freopen\n";
    // printf("From Freopen\n");
    fclose(stdin);
    fclose(stdout);
}
int main() {
    TestFstream();
    TestFopen();
    TestFreopen();
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
up = nullptr;//置为空，释放 up 指向的对象
up.reset();//释放 up 指向的对象
up.release();//放弃控制权，返回裸指针，并将 up 置为空

// 转移控制权
std::unique_ptr<int> up1(new int(42));
std::unique_ptr<int> up2(up1.release());

// 使用 move 也行
// std::unique_ptr<int> up2(std::move(up1));
// 或者分两步执行也可以
// std::unique_ptr<int> up2;
// up2.reset(up1.release());

1
2
3
4
5
6
7
8
9
10
#include <stdio.h>
 
int a[2] = {1,2};
int main(){
        printf("a = %p\n", a); // I
        printf("&a = %p\n", &a); // II
        printf("a + 1 = %p\n", a + 1);// III
        printf("&a + 1 = %p\n", &a + 1);// IV
        return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 省略了一些与本主题无关的变量
0804a01c A _edata
0804a024 A _end
080484ec T _fini
08048508 R _fp_hw
080482bc T _init
08048330 T _start
0804a014 D a // a 变量保存在虚拟地址 0x0804a014 中
0804a01c b completed.7021
0804a00c W data_start
0804a020 b dtor_idx.7023
080483c0 t frame_dummy
080483e4 T main // main 函数的地址
         U printf@@GLIBC_2.0

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
	.file	"name_of_array.c"
.globl a
	.data
	.align 4
	.type	a, @object
	.size	a, 8 // 从这里我们便知道 sizeof(a) 等于 8
a:
	.long	1 // 从这里可以看出，编译器直接把 .c 文件中的 int 转化为 long 型
	.long	2
	.section	.rodata
.LC0:
	.string	"a = %p\n"
.LC1:
	.string	"&a = %p\n"
.LC2:
	.string	"a + 1 = %p\n"
.LC3:
	.string	"&a + 1 = %p\n"
	.text
.globl main
	.type	main, @function
main:
	pushl	%ebp
	movl	%esp, %ebp
	andl	$-16, %esp
	subl	$16, %esp
	movl	$.LC0, %eax // I 所对应的汇编代码，movl 是前者赋值给后者
	movl	$a, 4(%esp)
	movl	%eax, (%esp)
	call	printf
	movl	$.LC1, %eax // II 所对应的汇编代码
	movl	$a, 4(%esp)
	movl	%eax, (%esp)
	call	printf
	movl	$.LC2, %eax // III 所对应的汇编代码
	movl	$a+4, 4(%esp)
	movl	%eax, (%esp)
	call	printf
	movl	$a+8, %edx // IV 所对应的汇编代码
	movl	$.LC3, %eax
	movl	%edx, 4(%esp)
	movl	%eax, (%esp)
	call	printf
	movl	$0, %eax
	leave
	ret
	.size	main, .-main
	.ident	"GCC: (Ubuntu 4.4.3-4ubuntu5) 4.4.3"
	.section	.note.GNU-stack,"",@progbits

1
2
3
4
5
6
7
8
9
10
11
12
for (auto it = l.begin(); it != l.end();) {
    cout << "cur: " << *it << endl;
    if (*it == 3) {
        // it = l.erase(it);

        auto nxt = next(it);
        l.erase(it);
        it = nxt;
    } else {
        ++it;
    }
}

1
2
3
4
5
6
7
8
int a = 1, b = 2;
auto l = [a, b]() { return a + b; };
auto r = [&a, &b]() { return a + b; };
cout << l() << endl;  // 3
b = 3;
cout << l() << endl;  // 仍然是 3

cout << r() << endl;  // 4, 因为是传引

1
2
3
4
5
6
7
8
9
10
11
int x;
bool biggerThanX(int& p) { return p > x; }
int main(){
    vector<int> v;
    v.push_back(3);
    v.push_back(7);
    x = 5;
    auto ans = find_if(v.begin(), v.end(), biggerThanX);
    cout << *ans << endl;
    return 0;
}

1
2
3
4
5
6
7
8
9
10
int main() {
    vector<int> v;
    v.push_back(3);
    v.push_back(7);
    int x;
    x = 5;
    auto ans = find_if(v.begin(), v.end(), [x](int& p) { return p > x; });
    cout << *ans << endl;
    return 0;
}

1
2
3
4
5
unique_ptr<int> sp(new int(88) ); 
vector<unique_ptr<int> > vec; 
vec.push_back(std::move(sp)); 
// vec.push_back( sp ); error:
// cout << *sp << endl; 

1
2
3
4
shared_ptr<A> sp1(new A(2)); //A(2) 由 sp1 托管，
shared_ptr<A> sp2(sp1);       //A(2) 同时交由 sp2 托管
shared_ptr<A> sp3;
sp3 = sp2;   //A(2) 同时交由 sp3 托管

1
2
3
4
5
6
class A {};
// 一定要注意这里是返回一个对象,而不是对象的地址
// new A(); 才是返回地址
A f() { 
    return A();
}

1
2
3
4
5
vector<MyString> vecStr;
vecStr.reserve(1000); //先分配好 1000 个空间
for(int i=0;i<1000;i++){
    vecStr.push_back(MyString("hello"));
}

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
class MyString
{
public:
    static size_t CCtor; //统计调用拷贝构造函数的次数
    static size_t MCtor; //统计调用移动构造函数的次数
    static size_t CAsgn; //统计调用拷贝赋值函数的次数
    static size_t MAsgn; //统计调用移动赋值函数的次数
    char * m_data;
public:
    // 构造函数
   MyString(const char* cstr=0){
       if (cstr) {
          m_data = new char[strlen(cstr)+1];
          strcpy(m_data, cstr);
       }
       else {
          m_data = new char[1];
          *m_data = '\0';
       }
   }

   // 拷贝构造函数
   MyString(const MyString& str) {
       CCtor ++;
       m_data = new char[ strlen(str.m_data) + 1 ];
       strcpy(m_data, str.m_data);
   }
   // 移动构造函数
   MyString(MyString&& str) noexcept
       :m_data(str.m_data) {
       MCtor ++;
       str.m_data = nullptr; //不再指向之前的资源了
   }

   // 拷贝赋值函数 =号重载
   // 这个不能对str进行修改

   MyString& operator=(const MyString& str){
       CAsgn ++;
       if (this == &str) // 避免自我赋值！!
          return *this;

       delete[] m_data;
       m_data = new char[ strlen(str.m_data) + 1 ];
       strcpy(m_data, str.m_data);
       return *this;
   }

   // 移动赋值函数 =号重载 当且仅当等号右侧是右值的时候
   // 比如 s = MyString("new string") 时候就会调用这个函数
   MyString& operator=(MyString&& str) noexcept{
       MAsgn ++;
       if (this == &str) // 避免自我赋值！!
          return *this;

       delete[] m_data;
       m_data = str.m_data;
       str.m_data = nullptr; //不再指向之前的资源了
       return *this;
   }

   ~MyString() {
       delete[] m_data;
   }

   char* get_c_str() const { return m_data; }
private:
   char* m_data;
};
size_t MyString::CCtor = 0;
size_t MyString::MCtor = 0;
size_t MyString::CAsgn = 0;
size_t MyString::MAsgn = 0;

1
2
3
4
5
vecStr2.reserve(1000); //先分配好 1000 个空间
for(int i=0;i<1000;i++){
    MyString tmp("hello");
    vecStr2.push_back(std::move(tmp)); //调用的是移动构造函数
}

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
#include <bits/stdc++.h>
using namespace std;
// 接收左值的函数 f()
template <typename T>
void f(T &) {
    cout << "f(T &)" << endl;
}

// 接收右值的函数 f()
template <typename T>
void f(T &&) {
    cout << "f(T &&)" << endl;
}
// 万能引用，转发接收到的参数 param
template <typename T>
void PrintType(T &&param) {
    f(param);  // 将参数 param 转发给函数 void f()
}

int main(int argc, char *argv[]) {
    int a = 0;
    PrintType(a);       //传入左值
    PrintType(int(0));  //传入右值
}

1
2
3
4
5
template<typename T>
T&& forward(T &param)
{
	return static_cast<T&&>(param);
}