读书笔记——《高质量C++/C编程指南》（3）

吐个泡泡。。。。。

已于 2024-05-08 23:54:25 修改

阅读量1.2k

点赞数 39

分类专栏：读书笔记文章标签： c++ c语言前端

于 2024-05-08 23:51:47 首次发布

本文链接：https://blog.csdn.net/weixin_74197067/article/details/138581447

版权

读书笔记专栏收录该内容

6 篇文章 1 订阅

订阅专栏

前言

前两篇笔记对这本书里面的文件结构、代码风格、命名规则、表达式和基本语句的良好编程习惯做了记录，读书笔记（3）将记录常量与函数设计。

常量

常量是一种标识符，它的值在运行期间恒定不变。

C 语言用 #define 来定义常量（称为宏常量）。

C++ 语言除了 #define 外还可以用const 来定义常量（称为const 常量）。

用直观的常量来表示那些将在程序中多次出现的数字或字符串

例如：
#define MAX 100 /* C 语言的宏常量 */
const int MAX = 100; // C++ 语言的const 常量
const float PI = 3.14159; // C++ 语言的const 常量

const 与 #define 的比较

C++ 语言可以用const 来定义常量，也可以用 #define 来定义常量。

const比 #define 的优点：
（1） const 常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换，没有类型安全检查，并且在字符替换可能会产生意料不到的错误。
（2）有些集成化的调试工具可以对 const 常量进行调试，但是不能对宏常量进行调试。

【规则1】在C++ 程序中只使用const 常量而不使用宏常量，即const 常量完全取代宏常量。

常量定义规则

【规则1】需要对外公开的常量放在头文件中，不需要对外公开的常量放在定义文件的头部。为便于管理，可以把不同模块的常量集中存放在一个公共的头文件中。

【规则2】如果某一常量与其它常量密切相关，应在定义中包含这种关系，而不应给出一些孤立的值。

例如：
const float RADIUS = 100;
const float DIAMETER = RADIUS * 2;

类中的常量

有时我们希望某些常量只在类中有效。由于#define 定义的宏常量是全局的，不能达到目的，于是想当然地觉得应该用const 修饰数据成员来实现。

const 数据成员的确是存在的，但其含义却不是我们所期望的。const 数据成员只在某个对象生存期内是常量，而对于整个类而言却是可变的，因为类可以创建多个对象，不同的对象其const 数据成员的值可以不同。不能在类声明中初始化const 数据成员。以下用法是错误的，因为类的对象未被创建时，编译器不知道SIZE 的值是什么。

数据成员的初始化只能在类构造函数的初始化表中进行。

class A
{
    //⋯
    const int SIZE = 100; // 错误，企图在类声明中初始化const 数据成员
    int array[SIZE]; // 错误，未知的SIZE
};
//const 数据成员的初始化只能在类构造函数的初始化表中进行，例如
class A
{
    //⋯
    A(int size); // 构造函数
    const int SIZE ;
};
A::A(int size) : SIZE(size) // 构造函数的初始化表
{
    //⋯
}
A a(100); // 对象 a 的SIZE 值为100
A b(200); // 对象 b 的SIZE 值为200

怎样才能建立在整个类中都恒定的常量呢？别指望const 数据成员了，应该用类中的枚举常量来实现。例如

class A
{
    //⋯
    enum { SIZE1 = 100, SIZE2 = 200}; // 枚举常量 

    int array1[SIZE1];
    int array2[SIZE2];
};

枚举常量不会占用对象的存储空间，它们在编译时被全部求值。

枚举常量的缺点是：它的隐含数据类型是整数，其最大值有限，且不能表示浮点数（PI=3.14159）。

函数设计

函数是程序的基本功能单元。本章重点论述函数的接口设计和内部实现的一些规则。

函数接口的两个要素是参数和返回值。

C 语言中，函数的参数和返回值的传递方式有两种：值传递和指针传递。

C++ 语言中多了引用传递。由于引用传递的性质象指针传递，而使用方式却象值传递。

引用与指针的比较

引用是 C++中的概念,下面这个就是引用的应用。

int m;
int &n = m;

n 相当于m 的别名（绰号），对n 的任何操作就是对m 的操作。

所以n既不是m 的拷贝，也不是指向m 的指针，其实n就是m它自己。

引用的一些规则如下：
（1）引用被创建的同时必须被初始化（指针则可以在任何时候被初始化）。
（2）不能有NULL 引用，引用必须与合法的存储单元关联（指针则可以是NULL）。
（3）一旦引用被初始化，就不能改变引用的关系（指针则可以随时改变所指的对象）。

以下示例程序中，k 被初始化为i 的引用。语句k =

