inline 额外的区别#

• inline 只意味着在程序中函数的定义可以出现很多次。

直接转载至此处

作者：吼姆桑 链接：https://www.zhihu.com/question/24185638/answer/2404153835 来源：知乎

1
inline int foo(int x) {
2
    static int factor = 1;
3
    return x * (factor++);
4
}
5

6
/* bar1.cc */
7
#include "foo.h"
8
int bar1() {
9
    return foo(1);
10
}
11

12
/* bar2.cc */
13
#include "foo.h"
14
int bar2() {
15
    return foo(2);
16
}
17

18
/* main.cc */
19
int Bar1(), Bar2();
20
int main() {
21
    return Bar1() + Bar2();
22
}

1
g++ -c main.cc bar1.cc bar2.cc -fno-gnu-unique  # ok
2
g++ -o main main.o bar1.o bar2.o    # ok
3
./main; echo $? # 5
4
readelf -s main

1
Num:    Value          Size Type    Bind   Vis      Ndx Name
2
...
3
49: 0000000000004010     4 OBJECT  WEAK   DEFAULT   23 _ZZ3FooiE6factor
4
...
5
53: 000000000000115f    32 FUNC    WEAK   DEFAULT   14 _Z3Fooi
6
...

1
inline int Foo(int x) {
2
    static int factor = 1;
3
    return x * (factor++);
4
}
5
int Bar1() {
6
    return Foo(1);
7
}
8

9
/* bar2.cc */
10
inline int Foo(int x) {
11
    static int factor = 2;
12
    return x * (factor++);
13
}
14
int Bar2() {
15
    return Foo(2);
16
}
17

18
/* main.cc */
19
int Bar1(), Bar2();
20
int main() {
21
    return Bar1() + Bar2();
22
}

1
g++ -o main main.cc bar1.cc bar2.cc -fno-gnu-unique # ok
2
./main; echo $? # 5
3
g++ -o main main.cc bar2.cc bar1.cc -fno-gnu-unique # ok
4
./main; echo $? # 8

1
struct Foo {
2
    inline static int foo = 1;
3
};
4
/* bar1.cc */
5
#include "foo.h"
6
int Bar1() { return Foo::foo + 1; }
7
/* bar2.cc */
8
#include "foo.h"
9
int Bar2() { return Foo::foo + 2; }
10
/* main.cc */
11
int Bar1(), Bar2();
12
int main() {
13
    return Bar1() + Bar2();
14
}

1
g++ -std=c++17 -c main.cc bar1.cc bar2.cc # ok
2
g++ -std=c++17 -o main main.o bar1.o bar2.o # ok

1
# 以下为 readelf -sS bar1.o | grep foo 和readelf -sS bar2.o的内容
2
Section Headers:
3
[Nr] Name               Type             Address           Offset
4
...
5
[ 6] .data._ZN3Foo3fooE PROGBITS         0000000000000000  0000005c
6
...
7
Symbol table '.symtab' contains 13 entries:
8
Num:    Value          Size Type    Bind   Vis      Ndx Name
9
...
10
11: 0000000000000000     4 OBJECT  WEAK   DEFAULT    6 _ZN3Foo3fooE
11
# 以下为readelf -s main | grep foo
12
Num:    Value          Size Type    Bind   Vis      Ndx Name
13
...
14
0000000000004010     4 OBJECT  WEAK   DEFAULT   23 _ZN3Foo3fooE

1
#define some_predefined_macro   2022L
2

3
namespace libfoo {
4
#if some_predefined_macro >= 2022L
5
    inline
6
#endif
7
    namespace libfoo_2022 {
8
        int foo(int);       // better foo
9
        float foo(float);   // new foo
10
    }
11
#if some_predefined_macro >= 2019L && some_predefined_macro < 2022L
12
    inline
13
#endif
14
    namespace libfoo_2019 {
15
        int foo(int);   // old foo
16
    }
17
// other versions ...
18
}
19

20
using namespace libfoo;
21
int main() {
22
    printf("foo(5) = %d\n", foo(5));    // refer to int libfoo::libfoo_2022::foo(int);
23
    // ...
24
}

1
namespace libfoo {
2
    namespace libfoo_2022 {
3
        template <typename T>
4
        T &foo(T &);
5
    }
6
    using namespace libfoo_2022;
7
}
8

9
namespace libfoo {
10
    template <>
11
    float &foo<float>(float &);
12
}

1
namespace libfoo {
2
    class Bar1 {};
3
    namespace libfoo_2022 {
4
        void foo1(Bar1);
5
        class Bar2 {};
6
    }
7
    using namespace libfoo_2022;
8
    void foo2(Bar2);
9
}
10

11
int main()
12
{
13
    libfoo::Bar1 bar1;
14
    libfoo::Bar2 bar2;
15
    (void)foo1(bar1);    // compile error
16
    (void)foo2(bar2);    // compile error
17
    ...
18
}

1
namespace libfoo {
2
    class Bar1 {};
3
    inline namespace libfoo_2022 {
4
        void foo1(Bar1);
5
        class Bar2 {};
6
        template <typename T>
7
        T &foo(T &);
8
    }
9
    void foo2(Bar2);
10
}
11

