C++ Primer Plus

字数统计: 7.8k字   |   阅读时长≈ 29分

构造器

基类的构造器在子类的构造器之前调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Animal
{
    
};

class Pig: public Animal // 继承基类设置为pulic属性，基类中的访问权限不变
{
    
};

class Cat: protect Animal // 继承基类设置为protect属性，基类中之前不管是什么属性，所有的成员都变成protect属性。
						  // 这样可以做到接口的安全：1.只有通过这个子类才可以修改基类的成员。
{
    
};

class Dog: private Animal // 继承基类设置为private属性，基类中之前不管是什么属性，所有的成员都变成private属性。
						  // 1.只有子类自己内部可以修改基类属性，外界也不能通过这个子类来修改基类的成员。
{
    
};
  1. ；类的属性和方法默认为私有属性。
  2. 如是局部对象，在函数返回即销毁局部对象的时候调用析构器。
  3. 构造器可以有参数和无参数，析构器没有参数。

image-20220508151721028

image-20220508152049171

方法的重写和方法的重载的区别

  1. 方法的重写：子类和父类拥有同样名字和参数返回值类型的函数，叫做子类重写了基类中的方法。
  2. 方法的重载：名字相同但参数个数或类型不同的多个函数，在调用函数式会根据传入参数的类型和个数自动确定调用哪个函数，叫做方法的重载。
  3. 重载并不是面向对象的特征，但可以简化编程。 简化编程是C++的全部追求。
  4. 类中的方法可以重写也可以被重载。
  5. 最好少用重载，重载的方法越多程序就越难看懂。
  6. 子类继承了基类的方法，然后不能再去重载这个方法。

image-20220508155043593

子类可以直接调用基类的类方法，因为类没实例化之前都没有分配空间，没空间的调用没空间的。

静态属性和方法

  1. 静态属性属于这个类，不属于某一个对象。
  2. 能过在该类的所有对象之间共享这个类属性。

image-20220509212303308

image-20220509212725249

  • 为类属性分配内存并初始化为0，类属性必须要在类外面定义一下（和类方法一样）目的是为了分配空间

image-20220509212814868

  1. 类属性对类和类的所有对象可见，所以可以作为类实例化为对象个数计数，在对象的构造函数对类属性count++，析构函数对类属性count–。
  2. 类的静态方法可以直接用：类名字::类静态方法()、对象.类静态方法() 两种方式调用，推荐使用第一种，更能清楚的知道这是个类静态方法。
  3. image-20220510203311815
  4. 静态方法只能访问静态成员变量，无法访问非静态成员变量。

image-20220510202814637

C++的this指针

image-20220510203852204

虚方法

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
class Pet
{
public:
    void eat();
    void sleep();
    
    virtual void play();
};

class Dog: public Pet
{
    virtual void play();
};

class Cat: public Pet
{
    virtual void play();
};

void Pet::eat()
{
    cout << "eat" << endl;
}

void Pet::sleep()
{
	cout << "sleep" << endl;
}
    
virtual void Pet::play()
{
	cout << "Pet play" << endl;
}

// 重写基类虚方法
virtual void Dog::play()
{
	cout << "Dog play>>>>>>>>>>>>>>>>>>>>>" << endl;
}

// 重写基类虚方法
virtual void Cat::play()
{
	cout << "Cat play>>>>>>>>>>>>>>>>>>>>>" << endl;
}

/* Dog、Cat都是Pet类型的对象 */
Pet *Dog = new Cat;
Pet *Cat = new Dog;

// 1. 如果是虚方法，根据new后面的类型运行时动态确定具体子类是否有重写该方法，重写则调用子类重写后的方法。
// 2. 如果是非虚方法，根据Dog对象前面的指针类型在编译是就确定为Pet的某个方法。
// 3. 以上Dog和Cat都是Pet类型的对象，却实现了调用Play方法Cat.play()和Dog.play()完全不同的结果。（即多态的原理）

image-20220510211748703

new Cat(参数)： 参数是传递给构造器的。

