C++代码优化(1):条款1~4

WGzZsyu

已于 2022-12-08 15:41:11 修改

阅读量384

点赞数

分类专栏： C++ 代码优化文章标签： c++

于 2022-12-07 03:08:15 首次发布

本文链接：https://blog.csdn.net/RNGWGzZs/article/details/128209106

版权

C++ 代码优化专栏收录该内容

4 篇文章 0 订阅

订阅专栏

"不要烟火不要星光，只要问问你内心的想法。"

本栏仅仅由对《Effictive C++》其中的一系列条款，掺杂着自己一些愚钝的理解而写的。

---前言

条款01:

尽量以const、enum、inline 替换 #define

在谈及上述好几个关键字与define宏定义的关系，我们不得不谈谈他们各自在编码时的使用情况。

(1)小试牛刀地回顾

①const 与 enum

#include<iostream>
using namespace std;

enum Color
{
	Red,
	Blow,
	Black
};

int main()
{
	const int a = 10;
	cout << "a:" << a << endl;
	cout << "Red:" << Red << endl;

	//Red = 3;
	//a = 3;

	return 0;
}

②inline 与 define

上述的enum、const 或许我们都在C中经常看到。 inline是个什么东西呢？

inline是一种“用于实现”的关键字，而不是一种“用于声明”的关键字。

想想一个场景:

一个函数其代码量短小,但是很多地方都会调用，也就是会被反复调用的函数，必然带来的是 main函数为其反复开辟、销毁的栈帧损耗。那么如何避免开辟栈帧了？

在C中提供了一种宏函数调用的方式！

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

#define ADD(x,y) ((x)+(y))

int main()
{
	int x = 4;
	int y = 5;
	cout << "普通函数加法的总和为:" << Add(1, 2) << endl;
	cout << "宏函数加法的总和为:" << ADD(1, 2) << endl;
	return 0;
}

它们的结果完完全全一样的，但是宏函数可以避免栈空间反复的开辟、销毁。

那么宏函数就可以肆无忌惮地乱使用了吗？答案是肯定不是！否则也不会有inline

宏函数的缺陷

1.没有检查类型

2.不支持调试

3.使用复杂

当然前两个也无需多说。宏函数不支持调试的根本原因就在于,宏函数在预处理完之后已经完成了文本替换。

其次,你也可以明显察觉到当上述代码定义宏函数的时候需要加上很多括号。

举个简单的例子:

也许C++正是看到了define宏函数存在的缺点，因此设计了一个新的关键字 inline;

并且还不如像使用宏函数那么拘谨！就当做一个普通的函数即可！

(2)开胃菜

①错误信息与数据冗余

上面的一节，仅仅做了一些要理解本条款的预备知识。

书上也说，老师也说，预处理阶段要经历的几个步骤; 但是没什么感性的认识！我们怎么知道这些是什么个东东？？？

去注释、宏替换、条件编译、头文件展开。

尽管const、enum、宏定义都作为一个语言常量！都保障其数值的常量性。

但:

①如果这个宏定义的数值(DEBUG) 在程序运行的获得一个错误信息却得到一个"2"！而非const 定义下的 DEBUG。如果这份代码不是你写的！你肯定对这个数字"2"的来源无从下手！因为其根本没有进入记号表。

②此外,编译器看到 #define DEBUG 只会盲目地进行替换(它可不会太智能)。从而导致一份代码里出现多份"2".相反如果改用const int DEBUG 则只需要有一份记录即可。

②封装性

C++引入类这个概念，对封装的要求一定比C语言高得多。

#define 与 const

注:

枚举与const:

上述不懂？那就记住!

1. 对于单纯常量，最好以const对象或者 enums替换 define。

2.形似函数的宏，最好用inline 替代。

条款03:

尽可能使用const

(1)小试牛刀地回顾

const是一个非常神奇且用途十分广泛的关键字。它既可以告诉编译器,你是会否应该让某个变量保持不变，也是告诉程序员,哪个变量由const 修饰是不变的！

恐怕各位初学const的时候尤其是到指针那章节！一定会被这个const 弄得晕头转向。

char greetring[] = "Hello";             //non-const pointer,non-const data
char* p1 = greetring;                   //non-const pointer,const data
const char* p2 = greetring;             //const pointer,non-const data
char* const p3 = greetring;             //non-const pointer,const data
const char* const p4 = greetring;       //const pointer,const data
                                                                ---样例取自《Effective C++》

分清 const 到底是修饰的是指针自身还是指针所指向的物

就是区分 const是在 " * " 的左边还是右边;

(2)开胃菜

①const 与迭代器

在C++中,STL大量使用迭代器(类似于指针一样,但不是真的指针)。

可能接触过STL容器的,一定更为头疼里面const的 “漫天使用”。

