C++ Tips and Tricks

整理了下在C++工程代码中遇到的技巧与建议。

0x00 巧用宏定义。

#define STRINGFY(X) #X

stringfy函数。处理shader文本,可以放在代码中会语法高亮显示,不会因为最终结果是字符串而不highlight。而且可以添加注释,比如:

const char* str = STRINGFY(
    this // line_comment
    i/* block_comment */s
    a
    test
);

在处理后 const char* str = "this i s a test";,注意那个空格。
注意C/C++源码的预处理流程,是先处理注释的,// line_comment会被去掉,Java语言没有预处理,所以在双引号块内需要\n换行,否则会把后面的文本全都注释了。
还有块注释/* block_comment */,会被替换成一个空格,而不是直接去掉,为什么呢?
想想 int x = 0; 是合法语句,in/**/t x = 0;会编译失败就知道了。
翻译阶段(transplation phase)是这么说的
  Phase 3 2) Each comment is replaced by one space character
C++11 的 raw string 借鉴了 Python 的三引号。
  prefix(optional) R "delimiter( raw_characters )delimiter"
在 Phase 3 1)处理,也就是说,如果上面的括号的内容写在 raw string 里,就不会被去掉的,因为定了起始、终止定界符。



  经常看见程序员用 enum 值,打印调试信息的时候又想打印数字对应的字符意思。见过有人写这样的代码 if(today == MONDAY) return "MONDAY"; 一般错误代码会有很多种,应该选用 switch-case 而不是 if-else。因为 if-else 最坏比较N次,switch-case 最坏是lgN次。这里用上宏,代码简介明了。而且也去掉了查找,直接索引到对应的字符串。

// from Android source frameworks/base/cmds/servicemanager/binder.c
#define NAME(n) case n: return #n
const char *cmd_name(uint32_t cmd)
{
    switch(cmd) {
        NAME(BR_NOOP);
        NAME(BR_TRANSACTION_COMPLETE);
        NAME(BR_INCREFS);
        NAME(BR_ACQUIRE);
        NAME(BR_RELEASE);
        NAME(BR_DECREFS);
        NAME(BR_TRANSACTION);
        NAME(BR_REPLY);
        NAME(BR_FAILED_REPLY);
        NAME(BR_DEAD_REPLY);
        NAME(BR_DEAD_BINDER);
    default: return "???";
    }
}

 

enum Day
{
    SUNDAY = 0,
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,

    COUNT
};

const char* toString(Day day)
{
#define CODE(code) array[static_cast<uint32_t>(code)] = #code
    const char* array[COUNT];
    CODE(SUNDAY);
    CODE(MONDAY);
    // ...
#undef CODE

    assert(0 <= day && day < COUNT);
    return array[day];
}

  接着有人说,数组每次运行会初始化一次啊。是的,可以用 static 变量达到仅初始化一次,生成的汇编代码里,会设置一个bit位,用来检查是否已初始化,而作相应的跳转。
  static local variables 在C++11标准里明确指出:在多线程环境下,静态变量的初始化只会出现一次。

If multiple threads attempt to initialize the same static local variable concurrently, the initialization occurs exactly once (similar behavior can be obtained for arbitrary functions with std::call_once).

Note: usual implementations of this feature use variants of the double-checked locking pattern, which reduces runtime overhead for already-initialized local statics to a single non-atomic boolean comparison.

  当然,如果想执行一段代码或一个函数一次。即让函数有 static 变量的效果,可不是也加 static 关键字了(static 函数表示作用域仅在该文件可见),可以这么写:

void do_something()
{
    std::cout<< "hello world\n";
}

bool run_once()
{
    do_something();
    return true;
}

int main()
{
    static bool unused = run_once();

    return 0;
}

这样稍微包装一下,就可以用了。利用 C++11 的 lambda 函数,可以不用额外写函数啦!

static bool unused = []() -> bool { do_something(); return true; }();

最简单的 lambda 函数申明 [](){}; 调用该函数就是 [](){}();
这里没有使用任何数字和字母,怎么样,新奇吧,好玩吧?

 

 

0x01 效率提升之用临时寄存器变量减少成员变量读写次数。
  在 Gameloft 做游戏开发的时候,经常要考虑如何提升游戏的性能。iPhone iPad的硬件水平非常好,Android 的硬件参差不齐,所以游戏从 iOS 移植到 Android 需要考虑 Android 的感受。讲一下我在游戏中遇到的一个问题。类中有一个数组 values,我们对它的计算结果 mTotal 作了缓存,这样不用每帧都计算。