image-20220510211625969

  1. Pet是Cat和Dog的基类，可以用Pet接收Cat和Dog的new出来的空间。
  2. 但是new是在运行时才确定的，把这个空间解释为Cat和Dog。
  3. 而在编译时Cat和Dog都是Pet类型的指针，所以编译器会把Dog和Cat解释为Pet类型。
  4. 所以在Dog和Cat类里面重写了Pet类型的Play方法没有起作用，调用Dog.play时任然是调用的Pet.play。
  5. 要想让Dog.play解释为重写后的Dog.play就必须在Pet.playe声明为虚方法，在方法名前面添加Virtual关键字。
  6. 虚方法会使程序速度慢一点，但如果不确定是否应该将其声明为虚方法，就最好声明为虚方法。防止程序没能按预期运行。
  • 虚方法是继承的，基类中的虚方法，子类也必须声明为虚方法。
  • 在实现一个多层次的继承关系的时候，最顶级的基类应该只有虚方法。（类似java的接口）
  • 其实析构器就是虚方法，析构对象的时候都是先调用的最底层子类的析构函数，而不是直接调用的基类的析构函数。
小结：1.虚方法是在运行时根据new的类型才被确定具体该调用哪个子类的方法，而非虚方法是在编译时根据对象的类型就被确定了。对象指针是Pet类型就调用Pet类型的方法。
2.基类的虚方法可以用来实现多态，使用基类的指针接收不同new出来的子类（子类中已对基类的虚方法进行了重写），当调用不同的基类对象的虚方法可以实现运行不同的方法而得到不同结果。
3.就像上面的Pet类型的两个对象（Dog和Cat），同样是Pet类型Dog和Cat对象在调用自己的Play方法时运行的结果确是不一样的。

抽象方法

抽象方法也可以称为纯虚函数。基类中只声明不定义，交给子类去实现定义的方法。

image-20220511203956977

1
2
3
4
5
6
7
8
class Pet
{
public:
    void eat();
    void sleep();
    
    virtual void play() = 0; // 此方法为抽象方法，基类没有实现，必须由子类去实现。
};

多态的概念

image-20220511204618972

  • 重载与覆盖

image-20220511205003034

  1. 编译时的多态性：通过重载实现。
  2. 运行时的多态性：通过虚函数实现。
  • 当一个类被作为基类时，它的析构函数应该写成虚函数

image-20220511205907332

虚函数是可以被继承的，基类中的虚函数，子类里面也必须写成虚函数。

运算符的重载

  1. 运算符的重载的方法是定义一个重载运算符的函数，在需要执行被重载的运算符时，系统就自动调用该方法，以实现相应的运算。

  2. 也就是说，运算符重载是通过定义函数实现的。运算符重载实质上是函数的重载。

  • 运算符函数格式

image-20220511210819651

image-20220511210848938

以上运算符重载函数，在使用 + 号时，实际会执行 - 号操作。

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
class car
{
public:
    string color;
    string engine;
    float gas_tank;
    int wheel;

    void set_color(string color);
    void set_engine(string engine);
    void set_wheel(int wheel);
    float runing(void);
    void add_tank(int ml);
    
    car(void); // 可以不写函数返回类型，构造函数只能是void返回类型
    car(int a, int i); // 重载析构函数
    ~car(void); // 析构函数一定没有参数和返回值，构造器可以接受参数

    static int get_count();

    /* 接收一个car类型的引用，返回一个car类型的对象 */
    car operator+(car &d); // 重载了 + 号 在此类范围内
    int real;
    int imag;
    
private：
    static int count;
}

car car::operator+(car &d) // + 号重载运算符函数的实现
{
    car c;
    c.real = this->real + d.real;
    c.imag = this->imag + d.imag;
    return c;
}

int main
{
    car tu1(10, -90);
    car tu2(78, 34);

    car tu = tu1 + tu2; // 这两个对象相加（+ 号以被car类重载了），等同于执行 car car::operator+(car &d) 这个函数

    cout << "tu.real = " << tu.real << endl;
    cout << "tu.imag = " << tu.imag << endl;
}