12
namespace libfoo {
13
    template <>
14
    float &foo<float>(float &);
15
}
16

17
int main() {
18
    libfoo::foo(3.2);       // call specialized libfoo::libfoo_2022::foo
19
    libfoo::Bar1 bar;
20
    libfoo::Bar2 bar2;
21
    foo1(bar1);             // call lib::libfoo_2022::foo1
22
    foo2(bar2);             // call lib::foo2
23
    ...
24
}

1
namespace mylib {
2
    namespace v1 {
3
        struct Foo { void old_api(); };
4
    }
5

6
    inline namespace v2 {         // 当前默认版本
7
        struct Foo { void new_api(); };
8
    }
9
}
10

11
// 用户代码：
12
mylib::Foo x;    // 实际是 mylib::v2::Foo
13
x.new_api();     // 未限定查找能直接用 v2 的名字
14
// 仍可显式用老版本：
15
mylib::v1::Foo y;
16
y.old_api();

typedef和define（宏）有什么区别#

• 用法不同：typedef用来定义一种数据类型的别名，增强程序的可读性。define主要用来定义常量，以及书写复杂使用频繁的宏。
• 执行时间不同：typedef是编译期处理，有类型检查的功能。define是宏定义，是预编译的部分，其发生在编译之前，只是简单的进行字符串的替换，不进行类型的检查。
• 作用域不同：typedef有作用域限定。define不受作用域约束，只要是在define声明后的引用都是正确的。
• 对指针的操作不同：typedef和define定义的指针时有很大的区别。

注意：typedef定义是语句，因为句尾要加上分号。而define不是语句，千万不能在句尾加分号。

如何加深理解移动构造和拷贝构造#

1
class myobj{
2
    public:
3
        myobj(int x):val(new int(x)){}
4
        int& getval(){
5
            return *val;
6
        }
7
        myobj(const myobj& obj){            //拷贝构造
8
            val = new int(*obj.val);
9
        }
10
        myobj& operator=(const myobj & rhs){      //拷贝赋值
11
            if(this == &rhs){
12
                return *this;
13
            }
14
            delete this->val;
15
            val = new int(*rhs.val);
16
            return *this;
17
        }
18
        myobj(myobj&& obj){                //移动构造
19
            cout <<"mv" << endl;
20
            val = obj.val;
21
            obj.val = nullptr;
22
        }
23
        myobj& operator=(myobj&& rhs){          //移动赋值
24
            cout <<"mv=" << endl;
25
            if(this == &rhs){
26
                return *this;
27
            }
28
            if(this->val != nullptr){
29
                delete val;
30
            }
31
            val = rhs.val;
32
            rhs.val = nullptr;
33
            return *this;
34

35
        }
36
        ~myobj(){
37
            delete val;
38
            val = nullptr;
39
        }
40

41

42
        int* val;
43

44
};
45

46
int main(){
47
    myobj a(5);
48
    myobj b(10);
49
    cout << a.getval() << endl;
50
    myobj c(a);              //拷贝构造
51
    cout << c.getval() << endl;
52
    myobj d = c;            //拷贝构造。因为d对象之前不存在。
53
    cout << d.getval() << endl;
54
    d = b;                //拷贝赋值
55
    cout << d.getval() << endl;
56
    myobj e = move(a);          //移动构造。因为e对象之前不存在。在这之后不可访问a，因为a所有权已被转移
57
    cout << e.getval() << endl;
58
    d = move(b);            //移动赋值。在这之后不可访问b,因为b所有权已被转移
59
    cout << d.getval() << endl;
60
    return 0;
61
}

首先我们要强化记忆，什么叫构造函数。构造函数就是创建对象的时候调用的。我们这里有一个类，里面有一根指针。首先，我们既然是构造，那么拷贝构造和默认构造都要对变量（指针）初始化（分配内存）。所以这里拷贝构造和默认构造都是new的。因为我们都是无中生有

那么移动构造和拷贝构造的区别在哪呢？

什么时候我们想要移动？假如我们要转移所有权，我们这时候会调用移动构造。也是无中生有。但是由于转移所有权，所以我们不需要new。我们只需要把原来指针指向的地址赋值给我们新变量的对应变量上即可。移动之后，因为我们的目的是转移所有权，所以应当对原对象的对应指针变量置空。

拷贝赋值和移动赋值。

• 拷贝赋值我们首先要检测自我赋值。通过地址来判断。如果是一个地址互相赋值，那么什么都不做。然后我们首先把自己的东西清理掉，也就是自己指针指向的资源释放掉。然后，由于我们是拷贝，不是移动。所以我们依旧要开辟新空间，把原来对象的指针指向的值复制过来。

• 移动赋值，我们首先也要检测自我赋值。然后也要先把自己的东西清理掉，也就是自己指针指向的资源释放掉。然后，由于我们是移动，所以我们直接复制指针而不是指针指向的值。然后把源对象的指针置空，因为我们是转移所有权。