for(int i = 0; i < count; ++i)
    mTotal += values[i];

////////////////////////////////

register int64_t total = 0;
for (int i = 0; i < count; ++i)
    total += values[i];
mTotal = total;

  分割线上下几行代码实现的功能是一样的,但是下面的速度更快些。下面用了一个栈临时变量(用了 register,也可能分配到一个寄存器),不用在每次循环中都读写成员变量,而是计算完后一次写入。可能有些人还是不明白,可以尝试自己反编译成汇编代码查看分析——不管读还是写,都经过先找到对象,再找到成员变量。



0x02 模拟其他语言字符串操作函数,startWith、split。

#include <string>
std::string haystack("malicious");
std::string needle("mali");
bool startWith(const std::string& haystack, const std::string& needle)
{
    return haystack.compare(0, needle.length(), needle) == 0;
}

C++ 里没有提供 startWith 方法,所以 Java 程序员转 C++ 的时候,处理字符串的时候,就很想找到这个函数。其他的函数还有trim,split等。其他转语言的开发者都会有类似的经历。上面用 haystack, needle 是套用 strstr 的参数名,很形象的比喻。man strstr 后,char *strstr(const char *haystack, const char *needle);。另外提一下,取 std::string 的长度,用 length() 或 size() 都可以,但最好用 length(),因为 size() 是 STL 里惯用的概念,以示区别。

#include <string>
#include <sstream>
#include <vector>

std::vector<std::string> split(const std::string& str, char delim)
{
    std::vector<std::string> elems;
    std::stringstream stream(str);
    std::string item;
    while(std::getline(stream, item, delim))
        if(!item.empty())  // skip empty token
            elems.push_back(item);
        
    return elems;
}

  字符串分割函数,如果你熟悉boost库,也可以用boost提供的split。

#include <boost/algorithm/string.hpp>

std::vector<std::string> strs;
boost::split(strs, "string to split", boost::is_any_of("\t "));

 



0x03 scanf、printf 函数
  读取一个字符串,遇到逗号停止,可以这么写:scanf("%[^,]\n", str);。但如果是多个字符串,忽略掉之前的字符,怎么写好呢?例如我想获取"Taylor Swift"的姓,一般的就这么写了,scanf("%s %s", temp, last_name); 这样占用了一个临时变量,改成 scanf("%s ", last_name); scanf("%s ", last_name); 的话,需要两次调用 scanf 函数,最佳的答案是 scanf("%*s %s", last_name); 。是这样的,如果你想忽略某个输入,可以在%后用*。

  写数据前,不能确定缓冲区的大小,该如何写?printf 族函数,大家都知道是用来打印的,很少有人能说出它有返回值,并且返回值是写入字符的个数。这里,返回值就派上用场了。
Calling std::snprintf with zero buf_size and null pointer for buffer is useful to determine the necessary buffer size to contain the output:

const char *fmt = "sqrt(2) = %f";
int sz = std::snprintf(nullptr, 0, fmt, std::sqrt(2));
std::vector<char> buf(sz + 1); // note +1 for null terminator
std::snprintf(&buf[0], buf.size(), fmt, std::sqrt(2));

  Visual C++ 先前没有提供 snprintf 函数,取而代之的是 _snprintf, _snprintf_s。长得像,但是完成的功能与C语言标准有些出入。直到 Visual Studio 2015 才加进来。_snprintf 写时溢出的时候不会写结束的\0字符,_snprintf_s 改善了安全性,但是在溢出的时候返回 -1,而不是标准所要求的返回写入的字符的长度。

#ifndef COMPILER_H_
#define COMPILER_H_

#include "stdio.h"
#include "stdarg.h"

/*
    Microsoft has finally implemented snprintf in VS2015 (_MSC_VER == 1900).

    Releases prior to Visual Studio 2015 didn't have a conformant implementation. 
    There are instead non-standard extensions such as _snprintf() (which doesn't 
    write null-terminator on overflow) and _snprintf_s() (which can enforce 
    null-termination, but returns -1 on overflow instead of the number of 
    characters that would have been written).
*/
#if defined(_MSC_VER) && _MSC_VER < 1900

#define snprintf c99_snprintf
#define vsnprintf c99_vsnprintf