// 补充：实现自己的 << 运算符重载为打印字符串。这里只实现了接收字符串，可以再对它们重载接收不同的参数类型：比如整形、双精度浮点型
void car::operator<<(string str) 
{
    printf("%s", str)
}

void car::operator<<(int vlaue) 
{
    printf("%d", vlaue)
}

void car::operator<<(double vlaue) 
{
    printf("%f", vlaue)
}

int main()
{
    car test_obj;
    /* 使用重载后的 << 符号， 根据不同类型的参数自动调用不同的重载符号的函数 */
    test_obj << "tesds\n"; 
    test_obj << 78;
    test_obj << 45.890;
}

// 从上个面的例子可以看出 cout 和 cin 其实就是系统自动定义的一个对象， 这个对象的类重载了 << 和 >> 运算符来执行了两个带 prinf 和 scanf 操作的函数。iuyb
  1. C++不运行用户自己定义新的运算符，所以要想让固有的运算符显示不用的运算就只能对运算符进行重载。
  2. C++不允许被重载的五个运算符： . * :: sizeof ?:
  • 重载运算符的一些规则

image-20220511221954638

image-20220512205656951

多继承

多继承场景：但一个类不能用是来表示的时候需要多继承。

学生是人、老师是人，学生和老师都单继承人类。

多继承示例：

  1. 假如有个助教，他必须多继承学和老师两个类。因为助教一方面是学生的角色一方面又是老师的角色。
  2. 此时不能说助教是老师或者助教是学生，助教应该同时拥有学生和老师类的方法、属性。

虚继承

  1. 上术例子，助教多继承了学生和老师类。而学生继承了人类，老师也继承了人类。导致一个助教对象拥有两份人类对象实例。
  2. 导致助教使用人类属性时出现不确定性，因为助教有两份人类实例。
  3. 虚继承就是为了解决这个问题，虚继承可以保证一个对象最多只拥有一个类的一份实例。

image-20220604151955538

image-20220604152042500

image-20220604152221165

  • 继承类的构造方法定义

image-20220604152541029

  1. 如果一个类继承了其它类，构造方法不是默认无参的情况下，需要在自己的构造函数调用基类的构造方法。

  2. 如果一个类是虚继承一个类，需要在其子类的构造方法调用虚继承的类的构造方法。

  3. 虚继承的东西不能被再继承出去：Teacher和Student类都是虚继承Person类，Teacher和Student类都不能拥有Person类的备份（不能继承给TeachingStudent类只有一份Person类实例）。所以需要在TeachingStudent类的构造函数调用Person类的构造方法，使TeachingStudent类自己去继承一份Person类，而不是通过Teacher或者Student类。

  4. 可以把虚继承理解成一个单例继承：只会在子类申请一份空间。别人不能通过这个类再去继承这个类的虚继承来的东西。

  5. 继承的本质就是在子类中申请一份和基类同样大小的空间，再把基类拷贝进来。而虚继承就是不让自己虚继承来的东西被别人继承（拷贝）走，别人需要自己去继承（拷贝）我虚继承来的东西。

  • 什么时候用虚继承
  1. 当一个类太抽象（底层）了，可能被多个同级别的类继承，这时候就需要用虚继承来继承这个类。
  2. 当一个类需要多继承的时候，首先考虑是否应该用虚继承。

同级别的类：会被一个子类同时继承（包含）的基类。

C++的错误机制

  • 错误的分类
  1. 编译时错误。
  2. 运行时错误。
  • 防止运行时错误方法
  1. 在一个类里面编写类专门的测试方法。
  2. 类方法多返回错误码。
  3. windows的蓝屏错误代码，就是运行时的错误码。
  • try catch

image-20220604164016184

image-20220604164215159

image-20220604164314102

image-20220604164403940

  • 示例

image-20220604164703260