• 返回值：

  • 构造函数，无论是默认构造，拷贝构造还是移动构造，函数都无返回值。

  • 赋值操作符，无论是拷贝赋值还是移动赋值，我们为了链式调用，也避免不必要的拷贝，都应该返回对象的引用。

• 形参：

  • 拷贝构造和拷贝赋值，应该接受对象的常引用。

  • 移动构造和移动赋值因为涉及到对源对象的修改，即 对源成员变量（指针）置空，所以不能是常量。而且要接收右值。因为是移动。

• 什么时候该触发移动构造呢？

  • 如果临时对象即将消亡，并且它里面的资源是需要被再利用的，这个时候我们就可以触发移动构造。

    • 比如vector.push_back(obj(8));这就是往容器添加一个临时对象。这时候如果此临时对象有移动构造，则调用完默认构造后，直接触发移动构造进行搬移省去一次内存分配。否则需要调用拷贝构造。

  • 移动构造在使用vector的情况下，一般是vector扩容的时候重新分配内存的时候使用，如果元素的自定义类型有移动构造就会用移动构造。没有就是拷贝构造。这里的移动构造必须是noexcept

1
class myobj{
2
    public:
3
        int val; //基本数据类型
4
        string str; //自定义类型可移动
5
        unique_ptr<int>u_ptr = nullptr; //智能指针，也算自定义类型可移动
6

7
        myobj(int x, const string& rhsstr, int num): val(x), str(rhsstr), u_ptr(make_unique<int>(num)){
8
            cout << "const" << endl;
9
        }
10
        myobj(myobj&& rhs) = default; //强制生成移动构造。
11
};
12
int main(){
13
    myobj obj(4, "abc", 22);
14
    cout << *obj.u_ptr << endl;
15
    cout << obj.str << endl;
16
    return 0;
17
}
18
/*
19
输出
20
const
21
22
22
abc
23
*/

1
int main(){
2
    myobj obj(4, "abc", 22);
3
    cout << *obj.u_ptr << endl;
4
    myobj obj1(move(obj)); //移动后
5
    if(obj.u_ptr != nullptr){
6
        cout <<"not null" << endl;
7
    }
8
    else{
9
        cout <<"null" << endl;
10
    }
11
    cout << obj.str << endl;
12
    return 0;
13
}
14
/*
15
输出
16
const
17
22
18
null
19
(这行是空字符串)
20

21
*/

1
class myobj{
2
    public:
3
        int val; //基本数据类型
4
        string str; //自定义类型可移动
5
        int* ptr = nullptr; //注意此处替换为原始指针
6

7
        myobj(int x, const string& rhsstr, int* num): val(x), str(rhsstr), ptr(num){
8
            cout << "const" << endl;
9
        }
10
        myobj(myobj&& rhs) = default;
11
        ~myobj(){
12
            delete ptr;
13
            ptr = nullptr;
14
        }
15
};
16
int main(){
17
    myobj obj(4, "abc", new int(22));
18
    cout << *obj.ptr << endl;
19
    if(obj.ptr != nullptr){
20
        cout <<"not null" << endl;
21
    }
22
    else{
23
        cout <<"null" << endl;
24
    }
25
    cout << obj.str << endl;
26
    return 0;
27
}
28
/*
29
输出
30
const
31
22
32
notnull
33
abc
34
*/

1
int main(){
2
    myobj obj(4, "abc", new int(22));
3
    cout << *obj.ptr << endl;
4
    myobj obj1(move(obj));
5
    cout << *obj1.ptr << endl;
6
    if(obj.ptr != nullptr){
7
        cout <<"not null" << endl;
8
    }
9
    else{
10
        cout <<"null" << endl;
11
    }
12
    cout << obj.str << endl;
13
    return 0;
14
}
15
/*
16
输出
17
const
18
22
19
22 //此行为obj1的输出。也是22
20
notnull
21
(这行是空字符串)
22
*/

1
myobj(myobj&& rhs):
2
    val(move(rhs.val)), //基本数据类型，这么写永远不会错。虽然没什么用。
3
    str(move(rhs.str)),
4
    ptr(move(rhs.ptr)){ //原始指针类型，这么写永远不会错。虽然没什么用。
5
        rhs.ptr = nullptr;
6
}

1
int main(){
2
    myobj obj(4, "abc", new int(22));
3
    myobj obj1(move(obj));
4
    cout << *obj1.ptr << endl;
5
    if(obj.ptr != nullptr){
6
        cout <<"not null" << endl;
7
    }
8
    else{
9
        cout <<"null" << endl;
10
    }
11
    cout << obj1.str << endl;
12
    return 0;
13
}
14
/*
15
输出
16
const
17
22 //此行为obj1的输出。也是22
18
null //obj的指针已经空了。
19
abc //此行为obj1的字符串。正确移动了。
20
*/

for循环#

1
for ( init; condition; increment )
2
{
3
   statement(s);
4
}

for循环的更新条件（第三个条件）是迭代之后执行的，也就是最后执行的。