j 并不能将k修改成为j的引用，只是把k的值改变成为6。由于k 是i 的引用，所以i 的值也变成了6。

int i = 5;
int j = 6;
int &k = i;
k = j; // k 和i 的值都变成了6;

引用的主要功能是传递函数的参数和返回值。

C++语言中，函数的参数和返回值的传递方式有三种：值传递、指针传递和引用传递。

以下是“值传递”的示例程序。由于Func1 函数体内的x 是外部变量n 的一份拷贝，改变x 的值不会影响n, 所以n 的值仍然是0。

void Func1(int x)
{
    x = x + 10;
}
//⋯

int n = 0;
Func1(n);
cout << “n = ” << n << endl; // n = 0

以下是“指针传递”的示例程序。由于Func2 函数体内的x 是指向外部变量n 的指针，改变该指针的内容将导致n 的值改变，所以n 的值成为10。

void Func2(int *x)
{
    (* x) = (* x) + 10;
}
⋯
int n = 0;
Func2(&n);
cout << “n = ” << n << endl; // n = 10

以下是“引用传递”的示例程序。由于Func3 函数体内的x 是外部变量n 的引用，x 和n 是同一个东西，改变x 等于改变n，所以n 的值成为10。

void Func3(int &x)
{
    x = x + 10;
}
⋯
int n = 0;
Func3(n);
cout << “n = ” << n << endl; // n = 10

对比上述三个示例程序，会发现“引用传递”的性质象“指针传递”，而书写方式象“值传递”。实际上“引用”可以做的任何事情“指针”也都能够做。

参数的规则

【规则1】参数的书写要完整，不要贪图省事只写参数的类型而省略参数名字。如果函数没有参数，则用void 填充。

例如：
void SetValue(int width, int height); // 良好的风格
void SetValue(int, int); // 不良的风格
float GetValue(void); // 良好的风格
float GetValue(); // 不良的风格

【规则2】参数命名要恰当，顺序要合理。

把参数名字起得更有意义；一般地，应将目的参数放在前面，源参数放在后面。

【规则3】如果参数是指针，且仅作输入用，则应在类型前加const，以防止该指针在函数体内被意外修改。

例如：
void StringCopy(char *strDestination，const char *strSource);

【规则4】如果输入参数以值传递的方式传递对象，则宜改用“const &”方式来传递，这样可以省去临时对象的构造和析构过程，从而提高效率。

【建议1】参数个数尽量控制在5 个以内。

【建议2】尽量不要使用类型和数目不确定的参数。

返回值规则

【规则1】不要省略返回值的类型。
规定任何C++/ C 函数都必须有类型。如果函数没有返回值，那么应声明为void 类型。

【规则2】函数名字与返回值类型在语义上不可冲突。

违反这条规则的典型代表是C 标准库函数getchar。

例如：
char c;
c = getchar();
if (c == EOF)
⋯

按照 getchar 名字的意思，将变量c 声明为char 类型是很自然的事情。

但getchar 不是char 类型，而是int 类型，其原型如：int getchar(void);

由于c 是char 类型，取值范围是[-128，127]，如果宏EOF 的值在char 的取值范围之外，那么if 语句将总是失败。

【建议1】有时候函数原本不需要返回值，但为了增加灵活性如支持链式表达，可以附加返回值。

例如：字符串拷贝函数strcpy 的原型：char *strcpy(char *strDest，const char *strSrc);

strcpy 函数将strSrc 拷贝至输出参数strDest 中，同时函数的返回值又是strDest。

这样做并非多此一举，可以获得如下灵活性：

char str[20];
int length = strlen( strcpy(str, “Hello World”) );//strcpy函数返回str,刚好可以计算str的长度

【建议2】如果函数的返回值是一个对象，

有些场合用“引用传递”替换“值传递”可以提高效率。

而有些场合只能用“值传递”而不能用“引用传递”，否则会出错。

对于赋值函数，应当用“引用传递”的方式返回String 对象。

如果用“值传递”的方式，虽然功能仍然正确，但由于return 语句要把 *this 拷贝到保存返回值的外部存储单元之中，增加了不必要的开销，降低了赋值函数的效率。

class String
{
    //⋯
    // 赋值函数
    String & operate=(const String &other);
    // 相加函数，如果没有friend 修饰则只许有一个右侧参数
    friend String operate+( const String &s1, const String &s2);
private:
    char *m_data;
}
//String 的赋值函数operate = 的实现如下：
String & String::operate=(const String &other)
{
    if (this == &other)
        return *this;
    delete m_data;

    m_data = new char[strlen(other.data)+1];
    strcpy(m_data, other.data);
    return *this; // 返回的是 *this 的引用，无需拷贝过程
}

对于相加函数，应当用“值传递”的方式返回String 对象。