image-20220604164811604

  1. try语句块中函数抛出异常后语句块中函数后面的代码就不会被执行，而是去执行catch中的代码了。
  2. try catch 可以使用参数指针（即异常类型参数）加goto实现。
  3. 使用异常的基本原则是：应该只用它们来处理确实可能不正常的情况。
  4. 开发测试阶段，应多用assert()来捕获运行是错误。
  5. 在构造器和析构器中不应该使用异常。

image-20220604170019138

动态内存管理

  1. new出来的内存块：里面充满了垃圾数据。

  2. delete后的指针最好将他指向NULL，防止程序在后面错误使用delete后的指针指向空间的内容。

副本构造器

  • 逐位复制

image-20220604193827485

  1. 当一个对象包含指针，将这个对象复制一份。就有两个对象里面的指针都指向同一个内存块。而当一个对象删除时将内存块释放，另一个对象还通过指针访问这个内存块就会出错。并且删除第二个对象时也会去释放这块内存出现二次释放的错误。
  2. 解决的版本就是两个对象的指针分别指向两个不同的内存块。
  3. 在复制对象的时候把对象指向指针的内存块也复制一份。

image-20220604194532247

  • 重载 = 号的方法解决

image-20220604194745028

以上情况可以在类中对 = 运算符进行重载，在运算符重载函数中处理类中的指针。

image-20220604195042442

= 号重载函数，接收一个const同类型的引用并且返回一个同类型的引用。

返回一个同类型的引用可以保证连续赋值：a = b = c

image-20220604195627949

  • 创建副本构造器的方法解决

image-20220604200112796

image-20220604200211740

在对象声明的时候同时初始化对象，编译器会在类中寻找副本构造器，找不到编译器就会自己创建。

image-20220604200519276

image-20220604200846585

C++的对象安全的类型强制转换

  • C语言方式的类型强制转换

C语言的方式强制转换不同类型的对象，如果被转换的类型占用空间小于接收对象的类型，在访问成员时可能访问越界的空间。

  • C++安全的强制类型转换

image-20220604202347583

  1. 也就是只有子类（占用空间大）可以强制转换为基类（占用空间小）。
  2. 以上的C++语法也是通过函数实现的，会把类型的检测放在函数中，不符号规则的强制类型转换类型将返回NULL。

image-20220604202940907

image-20220604203156140

命名空间

image-20220604211341261

image-20220604212008982

不要把using指令用在全局作用域，将失去命名空间的意义。

  • 单独从命名空间提取需要的部分

image-20220604212217910

链接器和作用域

image-20220604212658523

  1. 如果一个函数没有被声明就调用，编译的时候就会报错。
  2. 如果一个文件中有这个函数的声明就可以使用这个函数，编译的时候就不会报错。
  3. 如果一个函数声明了，并且调用了。但没有在任何一个源文件定义这个函数，链接的时候就会报错。

image-20220604213143204

image-20220604213537073

没有被初始化的static变量储存在.rss段，被初始化的static变量储存在.data段。

  • 内链接和外链接

image-20220604214005538

外链接：变量函数定义在其他文件，需使用extren关键字。头文件中函数如果会被其他文件调用都需要加extren，只是编译器默认给我们添加了。

内链接：本文件调用本文件定义的函数、变量。static用来说明这个变量是一个内链接变量、函数。

无链接：局部定义的变量。

模板

  • 范型编程

image-20220604220342986

image-20220604220506816

  • 模板

image-20220604220743349

STL库是范型编程的经典之作，它包含了许多非常有用的数据类型和算法。

image-20220604221032581

这里的class不是类的意思，这只是一种通俗的写法。

image-20220604222000392

模板相比于函数的重载：

  1. 重载需要自己手动定义需要的不同参数功能相同的函数。
  2. 模板把自己手动定义函数的事情交给了编译器做，解放了程序员。
  3. 函数重载就算不使用的函数也会被定义，而模板是根据需求来定义函数，不需要的就不会被定义。
  4. image-20220604223313399
  • 模板的另一种声明写法