1
int func(int x) {
2
    cout <<"call" << endl;
3
    return 5;
4
}
5
int main() {
6

7
    for (int i = 0; i < func(i); i++) {
8
        cout << "for" << endl;
9
    }
10
    return 0;
11
}

i++和++i#

• ++i ++i 先自加，再赋值。

1
#include<stdio.h>
2
int main()
3
{
4
    int i = 0;
5
    int j = ++i;
6
    cout << i << j <<endl;
7
    return 0;
8
}

此时输出 i=1 j=1

• i++

​ i++ 先赋值，再自加。

1
#include<stdio.h>
2
int main()
3
{
4
    int i = 0;
5
    int j = i++;
6
    cout << i << j <<endl;
7
    return 0;
8
}

此时输出 i=1 j=0

i++是右值，++i是左值

在内置类型的情况下

1
int a = i++;

这句话在编译器眼里是下面这样的两句话：

1
int a = i;
2
i++;

而

1
int a = ++i;

在编译器眼里则是这样：

1
i++;
2
int a = i;

i++和++i在非自定义类型的情况下，只要不发生赋值，则原理没有差别。但是性能有差别。

我们深入看一下自定义类型的情况

1
struct mybase
2
{
3
    // 前置++
4
    mybase& operator++()
5
    {
6
        data++;
7
        return *this;
8
    }
9

10
    // 后置++
11
    const mybase operator++(int) //注意返回const
12
    {
13
        auto tmp = *this;
14
        // 执行++有两种选择, data++或者调用上面的前置++
15
        data++;
16

17
        return tmp; //注意这里注意这里temp是局部变量，不可返回引用！！
18
    }
19

20
    int data = 0;
21
};

注意这里后置的++我们有一个非常奇怪的写法。我们用一个临时变量保存了自己，然后再把自己的值+1，然后返回一个自己的拷贝。不能返回引用！因为这里的temp是临时变量，返回引用就炸了

同时应为其添加const。原因是i++++这样的调用并不应该合法。首先因为它不符合如int这样的内置类型的语义。其次，i++++的第二个++是作用于i++返回值的临时对象身上的，所以最终i也只会被++一次。

这也就是为什么i++先赋值再自增了。因为我们赋值过去的是一个没有自增的自己。

这也是为什么i++是一个右值。因为他符合了右值的定义之一：返回了一个非引用类型的 函数调用。因为++本身也可以重载，也是函数调用。他返回了一个临时对象的自己。

所以++i反而看起来非常简单。我们先给自己+1然后返回自己的引用。这也是为什么++i是先自增再赋值，也是为何++i是左值。

编译过程#

记住ISO即可

.h/c/cpp通过 预处理器处理为.i的预处理代码

.i的预处理代码通过编译器处理为.s的汇编代码

.s的汇编代码通过汇编器处理为.o的目标代码（可重定位二进制）

.o的目标代码通过链接器生成可执行文件.exe/.out （如果没有外部代码或者dll/lib库文件就直接生成可执行文件）

从cpp源代码到可执行程序经过了哪些过程?#

A: 在Linux系统下从.cpp开始, 经过

1.预处理阶段, 在这部分主要处理include的文件包含关系, 还有宏的替换, 做完.cpp变为.i 2.编译阶段会做语法分析还有优化之类的, 将代码转换为汇编, 做完.i变.s 3.汇编阶段会把前面得到的汇编代码转换为二进制的机器代码, 做完.s变.o 4.最后运行链接器将所有可重定位文件合并为一个可执行文件, 做完.o变prog. 对于可执行文件可以调用系统中被称为加载器的函数来将文件复制到内存并开始执行.

其中自己了解较多的是最后的链接阶段. 链接器为了将输入的多个可重定位文件组合为一个可执行文件, 要做的事主要有两个, 一是符号解析, 二是重定位. 其中符号解析意思是说一个文件里会有很多对符号的定义和引用, 所谓符号就是全局变量,函数和静态变量这些. 然后符号解析就是将每个符号引用与一个符号定义关联起来. 而重定位做的事是把每个符号定义与一个内存地址关联起来, 然后将所有对这个符号的引用都指向这个地址.

详细说符号解析的话需要先说链接器的输入, 也就是可重定位文件的文件格式. 虽然它是二进制文件, 但实际上是有各种分段的, 比如有个固定的头部, 描述了文件类型, 机器类型等等一些主要信息. 还有放机器代码的段, 再往下还有放全局变量的段等等. 而文件中会有一个放符号表的段, 其中存放了这个文件定义和引用的全局变量以及函数这些信息.

符号表中有三类不同的符号主.分别是1.由当前文件定义的全局符号(定义的全局变量,函数等) 2.引用的其他文件定义的全局符号, 3.只被当前文件定义和引用的符号(static全局变量和函数). 每个符号条目并不是只有一个名字, 而是有一个固定的格式结构. 这个结构会标明符号名字, 大小, 类型(变量还是函数), 链接性(全局变量是GLOBAL, static全局变量大概会是LOCAL)等等.(之前看到过一个问题是说为什么static全局变量可以把作用域限制在本文件, 讲到这里就可以回答这个问题了. 因为static符号被单独分了一类, 链接器不会拿static符号去跟别的文件做解析.)