#include<vector>
#include<iostream>
using namespace std;
int main()
{
	vector<int> v1;
	v1.push_back(1);
	vector<int> v2;
	v1.push_back(1);

	//1.如果你希望得到一个迭代器
	//指向的对象是 可以被修改 但是自己不能指向不同的东西
	//你就需要一个 T* const
	vector<int>::iterator it = v1.begin();
	cout << ++(*it) << endl;

	//2.如果你希望得到一个迭代器
	// 指向的对象是 不能被修改的！
	//你就需要 const T*
	vector<int>::const_iterator cit = v1.cbegin(); //v1.begin()
	cout << ++(*cit) << endl;

	return 0;
}

注:

const迭代器并不是给迭代器+const!

②const 与函数返回值

有些函数的声明会让函数就返回一个const 对象！但是可能有人会觉得多此一举。

多的也不用多说了。很多时候我们或许将“ == ” 写成了 " = " 很明显，如果你对该对象施加了const 那么很容易编译器就会给我们立马找出错误点！而不是让我们盯着眼花缭乱的代码胡乱翻找。

③const对象、非const对象与成员函数

我们先来看看以下代码;

#include<string>
#include<iostream>
using namepace std;
class TextBlock
{
public:
	TextBlock(const char* str)
		:_text(str)
	{}
	//...
	const char& operator[](size_t pos)const  //这两个是operator 函数重载 
	{
		return _text[pos];
	}

	char& operator[](size_t pos)
	{
		return _text[pos];
	}
private:
	string _text;
};

int main()
{
	TextBlock tb("Hello");
	cout << tb[1] << endl;


	const TextBlock ctb("World");
	cout << ctb[1] << endl;

	return 0;
}

上述的境况仅仅是operator[] 的返回类型以致,"由const 版之 operator[] 返回的" const char& 进行赋值动作。

同样,对于non-const成员可以调用const成员函数，这显然是可以进容忍的！上述问题的根本在于，const成员去调用了 non-const成员函数。因此，const成员函数

当然！ operator[]的返回值一定是char& (reference to char) 而非 'char' (这样就变成了右值),否则也无法通过编译。

④如何定义成员函数 const属性？

1.对于成员变量的const属性那即是 —— 不能修改const修饰的成员变量，反之 non-const的成员变量可以轻易地更改。

2.因此一派(bitwise const)认为: 成员函数的const属性也和成员变量的const属性一样。

不能对 const成员函数里的任何成员变量做任何修改！显然，这很符合毒地const常良性的定义。

但事实是这样吗？我们看看下面代码;

#include<iostream>
using namespace std;
class TextBlock
{
public:
	TextBlock(char* str)
		:_ptext(str)
	{}
	//...
	char& operator[](size_t pos) const
	{
		return _ptext[pos];
	}
	void Print()const
	{
		cout << _ptext << endl;
	}
private:
	char* _ptext;
};

int main()
{
	char ch[] = "hello";
	const TextBlock ctb(ch);
	char* pc = &ctb[0];
	cout << "更改前-----------" << endl;
	ctb.Print();
	*pc = 'W';
	cout << "更改后-----------" << endl;
	ctb.Print();
	return 0;
}

不仅如此,难道const成员函数里的成员变量任何改变都不能容忍吗？

logical constness就拥护:

一个const成员函数可以修改它所处理对象内的某些bit！但这种情况只允许出现在检测不出来才得以如此。

mutable(C++11 后引入的新宠)

class TextBlock
{
public:
	TextBlock(char* str)
				:_ptext(str)
			{}
	//...
	size_t lenth()const
	{
		if (!lenghValid)
		{
			_textlength = strlen(_ptext);
			lenghValid = true;
		}

		return _textlength;
	}
private:
	char* _ptext;
	mutable size_t _textlength; //释放 bitwise constness
	mutable bool lenghValid;
};

⑤const 和 non-const避免重复

上面对于bitwise constness 一刀切的问题,mutable 可以解决。但不能解决所有问题。

回到最初的问题;

C++11提供了一个新的方法,即:常量性转除(cast away constness);

然而事实上，使用转型(casting) 是一个糟糕的想法！

但是本例中，仅仅是为了解决代码冗余给人带来的不快。

class TextBlocK
{
public:
	const char& operator[](size_t pos)const
	{
		//..

		return text[pos];
	}

	char& operator[](size_t pos)
	{
		return  //最外层是 去掉const属性
			const_cast<char&>(
				//加上const 属性 去调用 const版本的 operator[] 更加明确！
				static_cast<const TextBlocK&>(*this)[pos] //调用[]
				);
	}
private:
	string text;
};

忽然，你拍一脑袋！为什么不能让const const operator[] 版本去复用非const operator[]?

显然！你肯定不能被容忍这样干！因为const成员函数承诺不会改变其所处理对象的任何状态，非const成员函数则不会保证这样。

同样,如果你非要这样干，那不妨给const对象 const_cast 给它释放掉const 的属性。

当然这等于 “脱了裤子，打屁”。

想说的也就是，非const对象可以去调用非const成员函数也可以去调用 const成员函数，因为非const对象可以对自己的状态选择不做任何修改。