image-20220604222730032

  • 类模板

image-20220604223423557

image-20220604223509412

为明确说明swap是一个函数模板，调用时可以使用swap(i1, i2);

C++的 array、vector模板就是此写法：

vector vd;

vector<double, 4> vd;

array<int, 5> ai;

image-20220604224528887

image-20220604225947277

image-20220604230121954

image-20220604230321661

即vector<int, 5> vd;

迭代器

image-20220604232238686

每一个容器都会提供一个迭代器，迭代器的定义如上代码。

容器：用来处理数据的方法集合和储存数据的集合，类模板的实例就是容器。它可以处理一类数据和保存这类数据。

运算符隐式转换

  1. 如果两个整形运算，如果是char short比int小的，全部提升为int类型运算，再按照需要赋值的类型转换给赋值变量的类型。因为int类型硬件在计算时最快。
  2. 如果两个数分别是有符号和无符号，先看哪个数类型的优先级高，怎转换成哪个符号类型进行运算。
  3. 如果两个数分别是有符号和无符号相同类型，则先看有符号是否可以容纳无符号转换为有符号的类型。可以则将无符号类型转换为有符号类型进行运算，否则全部使用有符号类型的无符号版本。

C++扩展字符串

1
2
3
4
5
6
7
8
wchar_t title[] = L"cherio frv"; // w_char string
char16_t name[] = u"cheru lkds"; // char_16 string
char32_t name[] = U"cheru lkds"; // char_32 string


R"cher fdvklmg \\ \n  pooppw"; // 原始字符串：\n \\ 等转义字符会被原样输出
/* 原始字符串处理字符串中包括"的情况 */
R"+* "cher fdvklmg" \\ \n  pooppw. +*"; // 原始字符串：两个**之间是字符串的内容而不是两个""之间的内容

枚举

  1. 枚举变量不能进行算数运算，自增、自减。因为枚举变量算术运算后就可能不在枚举声明的范围了。
  2. 枚举类型的变量只能赋值为枚举声明范围内的，不能直接赋值为int类型的字面量或变量等（但可以使用强制类型转换）。
  3. 枚举量在和int类型变量做算术运算时，首先会被转换为int类型。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 一个枚举声明中可以有多个枚举量的值相同
enum test
{
    zero, // zero是0
    null = 0, // null是0
    NULL = 0, // NULL是0
    one,
    two,
    three,
};

enum test number; // 定义一个枚举类型的变量


enum bigstep
{
   first,
   second = 100,
   third
};
  • 枚举类型值的取值范围

取值范围定义如下:

  1. 首先,要找到上线,找到枚举量的最大值,找到大于这个最大值的,最小的2的幂,将它减去1,便是取值范围的上限
  2. 例：enum bigstep 最大枚举值是101,在2的幂中,比这个值大的最小的值为128,因此取值范围上限为127.要知道下限,需要知道枚举量的最小值.如果它不小于0,则取值范围的下限为0.否则,采取与寻找上限方式同样的方式,但加上负号,例如,如果最小的枚举量为-6,则比它小的,2的幂最大的值为-8,加1之后为-7.于是,上限与下限便能算出来.

指针

  • 使用常规方法定义变量时，值是指定量，地址是派生量。

  • 面向对象编程的与面向过程处理数据的策略：

  1. 面向对象在程序运行时动态分配内存（动态联编），面向过程在编译时（静态联编）确定并分配固定大小内存。
  2. 通过动态创建变量、结构、对象的方式：地址是指定量，地址中的内容（变量）是派生量。
  3. 通过编译时通过类型的方式定义变量、结构、对象的方式：内容是指定量，地址是派生量。
  4. 动态创建的好处可以方便的根据程序运行时，每次需要的大小申请不同大小的空间，C++使用 ：new 类型。

当地址为指定量时，*指定量：运算符结果被称为间接值。

不要重复delete一个new出来的指针，对NULL进行delete是安全的。

  • 动态数组的申请释放