符号解析就是利用这些符号表信息去做解析的. 对于那些定义和引用都在同一文件的符号解析很简单. 但是本文件引用了其他文件定义的符号就会复杂一些. 编译器会把这样的只有引用的符号交给链接器, 由链接器去其他文件找这个符号的定义, 如果找不到就会报错. 符号解析还有一个问题是重名问题, 编译器在编码符号的时候会给他一个强弱属性, 已初始化的全局变量就是强, 未初始化的就是弱. 然后如果重名, 链接器去选择的时候会优先选择强符号, 如果都是弱符号, 那就随便选一个. 但如果两个重名符号都是强那会直接报错.

符号链接还可以跟静态库链接(静态库就是提前写好的一些函数文件打包为一个单独文件, 可以用它来当作链接器输入). 在链接静态库的时候, 链接器会维护三个列表: 1.可重定位文件的列表, 2.未解析的符号(有引用但还没定义的符号) 3.已定义的符号. 链接器会从左向右扫描文件然后用这三个表来做符号解析. 这其中要注意的问题是文件的顺序很重要, 顺序不对了解析会失败.

上面就是符号解析的说明了, 接下来是重定位部分. 重定位要做的就是把文件合并一下,然后给每个指令和符号分配内存地址. 再然后就是把对符号的引用指向刚才分配好的地址.

重定位做完就可以得到一个可执行的目标文件.文件由三个大部分组成: 1.只读代码段, 2.读写数据段, 3.不加载进内存的符号表和调试信息这些. 而将一个可执行文件加载到内存后所呈现的布局主要有四个大的部分. 从下到上分别是:1.只读代码段, 2.读写数据段(用来放全局变量, 细分为已初始化和未初始化的两部分), 3.堆, 4.栈. 然后在堆栈之间还有预留给动态库的内存映射区域. 最后在栈的上面还有用户不可见的内核内存.

整数相除#

两个整数相除，无论用什么接都是整数。因为会自动窄化。所以想要让两个整数相除保留小数点，则必须转换成double或float再进行除法操作

1
int a = 3;
2
int b = 6;
3
double c = a/b;
4
// C = 0;
5
double a = 3;
6
double b = 6;
7
double c = a/b;
8
// C = 0.5

形参（parameter）和实参（argument）区别#

• 形参 parameter是在函数头的参数

1
void func(int parameter){
2

3
}

这里我们明显看到了parameter的位置

• 实参 argument是传递的参数

1
int argument = 10;
2
func(argument);

这里我们明显看到了argument的位置

函数参数（parameter）的默认值的继承#

c++的函数参数的默认值是不可以被继承的。表面上可以使用只是“借用”，但不是继承。同时会有奇怪调用。 我们看下面的例子

1
struct A {
2
  virtual void f(int a = 7){
3
    cout << a;
4
    cout <<"A" << endl;
5
  }
6
};
7
struct B : public A {
8
  void f(int a){
9
    cout << a;
10
    cout << "B" << endl;
11
  }
12
};
13
int main() {
14
    A* pa = new A;
15
    B* pb = new B;
16
    A* m = new B;
17

18
    pa->f();    //7A
19
    pa->f(10);  //10A
20

21
    pb->f();    //error: no matching function for call to ‘B::f()’
22
    pb->f(10);  //10B
23

24
    m->f();     //7B
25
    m->f(10);   //10B
26
}

• **虚函数调用中使用的默认参数（argument，参数的默认值）由对象的（指针或引用）的静态类型决定。 派生类中的重写的虚函数不会从被它重写的虚函数中获取默认参数。**来自标准库文档

  • 表面上的参数默认值的继承其实是借用，而不是继承。pb->f()，参数的默认值从静态类型决定。所以此处参数的默认值应该是从B类寻找。但是B类重写的函数的参数没有默认值，导致没有合适的值放入函数调用。函数签名不匹配，无法调用。

• **当父类虚函数和子类虚函数参数都有默认值，但是值不同的时候，如果产生了多态调用，则此时会忽略子类默认值，使用父类默认值，但是实际调用的是子类函数。**也就是在使用父类指针指向的对象调用虚函数时，函数会按实际指向的对象调用对应的成员函数（动态绑定的结果），而函数的默认参数依旧为父类对象中的默认参数（静态绑定的结果） 所以永远不要重新定义一个继承而来的默认参数值，因为默认参数值是静态绑定的，而虚函数——你应该重新定义的唯一的函数——是动态绑定的。effective C++ 37条