inline int c99_vsnprintf(char *outBuf, size_t size, const char *format, va_list ap)
{
    int count = -1;

    if (size != 0)
        count = _vsnprintf_s(outBuf, size, _TRUNCATE, format, ap);
    if (count == -1)
        count = _vscprintf(format, ap);

    return count;
}

inline int c99_snprintf(char *outBuf, size_t size, const char *format, ...)
{
    int count;
    va_list ap;

    va_start(ap, format);
    count = c99_vsnprintf(outBuf, size, format, ap);
    va_end(ap);

    return count;
}


#endif

#endif /* COMPILER_H_ */


0x04 类型转换。
  在 Gameloft 的日子里,每个月都会定期代码检查(Code Review),结果会通报给各位。很多人不情愿写 C++ 的类型转换,因为它有点长,没C语言的括号来的便捷。导致后来的我养成习惯,写C++代码时候,一律正确使用 C++的转换,而且现在的编译器都会有补全提示功能,不需要敲完整个关键字了。而且在游戏里,避免使用C++ 的 RTTI 和 exception 功能,RTTI 开销大,C++ 以前的异常处理简直就是一鸡肋。这里,矛盾就出现了,dynamic_cast 按照前者(C++ cast)应该使用,按照后者(用了RTTI)是不应该使用的。于是就有了下面的代码,debug 版调试时用来检测正确的类型,在 release 版本强转。很多对象继承于 Entity,于是 Creature 类,就用了所谓的 CREATURE_CAST 宏,其实就是
#define CREATURE_CAST(entity)  downcast<Creature*>(entity)

template <typename To, typename From>
To downcast(From p)
{
#ifdef DEBUG
    To to = dynamic_cast<To>(p);
    assert(to != nullptr);
    return to;
#else
    return static_cast<To>(p);
#endif
}

 

0x05 跳转新玩法。
对于 int a, b 两个值,如果都满足的话,执行某语句。大概很多人都会这么写: if(a >0 && b > 0) do_something();
我在看代码的时候,看到了一种很赞的写法,忘记出处了。写法是: if((a|b) > 0) do_something();
相比而言,少了一条跳转指令。你可以感受一下。
想到这,还要提醒一下,不要在函数里写 if(isGood) return true; else return false; 这样的代码了,直接写 return isGood; 就好了。


0x06  char* 与 std::string 之间的迁移。

<string.h>       =>  <string>
strlen(str)    =>  str.size()
strcmp(s1, s2)   =>  s1.compare(s2)
strcat(s1, s2)   =>  s1 += s2
strcpy(s1, s2)   =>  s1 = s2
strstr(s1, s2)  =>  s1.find(s2)
strchr(str, ch)   =>  str.find_first_of(ch)
strrchr(str, ch)  =>  str.find_last_of(ch)
strspn(s1, s2)   =>  s1.find_first_not_of(s2)
s1 = strdup(s2)  =>  s1 = s2



0x06 更快的循环。
  哪有什么更快的循环,又不是并行计算。其实,我要说得是一些写的不好的代码会导致速度降下来。新手写代码,让代码达到功能需求就完事,很少会像工匠雕琢一样,怎样写出更好的代码。我见过这么写代码的 for(int i = 0; i < strlen(str); i++) ,功能上正确,但是:其一,如果 str 过长,效率就不理想,因为它每次循环会计算长度;其二,虽然编译器可能对 i++ 优化,但是最好还是用前缀自增 ++i 吧;其三,类型不对的整数比较,i是 int 型,而 strlen 返回 size_t 型。然后他修改成这样,size_t len = strlen(str); for(size i = 0; i < len; ++i) 将长度提取出来,用了一个额外的变量。然后我告诉他,可以直接这么写的: for(size i = 0, len = strlen(str); i < len; ++i) 或者 for(const char* p = str; *p != '\0'; ++p) 。
  STL 数据结构在读取的时候,小心调用构造函数的开销。项目里有一人很喜欢带冒号的 for 循环(即 for_each),这样很好,符合 C++ 的信息隐藏的思想。我只是要遍历一遍而已,你不用很明显地告诉我是从第一个自增迭代到最后一个。可是他写的时候,是这样的:
std::vector<Creature> creatures;
for(const Creature creature: creatures)
    creature.roar();

乍一看,没什么啊。我提醒了他,这里应该用引用,for(const Creature& creature: creatures),可以避免调用复制构造函数的开销,就跟函数的传值与传引用一样。