1
2
3
4
5
6
7
/* 变量、结构、类 */
int *ps = new int;
delete ps;

/* 数组 */
int *arry = new int [10];
delete [] arry; // 不能写成，delete arry代表只是否数组的第一个元素
  • 指针的算数运算
  1. 指针进行乘除运算是没意义的。可以用两个指针做加减运算将得到一个int类型的整数（仅当两个指针指向同一类型时才有意义，将得到两个元素的间隔）。
  2. 指针加1，相当于加：指针指向类型的字节数。减1同理。
  3. 指针加n，相当于加： n * 指针指向类型的 字节数。减n同理。
  • 指针和数组区别
  1. 数组名是常量（是第一个元素的地址类型为数组的类型），指针是变量。
  2. 数组名是数组第一个元素的地址，而对数组名取地址是整个数组的地址。数组（类型是数组类型）和对数组名（类型是一维数组）取地址：都是指针值是一样的但类型不一样所以它们表示的步进长度也不一样。
  3. sizeof（数组名）返回整个数组的长度字节。
  4. arry[7]和*(arry + 7)等效。下标便表示法内部就是使用指针实现的（所以指针表示法的效率应略高于下标表示法）。
1
2
3
4
5
6
7
int arry[10] = { 0 , 1, 2, 3, 4, 5, 6, 7, 8, 9};
int *p = arry;
int (*pp)[10] = &arry;

cout << "arry[0] = " << p[0] <<endl; // 数组的第一个元素
cout << "arry[sizeof(arry) / sizeof(arry[0]) -1] = " << *((int *)(pp + 1) - 1) <<endl; // 数组的最后一个元素 &arry + 1 指向数组末尾的后一个字节
cout << "arry[0] ~ arry[9] " << &arry[9] - &arry[0] <<endl; // 得到两个元素的间隔
  • 结构数组
1
2
3
4
5
6
7
struct tyu ar[6];

tyu[0].year = 2022; // 第一个元素的year成员
tyu->year = 2022;  // 第一个元素的year成员，因为数组名就是数组第一个元素的地址，即tyu等同&tyu[0]

tyu[1].year = 2022; // 第二个元素的year成员
(tyu + 1)->year = 2022;  // 第二个元素的year成员

模板类

  • 模板类vector
  1. verctor类类似于string类，是一种动态数组。内部通过new和delete实现。
  2. 可以在程序运行时动态创建不同（变量或字面量）大小的相同元素的空间。
  3. 空间存储于堆上。

vector是c++的一个类可以看成是一个单链表及其函数集，可以动态创建，动态插入删除vector里面的元素。

1
2
3
4
5
6
7
8
#include <vector>

using namespace std;

vector<int> vi; // 创建一个int类型的vector，初始化不含元素
int n;
cin >> n;
vector<double> vd(n); // 创建vector 初始化包含n个double元素
  • 模板类array
  1. array类和数组类似，只能在编译时分配字面量大小的固定空间。
  2. 空间存储在栈上。

array相比数组更加安全，array类有运行是对数组边间检查。array类有方法设置array对象的内存范围等安全手段。

1
2
3
4
5
6
#include <vector>

using namespace std;
// array类创建大小必须在编译时确定和数组一样
array<int, 5> ai; 
vector<double, 4> vd = {1.2, 1.3, 1.4, 1.5}; // 创建array 初始化包含4个double元素

数组：a1[-2] = 20，等效于*(a1 - 2) = 20。此方法是采用数组下标，（语法没错）但可能会出现越界。而array类通过类方法的形式：

array模板类：a1.at(-2)，at方法就是索引元素的意思，还有a1.begin(s)、a1.end(e)。如果-2不在s和e之间（非法索引）程序就会捕捉到。

打印字符串地址：

1
2
3
// cout对象的智能类型判断功能
cout << (int *)"urie fgjk kdfk" << endl; // cout是字符串地址int *类型，输出地址（字符串的）
cout << "urie fgjk kdfk" << endl; // cout是字符串地址char *类型，输出字符串