如果改用“引用传递”，那么函数返回值是一个指向局部对象temp 的“引用”。由于temp 在函数结束时被自动销毁，将导致返回的“引用”无效。

例如：c = a + b;此时 a + b 并不返回期望值，c 什么也得不到，流下了隐患。

String a,b,c;
//⋯
a = b; // 如果用“值传递”，将产生一次 *this 拷贝
a = b = c; // 如果用“值传递”，将产生两次 *this 拷贝
//String 的相加函数operate + 的实现如下：
String operate+(const String &s1, const String &s2)
{
    String temp;
    delete temp.data; // temp.data 是仅含‘\0’的字符串
    temp.data = new char[strlen(s1.data) + strlen(s2.data) +1];
    strcpy(temp.data, s1.data);
    strcat(temp.data, s2.data);
    return temp;
}

函数内部实现的规则

我们可以在函数体的“入口处”和“出口处”从严把关，从而提高函数的质量。

【规则1】在函数体的“入口处”，对参数的有效性进行检查。很多程序错误是由非法参数引起的，我们应该充分理解并正确使用“断言”（assert）

【规则2】在函数体的“出口处”，对return 语句的正确性和效率进行检查。
注意事项如下：
（1）return 语句不可返回指向“栈内存”的“指针”或者“引用”，因为该内存在函数体结束时被自动销毁。


char * Func(void)
{
    char str[] = “hello world”; // str 的内存位于栈上——局部变量
    //…
    return str; // 将导致错误
}

（2）要搞清楚返回的究竟是“值”、“指针”还是“引用”。
（3）如果函数返回值是一个对象，要考虑return 语句的效率。

例如
return String(s1 + s2);
这是临时对象的语法，表示“创建一个临时对象并返回它”。

不要以为它与“先创建一个局部对象temp 并返回它的结果”是等价的，

String temp(s1 + s2);
return temp;

实质不然，第二个代码将发生三件事。temp 对象被创建，同时完成初始化；然后拷贝构造函数把temp 拷贝到保存返回值的外部存储单元中；最后，temp 在函数结束时被销毁（调用析构数）。然而“创建一个临时对象并返回它”的过程是不同的，编译器直接把临时对象创建并初始化在外部存储单元中，省去了拷贝和析构的化费，提高了效率。

类似地，我们不要将
return int(x + y); // 创建一个临时变量并返回它
写成
int temp = x + y;
return temp;

由于内部数据类型如int,float,double 的变量不存在构造函数与析构函数，虽然该“临时变量的语法”不会提高多少效率，但是程序更加简洁易读。

其它建议

【建议1】函数的功能要单一，不要设计多用途的函数。
【建议2】函数体的规模要小，尽量控制在50 行代码之内。
【建议3】尽量避免函数带有“记忆”功能。相同的输入应当产生相同的输出。函数的static 局部变量是函数的“记忆”存储器。建议尽量少用static 局部变量，除非必需。

使用断言

程序一般分为Debug 版本和Release 版本，Debug 版本用于内部调试，Release 版本发行给用户使用。
断言 assert 是仅在Debug 版本起作用的宏，它用于检查“不应该”发生的情况。

下面是一个内存复制函数。在运行过程中，如果assert 的参数为假，那么程序就会中止（一般地还会出现提示对话，说明在什么地方引发了assert）。

void *memcpy(void *pvTo, const void *pvFrom, size_t size)
{
    assert((pvTo != NULL) && (pvFrom != NULL)); // 使用断言
    byte *pbTo = (byte *) pvTo; // 防止改变pvTo 的地址
    byte *pbFrom = (byte *) pvFrom; // 防止改变pvFrom 的地址
    while(size -- > 0 )
    *pbTo ++ = *pbFrom ++ ;
    return pvTo;
}

assert 不是函数，而是宏。程序员可以把assert 看成一个在任何系统状态下都可以安全使用的无害测试手段。
【规则1】使用断言捕捉不应该发生的非法情况。不要混淆非法情况与错误情况之间的区别，后者是必然存在的并且是一定要作出处理的。
【规则2】在函数的入口处，使用断言检查参数的有效性（合法性）。

吐个泡泡。。。。。

关注

39
点赞
踩
10

收藏

觉得还不错? 一键收藏
0
评论
读书笔记——《高质量C++/C编程指南》（3）

【规则1】需要对外公开的常量放在头文件中，不需要对外公开的常量放在定义文件的头部。为便于管理，可以把不同模块的常量集中存放在一个公共的头文件中。【规则2】如果某一常量与其它常量密切相关，应在定义中包含这种关系，而不应给出一些孤立的值。例如：RADIUS * 2;
复制链接

扫一扫