类(对象）内存模型：#

1
struct alignas(4) EbaInfo {
2
    uint8_t eba_switch;
3
    uint8_t eba_state;
4
    uint8_t eba_direction;
5
};

1
class A {
2
  char a;
3
  int b;
4
  double c;
5
};
6

7
class B {
8
  char a;
9
  double b;
10
  int c;
11
};
12

13
int main() {
14
  cout << sizeof(A) << endl; //16
15
  cout << sizeof(B) << endl; //24
16
}

1
class D {
2
public:
3
  virtual void funA();
4

5
private:
6
  char a;
7
  int b;
8
  double c;
9
};
10

11
int main() {
12
    cout << sizeof(D) << endl; //24
13
}

1
class a{
2
    char a;
3
    int b;
4
    char c;
5
    int d;
6
    char e;
7
    int f;
8
    char g;
9
    int h;
10
};
11

12
class b{
13
    char a,b,c,d;
14
    int e,f,g,h;
15
};
16

17

18
int main() {
19
    cout << sizeof(a) << endl;   //32
20
    cout << sizeof(b) << endl;  //20
21
    return 0;
22

23
}

1
class test{
2
    public:
3
    void funcs(){
4
        int val;
5
    }
6
};

NRV优化#

NRV优化一句话就是，在函数返回值是值传递的时候，按理来说需要有临时变量调用拷贝构造。编译器对这些事情有优化。

1
void myfunc(solution& ret, solution& a, solution& b);
2

3
solution myfunc1(solution&a, solution& b);

1
Vector add(Vector& a, Vector & b)
2
{
3
    Vector v;
4
    v.x = a.x + b.x;
5
    v.y = a.y + b.y;
6
    return v;
7
}
8
int main(){
9
    Vector a, b;
10
  Vector c = add(a, b);
11
    return 0;
12
}

1
void add(Vector& __result, Vector& a, Vector & b)
2
{
3
    __result.x = a.x + b.x;
4
    __result.y = a.y + b.y;
5
    return;
6
}
7
int main(){
8
    Vector a, b;
9
    Vector c;
10
    add(c, a, b);
11
    return 0;
12
}

类的私有静态变量可以通过作用域访问运算符直接访问#

main函数结束也会为栈对象调用析构，但是不会为堆对象调用。#

类内函数内声明的变量（局部变量）作用域是函数而不是类#

所以类的函数内的变量不会算作类的大小。

指针和引用的区别：#

引用从来都不是所谓的“指针包装器”。它们的行为完全不同。是完全不同的两种数据类型。

• 可以把引用看成一个const指针。因为是const指针所以必须定义时初始化，也不能更改指向。但是这个并不全对。比如

  • 1
    double p = 3.33;
    2
    int& ref = p; //错误
    3
    int&& ref = p;//可以。
    

  • 我们上面提到了。隐式类型转换会创建临时对象。这里就是调用了int的形参为double的构造函数创建了一个临时对象。临时对象是右值。右值没有地址。我们这里用的又是左值引用，自然会产生错误。

  • 所以我们注意到了，隐式转换的临时变量是右值。所以可以用右值引用去接。但是！！这时候这个ref并不是p的引用，而是一个临时变量的引用。ref此时代表的并不是p而是一个临时对象！

• 指针是一个单独的实体，引用则是别名

  • 所以指针有地址
  • 引用虽然（可能）也有地址（也分配内存），但是引用和引用所引用的变量共用一块内存空间。当然了，引用本身确实有自己的内存空间，和指针一样。但是经过编译器处理后，访问这块内存时将直接转而访问其指向的内存。因此在程序中无法读取到这块内存本身。（依靠实现）

• 引用不可以赋值，所以引用只能在定义时初始化一次，之后不可更改。指针可以更改该并且可以把定义和初始化分开。

• 引用不能为空，指针可以为空。

• sizeof指针的大小是指针自己的大小。sizeof引用是对象的大小。

• 没有引用的引用，没有引用数组，也没有指向引用的指针。

  • 下面我们的b和c都是a的引用。c并不是b的引用。因为没有引用的引用。

1
int main(){
2
    int a = 10;
3
    int &b = a;
4
    int &c = b;
5
    c = 20;
6
    cout << a << b << c <<endl; //20 20 20
7
    return 0;
8
}

• 指针有自增操作。

• 引用不可以重新赋值（不能更改指向）

1
int main(){
2
    int a = 10;
3
    int b = 20;
4
    int c = 30;
5
    int& aref = a;
6
    cout << aref << endl; //10
7
    aref = c; //注意这里！
8
    cout << aref << endl; //30
9
    cout << a << endl; //30
10
    return 0;
11
}

我们看到aref是a的引用，也就是它俩是一个东西。执行aref = c的时候，并不是把aref变成c的引用，而是把c的值赋给aref也就是赋给a的引用。所以最后a和aref都会变成30。

• 使用一个引用给一个变量赋值，则会调用其拷贝构造构造出一个新的变量。因为引用的行为和普通变量一样

1
int a = 10;
2
int& b = a;
3
int c = b; //在这里a会被拷贝然后给c。也就是c会被拷贝构造。因为如果这里换成int c = a,也是会被拷贝构造。引用就相当于变量的别名。所以这里引用和普通变量行为一样

• 自然而然的，函数的值传递和引用传递可以解释通了

1
void func(int& a);
2
void func1(int a);
3

4
int var = 100;
5
int& ref = var;
6

7
func(var);
8
func(ref);
9
func1(var);
10
func1(ref);

• 第一个调用：标准的引用传递。

  • 变量var传递进函数func的时候，函数内部会创建一个叫a的引用，引用的对象是外部的var

• 第二个调用：引用的引用。

  • 引用ref传递进函数func的时候，函数内部会创建一个叫a的引用，引用的对象是引用ref的引用对象也就是var。因为没有引用的引用。

• 第三个调用：标准的值传递。

  • 变量var传递进函数func1的时候，函数内部会创建一个叫a的变量，变量拷贝构造自外部的var。

• 第四个调用：也是值传递。

  • 引用ref传递进函数func1的时候，函数内部会创建一个叫a的变量。我们刚提到了，使用引用初始化一个普通变量会调用拷贝构造，拷贝自引用的引用对象。所以这里a的变量是拷贝自引用ref所引用的对象，也就是var。

• 移动一个元素的引用就等同于移动一个元素本身

1
int main(){
2
    myobj a(200);
3
    myobj& b = a; //b是a的引用
4
    myobj c = move(b); //这里移动b和移动a效果相同
5
    cout << *a.val << endl; //无论访问a还是b都是无效。因为移动b等同于移动a。
6
    return 0;
7
}

继承权限和访问权限#

默认继承方式#

继承的默认类型取决于继承（派生）类型，而不是正在继承的类型（基类）。

• struct，默认为public
• class，默认为private

1
class A {};
2
struct B: /* public */ A {}; //派生类型是struct，默认为public
3

4
struct A {};
5
class B: /* private */ A {}; //派生类型是class，默认为private

函数指针和类成员函数指针#

1
//静态的成员函数指针语法:
2
void (*ptrStaticFun)() = &ClassName::staticFun;
3
//成员函数指针语法:
4
void (ClassName::*ptrNonStaticFun)() = &ClassName::nonStaticFun; //必须加作用域
5
<返回值类型>(<类名>::*<指针名称>)(<参数列表>) = &<类名>::<非静态成员函数名称>

我们来通过具体例子来说明其中的坑。

1
void normal_func(){
2
    cout << "func" <<endl;
3
}
4

5
void call_back_test(int& a, int& b){
6
    cout << a + b << endl;
7
}
8

9

10
class test{
11
    public:
12
        int val = 5;
13
        void class_nonstatic_func(){
14
            cout << "class_nonstatic_func" <<endl;
15
        }
16
        static void class_static_func(){
17
            cout << "class_static_func" <<endl;
18
        }
19
        void callback(void(*ptr)(int&, int&), int& a, int& b){
20
            ptr(a, b); //普通函数调用
21
            void(*normal_funcptr)() = &normal_func; //类内获取全局函数指针。注意全局函数必须写在这一行的前面。
22
            normal_funcptr(); //调用 语法糖
23
            (*normal_funcptr)(); //调用
24

25

26
            void(test::*class_nonstatic_func_ptr)() = &test::class_nonstatic_func; //类内获取类非静态成员函数指针
27
            (this->*class_nonstatic_func_ptr)(); //调用。调用类成员函数指针必须加*解引用。而且需要绑定对象。类内就是用this。
28

29
            void(*class_static_func_ptr)() = &test::class_static_func; //类内获取类非静态成员函数指针
30
            class_static_func_ptr();    //调用 语法糖
31
            (*class_static_func_ptr)(); //调用
32

33

34
        }
35
};
36

37

38
int main(){
39
    void (*normal_funcptr)() = &normal_func;          //普通函数指针
40
    void (*normal_funcptr1)() = normal_func;          //也可以不取地址。语法糖。
41

42
    normal_funcptr(); //调用方式，不解引用也可以，语法糖
43
    normal_funcptr1();
44

45
    (*normal_funcptr)();    //解引用，正确方式。应该这么写，更加清晰。
46
    (*normal_funcptr1)();
47

48
    test classobj;
49
    test* classobj_ptr = new test();
50
    void (test::*class_nonstatic_func_ptr)() = &test::class_nonstatic_func; //获取类非静态成员函数指针，必须取地址
51
    //获取类获取类非静态成员函数指针 必须在指针名字前面加类作用域，用来辨别。
52
    (classobj.*class_nonstatic_func_ptr)(); //对象调用。调用类成员函数指针必须加*解引用。而且需要绑定对象（通过对象调用）。
53
    (classobj_ptr->*class_nonstatic_func_ptr)(); //指针调用。调用类成员函数指针必须加*解引用。而且需要绑定对象（通过对象调用）
54

55

56

57
    void(*class_static_func_ptr)() = &test::class_static_func; //获取类静态成员函数指针 ，必须取地址
58
    //获取类获取类静态成员函数指针 不需要指针名字前面加类作用域。因为静态成员函数可以理解为在类作用域内的全局函数。
59
    //所以取地址还要加作用域，函数名字不需要。
60
    class_static_func_ptr(); //直接调用。语法糖
61
    (*class_static_func_ptr)(); //直接调用。解引用
62

63
    //!(classobj.*class_static_func_ptr)();     //对象调用错误
64
    //!(classobj_ptr->*class_static_func_ptr)();//指针调用错误
65

66

67
    return 0;
68
}

• 声明

  • 普通函数指针
    • 直接取名字即可
  • 类成员函数指针
    • 必须在指针名字前面加类作用域，用来辨别。
  • 类静态成员函数指针
    • 和普通函数指针一样，不需要加作用域。因为静态成员函数可以理解为在类作用域内的全局函数。（所以赋值依旧需要取地址+作用域）

• 赋值

  • 普通函数指针
    • 可以直接用函数名赋值。语法糖。
    • 也可以取地址
  • 类成员函数指针和类静态成员函数指针
    • 赋值必须要加作用域解析运算符并且取地址

• 调用

  • 普通函数指针
    • 直接调用。语法糖
    • 解引用调用。注意解引用必须加括号。
  • 类成员函数指针
    • 不可以直接调用，必须解引用。同时必须绑定对象使用对象调用或对象指针调用
    • 类内必须使用this用来充当绑定对象。
  • 类静态成员函数指针
    • 和普通函数指针一样。
    • 直接调用。语法糖
    • 解引用调用。注意解引用必须加括号。

1
template<typename T> //类模板
2
class myclass{
3
    public:
4
    void func(){
5
        cout << "class func" << endl;
6
    }
7
    int func2(int a){
8
        cout << "class func2" << endl;
9
        return a;
10
    }
11
};
12

13
class nclass{
14
    public:
15
        template <typename T>
16
        void func(T a){
17
            cout <<"nclass func" << endl;
18
            cout << a << endl;
19
        }
20
        template <typename RT, typename T> //函数模板
21
        RT func2(T a){
22
            cout <<"nclass func" << endl;
23
            cout << a << endl;
24
            return a;
25
        }
26
};

1
myclass<int> myclassobj; //实例化的对象
2

3
void(myclass<int>::*myptr)() = &myclass<int>::func;
4
(myclassobj.*myptr)();
5

6
int(myclass<int>::*myptr2)(int) = &myclass<int>::func2;
7
(myclassobj.*myptr2)(4);

1
nclass nclassobj; //实例化的对象
2

3
void(nclass::*nptr)(int) = &nclass::func;
4
(nclassobj.*nptr)(234);
5

6
float(nclass::*nptr2)(int) = &nclass::func2;
7
(nclassobj.*nptr2)(2343);
8

9
float(nclass::*nptr_noneed)(int) = &nclass::func2<float, int>; //不是必须显式指明模板参数。
10
(nclassobj.*nptr_noneed)(2343);

类成员（变量）指针#

• 类成员变量指针与普通意义上的指针不一样。存放的是类内偏移量。

• 指向成员变量的指针并不指向某一个具体对象的内存地址。它指向的是一个类的特定成员，而不是指定某一个特定对象的成员。

• 指向类成员变量的指针”的实现方式是获取该类成员在类中的偏移值，这也同样印证了指向类成员变量的指针不可以单独访问 (依赖于某一特定对象) 的原因 —— 它只是偏移值，需要通过特定的对象来访问该对象此偏移值处的子对象。

• 在我们对一个 “指向类内数据成员的指针” 赋予初始值，实际上是获得了该数据成员在类内的偏移量。除非是对一个类内的 static 数据成员进行 & 操作，否则不会带来一个实际的地址，而是一个偏移量。

1
//静态的成员变量指针语法:
2
int *ptrStaticitem = &ClassName::Staticitem
3
<成员变量数据类型>*<指针名> = &<类名>::<静态数据成员名称>
4
//成员变量指针语法:
5
int ClassName::*ptrNonStaticitem = &ClassName::nonStaticitem
6
<成员变量数据类型><类名>::*<指针名> = &<类名>::<非静态数据成员名称>

1
class person{
2
    public:
3
        int id = 20;
4
        static int info;
5
};
6
int person::info = 10;
7

8
int main()
9
{
10
    person human;
11
    person* human_ptr = new person();
12
    int person::*nonstatic_ptr = &person::id; //非静态成员变量指针
13
    cout << human.*nonstatic_ptr << endl; //必须对指针解引用后通过对象或指针访问
14
    cout << human_ptr->*nonstatic_ptr << endl; //指针解引用访问。
15

16
    int* static_ptr = &person::info; //静态成员变量指针
17
    cout << *static_ptr << endl; //解引用
18
    cout << person::info << endl;//直接通过作用域运算符访问类静态成员变量。
19
    return 0;
20
}

• 非静态成员变量：
  • 和非静态成员函数相似。不可以直接使用，必须解引用后绑定对象使用对象调用或对象指针调用
• 静态成员变量：
  • 和静态成员函数相似。可以直接使用，不必绑定对象。

https://imzlp.com/posts/27615/

类成员（变量）指针和类成员函数指针的具体区分方式在模板的结尾。但是记住一点，类成员函数指针是类成员（变量）指针的子集。#

https://zhuanlan.zhihu.com/p/659510753