表达式

  • 表达式
1
2
3
4
5
6
7
8
9
10
22 + 27 // 表达式的值为49

x = 20 // 表达式的值为20 

if (x = 20) // 表达式的值为20, 会被转换成bool类型的ture
{

}

maids = (cooks = 4) + 3; // maids被赋值为7，赋值运算符从右向左结合的

都是表达式，表达式的值定义为左侧成员的值。

  • 语句
1
2
3
22 + 27; // 在表达式后面加上；就变成了语句

x = 20; //
  1. 只要加上；所有的表达式都可以变成语句。
  2. 赋值语句的值为左操作数的值。
  • – ++ 表达式

C++用户类定义这些运算符存在差别：

–前缀函数：将值加1，然后返回结果。

–后缀函数：将值先复制一份，将其加1，然后将复制的值返回。

因此，–前缀版本的效率更高。

C++内置的的版本前缀后缀无差别。

指针变量的自增自减：增加其指向类型占用字节数。

逗号运算符

1
2
3
i = 20, j = 2 * i; // 先计算i为20 j为40，表达式的值为40

int j, i = 9, o,p; // 这样的情况不是逗号运算符，逗号只是起分隔的作用。
  1. 逗号运算符从左边开始计算，逗号表达式的值是最后一个逗号后的值（最右边）。
  2. 而函数参数是从最右边开始往左边的顺序计算。
  3. 逗号运算符是所有运算符中优先级最低的。

比较字符串

string类不使用字符’\0’来标记字符串的末尾。

cin对象

cin.get()不用传参数的引用即可改变参数变量的值。

文件末尾EOF，cin.eof()或者cin.fail()检测是否读到文件末尾。EOF值为-1。

  1. c语言的getchar()、putchar(int)为什么返回的是int类型，因为需要返回EOF（-1），但char类型根据编译器有些是有符号有的是无符号，所以不能全部用char。
  2. EOF可以使用Ctrl+Z或者Ctrl+D来模拟，以终止输入。
  3. cin.get(ch)返回一个cin对象，所以可以cin.get(ch).get(cha1)。
  4. cin.get(ch)有参方法到达文件末尾是不会把EOF（-1）的值赋值给ch。而cin.get()无参方法（类似c语言getchar）会返回EOF。
  5. cin.get()无参方法（类似c语言getchar）返回的是int类型而不是cin对象，cin.get(ch)返回一个cin对象。
  6. cin << ch; 这种方法读取字符串将忽略空格、换行符、制表符，需要这样使用 ch = cin.get();

关系运算符

|| && ！ 先对关系运算符先修改左侧的值在对右侧的值进行判定。|| 如果左侧的值为true将不会再去判定右侧的值。

关系运算符和逗号分号运算符都是一个顺序点（以运算符为中心分为左侧和右侧），顺序点会先判断左侧。

&& 运算符优先级高于 ||。

字符函数库

cctype ：isalpha(ch)测试是否是字母、ispunct(ch)测试是否为标点符、isdigits(ch)测试是否是数字、isapace(ch)测试字符是否是换行符、空格、制表符。

更多库函数见库文件。

switch效率高于else if

全局错误码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
int *_fpErrNo(void)
{
   static int dwLocalErrNo = 0;
   return &dwLocalErrNo;
}

#define ErrNo (*_fpErrNo())
#define EOUTOFRANGE  1
//define other error macros...

int Callee(void)
{
    ErrNo = 1;
    return -1;
}

int main(void)
{
    ErrNo = 0;
    if((-1 == Callee()) && (EOUTOFRANGE == ErrNo))
        printf("Callee failed(ErrNo:%d)!\n", ErrNo);
    return 0;
}

非局部跳转

goto只能在函数内跳转，非局部跳转是在函数之间。

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
jmp_buf gJmpBuf;
void Func1(){
    printf("Enter Func1\n");
    if(0)longjmp(gJmpBuf, 1);
}
void Func2(){
    printf("Enter Func2\n");
    if(0)longjmp(gJmpBuf, 2);
}
void Func3(){
    printf("Enter Func3\n");
    if(1)longjmp(gJmpBuf, 3); // 跳转到buf保存的堆栈，也就是回到setJmp的位置
}