0x07 查找的时候,有没有类似 std::binary_search 一样的函数,我需要的是返回迭代器,而不是仅仅告诉我查找的元素是否存在。
  STL 里面好像没有这样的函数,不过你可以用上 std::lower_bound, std::upper_bound 或 std::equal_range。
template<class Iter, class T>
Iter binary_find(Iter begin, Iter end, T value)
{
    // Finds the lower bound in at most log(last - first) + 1 comparisons
    Iter it = std::lower_bound(begin, end, value);
    if (it != end && !(value < *it))
        return i; // found it
    else
        return end; // not found
}

  STL 取 find 名的函数是返回迭代器的。
  注意,这里是模板函数,不要用 *it == value,要用 !(value < *i)。原因是 std::lower_bound 用的是 < ,即严格的弱序关系。这里的类型 T 可以没有相等==的判断。相等(equality)与等价(equivalence)是不能搞混淆的。可以查看 Scott Meyers 的书 Effective STL 的 19 条,有关 equality 与 equivalence 的区别。
  我在上面也栽倒过。unordered_map (旧时叫 hash_map,但未纳入标准)的类模板声明如下:

template<
    class Key,
    class T,
    class Hash = std::hash<Key>,
    class KeyEqual = std::equal_to<Key>,
    class Allocator = std::allocator< std::pair<const Key, T> >
> class unordered_map;

  我需要完成反向查找,即原先是通过key找value,现在是通过value找key。std::unordered_map<vec3i, int> table; 由于 vec3i 是自己的类,没有默认的 hash 函数,需要自己提供。之前重载关于 tuple 的比较函数,被我写成了

class IndexCompare
{
public:
    bool operator()(const vec3i& a, const vec3i& b) const
    {
        return a.i < b.i || a.j < b.j || a.k < b.k;
    }
};

而正确的应该是这样的,采用"skip while equal, then compare"的策略。std::vector 有重载 operator < 操作符,也可以直接拿来用。

class IndexCompare
{
public:
    bool operator()(const vec3i& a, const vec3i& b) const
    {
        // Operator < and strict weak ordering
        if(a.i != b.i) return a.i < b.i;
        if(a.j != b.j) return a.j < b.j;
        if(a.k != b.k) return a.k < b.k;

        return false;
    }
};

 

0x08 assert/static_assert 断言错误,当断不断,反受其乱。
  写程序,更多的时间是花在调试上。这里为什么会出错,那里为什么没走到?啊啊啊。在可能出错的地方写上断言,可以避免错误多次传播到其他地方。也就是上游犯的错,下游某处运行不畅被发现了,你以为是下游的问题,稍微堵了一下。好像没事了,你欣喜地以为可以关上一个bug了,下次又冒出下游的其他地方出问题了,其实原本你就不应该让上游的错误漂流这么远。《史记》有曰”当断不断,反受其乱”,适当地添加断言,是有好处的。为了让错误及早发现,能用 static_assert 的地方绝不用 assert,即编译时可检查错误的地方绝不推迟到运行时。可以读一下参考的快速失败(fail fast),出错就不应该运行下去。
  C++ 于 C 而言,强类型语言,即很强调类型的安全性。项目中有人犯过这样的错,起先用了一个 int value; 存储能量值,计算的时候用了 abs(value); 后来发现,value 会参与乘除运算,更应该用浮点数表达,于是将类型改成了 float value; 编译也没任何错误。可是他忘记了修改 abs(value) 为 absf(value),编译器作了隐式转换,将 float 转成 int 再调用 int 版的 abs 函数,导致他 debug 了很长时间。其实利用 C++ 的模板就可以避免此类错误,#include <cmath> 而不是 #include <math.h> ,然后调用 std::abs() 实现无缝切换。
  要关注编译器发出的 warning,不要忽略,因为这也可能是 bug 隐患。旧版本的 Visual Studio 对 C++ 标准支持的不好(好事是微软团队在慢慢改进),GCC/Clang 编译器可能检查出更多的错误。


参考:
Scott Meyers 的 Effective C++ 系列丛书
LLVM 的编码规范 http://llvm.org/docs/CodingStandards.html
Martin Fowler 的 Fail Fast

posted @ 2015-11-30 21:50  KAlO2  阅读(2000)  评论(2编辑  收藏  举报