上述不懂？那就记住！

1.将某些变量声明为const 可以让编译器帮助你检测错误。其次 const可以施加于作用域的任何对象，函数参数、函数返回的类型、成员函数自己身上。

2.编译器多半强制实施 bitwise constness，mutable有时可为你提供一种解决方法。

3.当const 与 non-const成员函数有着实质性的等价实现时，令non-const成员函数调用 const成员函数，未尝不是一个值得考虑的选择。

条款4:

确定对象被使用前已先被初始化。

(1)小试牛刀地回顾

class Point
{
	int x, y;
	//.....
};

int main()
{
	Point p;
	return 0;
}

因此,处理这些的最佳办法就是：永远在使用这些对象、使用这些内置类型之前进行初始化。

(2)开胃菜

①区分初始化和赋值

这里提个问题：类的构造函数是赋值还是初始化?

C++规定，对象的成员变量初始化的动作发生在，进入构造函数本体之前。所以在ABEntry进入构造函数之前其中等待Name、Address(自定义类型)已经初始化好了。构造函数调用时，已经是对ABEntry 进行赋值动作了。但可以看到，构造函数对Age(内置类型)就并没有那么友好，里面是随机值！并没对其进行初始化！

对上述ABEntry的最佳的写法时，利用初始化列表(member initialzation list);从而替换赋值的那些琐碎的操作。

显然，第二个版本避免了由default对它进行重新赋值的多余动作。而那些实参都被初始化列表拿去作为实参进行构造拷贝了。当然Name \ Address 分别为 name\address的初值copy。

当然，也有无参的构造函数(默认构造)。都受便于编译器对于自定义类型的处理方式:

②初始化列表与 const、reference

如果没有缺省参数，我们对于const 或者 reference 应该怎么初始化? 难道任让它们各自飞翔？

对于内置类型，可能赋值、初始化的代价不是很大！但是例如const 、 reference 它们一定就需要初值,而不是赋值！

最简单的做法就是，所有成员变量的初始化都交由初始化列表！ "这样做有时候绝对必要，且往往比赋值要高 "

但是，也有classes 拥有多个构造函数和多个成员变量，那样每个构造函数都写初始化列表，未免有些重复、无聊。因此，对于 “初始化与赋值等价”的成员而言,也可以给它们的赋值操作抽象成一个函数(通常为 private),往往使得代码更加美观。

构造函数无非只是一种 “伪初始化”,而不是初始化列表的“真初始化”那样更可取。

③初始化列表与 static

(这里讨论的问题,更加倾向于工程性的情况，可以进行选读)

static声明的对象,其寿命是随程序的！

我们往往称一个在函数内的static 对象为 local static 其他static对象为 non-local static

如何解决 “定义于不同编译单元内的 non-local static对象无明确定义次序”？

简单来说，就是两个源码文件，各自内部都有一个 non-local static 的对象。如果其中一个源码文件中的 non-local static的初始化需要借助另外一个文件里的 non-local static对象，但事实是，你根本不知道要借助的该对象是否已经初始化完毕了! 毕竟C++并没有该明确的次序定义！

我们来看看下面代码;

class FileSystem
{
public:
	//...
	size_t numDisks() const; //统计Disks众多成员
	//...
};

extern FileSystem tfs; //这是一个全局变量 预备给客户使用的!


class Directory
{
public:
	Directory()
	{
		size_t disks = tfs.numDisks();
	}
};

Directory tempDir;

这样不管是 tempDir依赖tfs 还是之后tempDir被其他依赖。都会在用其被调用的地方，首先被初始化。并且，不会再经历、调用non-local static 对象的 “仿真函数”,也绝不会引发构造、析构带来的性能损耗。

上述不懂？那就记住:
1.为内置类型对对象进行手工初始化，因为C++不保证初始化他们。

2.任何类的成员变量初始化。最好都使用初始化列表。而不要在构造函数内就进行赋值。并且，初始化列表里的排序，最好与变量声明的次序一致。

3.为免除"跨编译单元之初始化次序"问题,请以local static 对象替代 non-local static 对象。

本篇也就到此为止。此外，“每个条款的最后模块都也是该本书最后的总结”

希望对读者能有所帮助。感谢你的阅读~

WGzZsyu

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
C++代码优化(1):条款1~4

"不要烟火不要星光，只要问问你内心的想法。" 本栏仅仅由对《Effictive C++》其中的一系列条款，掺杂着自己一些愚钝的理解而写的。---前言在谈及上述好几个关键字与define宏定义的关系，我们不得不谈谈他们各自在编码时的使用情况。上述的enum、const 或许我们都在C中经常看到。 inline是个什么东西呢？想想一个场景: 一个函数其代码量短小,但是很多地方都会调用，也就是会被反复调用的函数，必然带来的是 main函数为其反复开辟、销毁的栈帧损耗。
复制链接

扫一扫