int main(void)
{
    int dwJmpRet = setjmp(gJmpBuf); // 保存此时的运行堆栈到buf
    printf("dwJmpRet = %d\n", dwJmpRet);
    if(0 == dwJmpRet)
    {
        Func1();
        Func2();
        Func3();
    }
    else
    {
        switch(dwJmpRet)
        {
            case 1:
                printf("Jump back from Func1\n");
            break;
            case 2:
                printf("Jump back from Func2\n");
            break;
            case 3:
                printf("Jump back from Func3\n");
            break;
            default:
                printf("Unknown Func!\n");
            break;
        }
    }
    return 0;
}

setjmp()函数返回longjmp()函数所设置的参数val值，程序将继续执行setjmp调用后的下一条语句(仿佛从未离开setjmp)。参数val为非0值，返回val。若设置为0，则setjmp()函数返回1。

非局部跳转模拟C++的异常处理机制

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
jmp_buf gJmpBuf;
void RaiseException(void)
{
   printf("Exception is raised: ");
   longjmp(gJmpBuf, 1);  //throw，跳转至异常处理代码
   printf("This line should never get printed!\n");
}
double Division(double fDividend, double fDivisor)
{
    return fDividend/fDivisor;
}
int main(void)
{
    double fDividend = 0.0, fDivisor = 0.0;
    printf("Enter the dividend: ");
    scanf("%lf", &fDividend);
    printf("Enter the divisor : ");
    if(0 == setjmp(gJmpBuf))  //try块
    {
        scanf("%lf", &fDivisor);
        if(0 == fDivisor) //也可将该判断及RaiseException置于Division内
            RaiseException();
        printf("The quotient is %.2lf\n", Division(fDividend, fDivisor));
    }
    else  //catch块(异常处理代码)
    {
        printf("The divisor cannot be 0!\n");
    }

    return 0;
}

longjmp()函数必须在setjmp()函数的作用域之内。在调用setjmp()函数时，它保存的程序执行点环境只在当前主调函数作用域以内(或以后)有效。若主调函数返回或退出到上层(或更上层)的函数环境中，则setjmp()函数所保存的程序环境也随之失效(函数返回时堆栈内存失效)。这就要求setjmp()不可该封装在一个函数中，若要封装则必须使用宏(详见《C语言接口与实现》“第4章 异常与断言”)。

断言

1
2
3
4
5
6
7
#undef assert
#ifdef NDEBUG
    #define assert(expr)        ((void) 0)
#else
    #define assert(expr)        ((void) ((expr) || \
         (printf("[%s(%d)] Assertion '%s' failed.\n", __FILE__, __LINE__, #expr), while(1){}))
#endif

注意，expr1||expr2表达式作为单独语句出现时，等效于条件语句if(!(expr1))expr2。这样，assert宏就可扩展为一个表达式，而不是一条语句。逗号表达式expr2返回最后一个表达式的值(即0)，以符合||操作符的要求。

各种字节对齐

1
2
3
4
5
6
7
8
9
10
#if (TFDB_WRITE_UNIT_BYTES==2)
    /* aligned with TFDB_WRITE_UNIT_BYTES */
    aligned_value_size = ((aligned_value_size + 1) & 0xfe);
#elif (TFDB_WRITE_UNIT_BYTES==4)
    /* aligned with TFDB_WRITE_UNIT_BYTES */
    aligned_value_size = ((aligned_value_size + 3) & 0xfc);
#elif (TFDB_WRITE_UNIT_BYTES==8)
    /* aligned with TFDB_WRITE_UNIT_BYTES */
    aligned_value_size = ((aligned_value_size + 7) & 0xf8);
#endif

项目地址：https://github.com/smartmx/TFDB/tree/main

赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

从事嵌入式开发