Welcome to CherieLi's Blog!

世上无知己，唯花解我心

开发者测试

2019-11-08

CherieLi

linux

ut
开发者测试 (DT， Developer Testing)

开发者所做的测试。

可控制性，可观测性，可定位性。

可定位性：不管故障被自愈，容错，还是最终失败，异常都需要输出，不能被内部逻辑完全消化。

日志要分层（INFO/WARN/ERROR）,日志量与可定位性要权衡，太少不足以定位问题，太多影响性能，浪费磁盘空间。

有时过程中的交互消息/事件、状态、性能、资源等过程信息输出对问题定位也有非常关键的作用。

测试分层：UT:IT:ST = 7:2:1

单元测试（UT， Unit Test）

单元：最小粒度的功能单元/工作单元。

单元测试：一段自动化的代码。

单元测试（Unit Testing）是用来对一个模块、一个函数或者一个类来进行正确性检验的测试工作。

一个单元测试是一段自动化的代码，这段代码调用被测试的工作单元，之后对这个单元的单个最终结果的某些假设进行校验。单元测试几乎都是用单元测试框架编写的；只要产品代码不发生变化，单元测试的结果是稳定的。

CUnit
测试框架gtest/gmock

https://github.com/google/googletest/tree/main/googletest/samples

https://github.com/google/googletest/tree/main/googlemock/test

DECLARE_FUNCTION_MOCK
IMPLEMENT_FUNCTION_MOCK
EXPECT_FUNCTION_CALL
（WillOnce，WillRepeatedly，Invoke）

https://www.cnblogs.com/welkinwalker/archive/2011/11/29/2267225.html
https://www.cnblogs.com/coderzh/archive/2009/04/06/1426755.html

gtest的官方网站是： http://code.google.com/p/googletest/

测试框架关键字简介：

1.TEST_F宏：每个宏定义一个测试用例，宏的两个参数分别代表测试套名和测试用例名

2.SetUp和TearDown: 在每个测试用例调用前和调用后执行

3.SetUpTestCase和TearDownTestCase：在测试套调用前和调用后执行，必须为static void类型

4.EXPECT_EQ:预期结果检查

5.MOCK_METHOD1,EXPECT_CALL：对一个类的接口进行打桩/模拟

单元测试原则FIRST：

F-FAST（快速原则）

I-Independent(独立原则)

R-Repeatable(可重复原则)

S-Self Validating（自我验证原则）

T-Timely(及时原则)

单元测试用例需要符合BCDE原则：

B：Border 边界值测试

C：Correct 正确的输入

D：Design 与设计文档相结合

E：Error 强制的错误输入

单元测试的作用： 1.单元测试描述了代码的预期行为，可以最有效地保证代码正确运行 2.由于单元规模较小，当因为代码变更出现问题的时候，可以帮助我们快速定位问题 3.有单元测试覆盖的代码，让我们更有信心，敢于放心做代码重构

集成测试（IT， Integration Test）

集成测试也叫组装测试或联合测试，按照设计要求将各个单元，组件或子系统集成到一起测试是否能正确运行。

系统测试（ST， System Test）

系统测试是对整个系统的测试，将硬件，软件，操作人员看作一个整体，检验它是否有不符合系统说明书的地方。

测试驱动开发（TDD, Test Driven Development）

TDD = TFD + Refactoring 即测试先行加上重构。

测试驱动开发是一种由一系列短小迭代组成的软件开发技术。

UT中的替身对象

测试对象概述
- Dummy: 不被使用的占位
- Stub: 提供假的数据
- Mock:提供期望的行为
- Spy:能够存储数据
- Fake:简化版的实现
自测

（单选题）1.软件测试是软件质量保证的重要手段，（）是软件测试中的最基础环节
- 功能测试
- 单元测试
- 结构测试
- 验收测试
2.关于软件测试，以下说法错误的是（）
- 测试是为了发现程序中的错误而执行程序的过程
- 好的测试方案是尽可能发现迄今为止尚未发现的错误的测试方案
- 成功的测试是发现了至今为止尚未发现的错误的测试
- 软件测试的目的是使程序符合结构化原则
（多选题）1.关于可测试性，以下描述正确的是：（）
- 可隔离性指软件元素（功能单元、模块/组件等）被分解/隔离的能力，也有称可分解性。
- 可控制性指对广义输入的控制能力，广义输入包括：被测对象的初始状态构造，被测对象的输入，注入到被测对象内部的异常。
- 可观测性指对广义输出的观察能力；广义输出包括：被测对象的内部状态或事件（过程），被测对象实际的输出（结果）。
- 可定位性指输出信息支撑问题分析的能力。
2.关于单元测试，以下说法正确的是：（）
- 单元测试主要针对对外暴露的小粒度功能接口的测试，未对外暴露的内部函数不需要测试
- 面向对象语言，单元测试主要测试类对外暴露的公共接口；对于面向过程的语言（C语言等），单元测试主要测试头文件中对外暴露的接口。
- UT测试也需要做测试设计，且要从黑盒（功能）角度设计，从输入(I)、处理(B)、预期输出(O)的角度进行用例分析设计
- UT测试需要将功能单元隔离开测试，一方面需要代码具有较好的可隔离性，另一方面，为了做UT，需要做适当的代码重构提升代码可隔离性，也就是说，做UT可以提升内部质量（代码架构质量）。
3.关于测试分层，以下说法正确的是：（）
- 耦合/依赖大的功能单元或者组件不要强行隔离测试，建议要么通过架构优化，解耦开，要么直接集成测试
- 虽然耦合/依赖大的功能单元/组件拆分测试的成本较大，但是为了追求金字塔测试分层，还是要将功能单元/组件强行拆分隔离开测试
- 通过持续重构保持单元/模块/组件边界清晰，提升代码的可隔离性，降低功能单元/模块/组件分解的成本，从而逐步的朝着金字塔分层的方向优化
- 所有的产品测试分层都是分UT、IT、ST三层
测试框架

• C/C++单元测试框架gtest
• Java单元测试框架JUnit
• Python单元测试框架PyUnit
• go单元测试框架可以用go自带的gotest包

相关书籍

• 《软件测试基础教程（第2版）》

• 《有效的单元测试》

• 《JUnit Recipes-程序员使用测试技巧》（JAVA）

• 《软件测试》

• 《Clean Code》

• 《重构—改善既有代码的设计》

• 《xUnit测试模式–测试码重构》

• 《单元测试之道》

• 《实战Infusion 代码坏味道浅析》（JAVA）

相关链接

• 白盒测试覆盖技术：https://blog.csdn.net/virus2014/article/details/51217026

• JUnit4（JAVA）：https://github.com/junit-team/junit4/wiki

• Mockito（JAVA）：http://static.javadoc.io/org.mockito/mockito-core/2.25.1/org/mockito/Mockito.html

• 《Debugging with GDB》：https://www.gnu.org/software/gdb/documentation/
Read All

dest	-	指向要复制到的字符数组的指针
src	-	指向复制来源的字符数组的指针
count	-	要复制的最大字符数
destsz	-	目标缓冲区的大小

dest	-	指向要复制的对象的指针
destsz	-	目标中要修改的最大字节数（典型地为目标对象的大小）
src	-	指向复制来源对象的指针
count	-	复制的字节数

a.下载所需要的rpm包，gcc需要安装比较多的rpm包，而且不同rpm包之间具有依赖关系，需要按照一定顺序安装，这里推荐直接下载附件；
b.把下载好的附件解压，复制到Linux环境下，例如复制到~/home文件夹下；
c.执行 cd /home/gcc-4.8.5 ，进入该目录下，执行 rpm -ivh –force *，等待安装完成即可；
d.执行 gcc –version，出现版本号说明gcc安装成功。

g++ test.cpp  --verbose -I/home/lzy

https://bbs.huaweicloud.com/blogs/308450

https://colobu.com/2018/08/28/15-Most-Frequently-Used-GCC-Compiler-Command-Line-Options/

15个最常用的GCC编译器参数

1. 指定编译输出的名字

生成一个a.out文件

gcc main.c

使用参数-o, 可以指定输出的文件名。

gcc main.c -o main

2. 通过-Wall参数启用所有警告

gcc -Wall main.c -o main

3. 使用-E参数只产生预处理输出

gcc -E main.c > main.i

gcc命令将结果输出在stdout中，所以你可以把它重定向到任意的文件中，在上面的例子中，重定向到main.i文件中。

4. 使用-S参数只产生汇编代码

gcc -S main.c > main.s

文件main.s包含汇编代码。

5. 使用-C参数只产生编译的代码

gcc -C main.c

代码产生main.o, 包含机器级别的代码或者编译的代码。

-C参数只产生编译的代码(没有链接link)。

6. 使用-save-temps参数产生所有的中间步骤的文件

$ gcc -save-temps main.c

$ ls

a.out main.c main.i main.o main.s

7. 使用-l参数链接共享库

gcc -Wall main.c -o main -lCPPfile

上面的代码会链接libCPPfile.so，产生可执行文件main。

pthread库不是Linux系统默认的库，连接时需要使用库libpthread.a,所以在使用pthread_create创建线程时，在编译中要加-lpthread参数:

gcc -o test -lpthread test.c

8. 使用-fPIC产生位置无关的代码

$ gcc -c -Wall -Werror -fPIC Cfile.c

$ gcc -shared -o libCfile.so Cfile.o

产生共享库的时候使用了-fPIC参数。

注意-shared产生共享库

9. 使用-V打印所有的执行命令

$ gcc -Wall -v main.c -o main

Using built-in specs.

COLLECT_GCC=gcc

……

10. 使用-ansi参数支持 ISO C89程序

ISO C89不支持C++风格的注释

11. 使用-funsigned-char将char解释为符号的char

$ gcc -Wall -funsigned-char main.c -o main

$ ./main

The Geek Stuff [246]

通过这个参数， char类型被看作为 unsigned char类型

12. 使用-fsigned-char将char解释为有符号的char

$ gcc -Wall -fsigned-char main.c -o main

$ ./main

The Geek Stuff [-10]

使用这个参数， char类型被看作是有符号的

13. 使用-D参数可以使用编译时的宏

$ gcc -Wall -DMY_MACRO main.c -o main

$ ./main

可以看到宏MY_MACRO被定义了，并打印出了结果。

14. 使用-Werror将警告升级为错误

$ gcc -Wall -Werror main.c -o main

15. 使用@参数从文件中读取参数

$ cat opt_file

-Wall -omain

$ gcc main.c @opt_file

16. 使用参数-I指定头文件的文件夹

gcc -I/home/codeman/include input-file.c

17. 使用参数-std指定支持的c++/c的标准

gcc -std=c++11 hello-world.cpp

标准如 c++11, c++14, c90, c89等。

g++ -g -Wall -std=c++11 main.cpp

18. 使用-static生成静态链接的文件

gcc main.c -static -o main -lpthread

使用-shared使用动态库链接。

19. 使用-static-libstdc++静态链接libstdc++

如果没有使用-static,默认使用libstdc++共享库，而-static-libstdc++可以指定使用libstdc++静态库。

20. 使用-M生成文件关联的信息

gcc -M main.c

gcc 命令的常用选项

http://www.runoob.com/w3cnote/gcc-parameter-detail.html

gcc参数详解

选项	解释
-ansi	只支持 ANSI 标准的 C 语法。这一选项将禁止 GNU C 的某些特色，例如 asm 或 typeof 关键词。
-c	只编译并生成目标文件。
-DMACRO	以字符串”1”定义 MACRO 宏。
-DMACRO=DEFN	以字符串”DEFN”定义 MACRO 宏。
-E	只运行 C 预编译器。
-g	生成调试信息。GNU 调试器可利用该信息。
-IDIRECTORY	指定额外的头文件搜索路径DIRECTORY。
-LDIRECTORY	指定额外的函数库搜索路径DIRECTORY。
-lLIBRARY	连接时搜索指定的函数库LIBRARY。
-m486	针对 486 进行代码优化。
-o FILE	生成指定的输出文件。用在生成可执行文件时。
-O0	不进行优化处理。
-O 或 -O1	优化生成代码。
-O2	进一步优化。
-O3	比 -O2 更进一步优化，包括 inline 函数。
-shared	生成共享目标文件。通常用在建立共享库时。
-static	禁止使用共享连接。
-UMACRO	取消对 MACRO 宏的定义。
-w	不生成任何警告信息。
-Wall	生成所有警告信息。

-funroll-loops

gcc来检查代码，进行循环展开，减少循环次数提高性能

gcc -O0 -O1 -O2 -O3 四级优化选项及每级分别做什么优化

https://blog.csdn.net/qq_31108501/article/details/51842166

-O0：不做任何优化，这是默认的编译选项。

-O和-O1：对程序做部分编译优化。使用本项优化，编译器会尝试减小生成代码的尺

寸，以及缩短执行时间。

打开的优化选项：

-fdefer-pop 延迟栈的弹出时间。

-fmerge-constants 尝试横跨编译单元合并同样的常量

-fthread-jumps 分支重定向

-floop-optimize 常量表达式从循环中移除，简化判断循环的条件

-fif-conversion 将条件跳转转换为等价的无分支型式

-fif-conversion2

-fdelayed-branch 根据指令周期时间重新安排指令

-fguess-branch-probability 采用随机模式猜测分支被执行的可能性

-fcprop-registers 减少调度依赖性并且删除不必要的寄存器复制操作

-O2：是比O1更高级的选项，进行更多的优化。提高了生成代码的执行效率。

-fforce-mem

-foptimize-sibling-calls

-fstrength-reduce

-fcse-follow-jumps

-fcse-skip-blocks

-frerun-cse-after-loop

-frerun-loop-opt

-fgcse-lm

-fgcse-sm

-fgcse-las

-fdelete-null-pointer-checks

-fexpensive-optimizations

-fregmove

-fschedule-insns

-fschedule-insns2

-fsched-interblock

-fsched-spec-load

-fcaller-saves

-fpeephole2

-freorder-blocks

-freorder-functions

-fstrict-aliasing

-funit-at-a-time

-falign-functions

-falign-jumps

-falign-loops

-falign-labels

-fcrossjumping

-O3：比O2更进一步的进行优化。

-finline-functions

-fweb

-frename-registers

-funswitch-loops

-Os：主要是对程序的尺寸进行优化。

Os会关闭如下选项： -falign-functions -falign-jumps -falign-loops -falign-labels -freorder-blocks -fprefetch-loop-arrays

O1优化会消耗少多的编译时间，它主要对代码的分支，常量以及表达式等进行优化。

O2会尝试更多的寄存器级的优化以及指令级的优化，它会在编译期间占用更多的内存和编译时间。

O3在O2的基础上进行更多的优化，例如使用伪寄存器网络，普通函数的内联，以及针对循环的更多优化。

Os主要是对代码大小的优化，我们基本不用做更多的关心。通常各种优化都会打乱程序的结构，让调试工作变得无从着手。并且会打乱执行顺序，依赖内存操作顺序的程序需要做相关处理才能确保程序的正确性。

gcc参数详解

http://www.runoob.com/w3cnote/gcc-parameter-detail.html

100个gcc小技巧

https://wizardforcel.gitbooks.io/100-gcc-tips/content/address-sanitizer.html

Read All

流控

2019-10-15

CherieLi

算法

flowcontrol

流控常见算法

1.令牌桶算法

令牌生成算法：

A.投资收益比值法

B.二分逼近法

C.等比法

参考文档

https://cloud.tencent.com/developer/article/1692032

Read All

统一初始化

2019-10-14

CherieLi

读书笔记

C++

初始化
统一初始化（Uniform initialization）

初始化

C++的初始化有很多方式：默认初始化，值初始化，直接初始化，拷贝初始化，列表初始化

1.默认初始化（default initialization）

默认初始化是指定义变量时没有指定初值时进行的初始化操作。

（1）内置类型变量（如int，double，bool等），如果定义在语句块外（即｛｝外），则变量被默认初始化为0；如果定义在语句块内（即｛｝内），变量将拥有不确定的值。

#include <iostream>
using namespace std;
int a;
int main()
{
    int b;
    cout << a << endl;
    cout << b << endl;
    return 0;
}

输出结果：

（2）对于类类型的变量（如string或其他自定义类型），不管定义于何处，都会执行默认构造函数。如果该类没有默认构造函数，则会引发错误。因此，建议为每个类都定义一个默认构造函数（=default）。

示例一：默认构造函数由编译器自动生成

#include <iostream>
using namespace std;
class testA
{
    public:
        void printf() const
        {
            cout << data << endl;
        }
    private:
        int data;
};

testA a;
int main()
{
    testA b;

    a.printf();
    b.printf();

    return 0;
}

输出结果：

示例二：定义一个构造函数，阻止编译器自动生成默认构造函数

#include <iostream>
using namespace std;

class testA
{
    public:
        testA(int a)
        {
            data = a;
        }

        void printf() const
        {
            cout << data << endl;
        }
    private:
        int data;
};

testA a;

int main()
{
    testA b;

    a.printf();
    b.printf();

    return 0;
}

编译出错：error:no matching function for call to ‘testA::testA()’

a与b都无法初始化

2.值初始化（value initialization）

值初始化是值使用了初始化器（即使用了圆括号或花括号）但却没有提供初始值的情况。

#include <string>
#include <vector>
#include <iostream>
 
struct T1
{
    int mem1;
    std::string mem2;
}; // 隐式默认构造函数
 
struct T2
{
    int mem1;
    std::string mem2;
    T2(const T2&) { } // 用户提供的复制构造函数
};                    // 无默认构造函数
 
struct T3
{
    int mem1;
    std::string mem2;
    T3() { } // 用户提供的默认构造函数
};
 
std::string s{}; // 类 => 默认初始化，值为 ""
 
int main()
{
    int n{};                // 标量 => 零初始化，值为 0
    double f = double();    // 标量 => 零初始化，值为 0.0
    int* a = new int[10](); // 数组 => 每个元素的值初始化
                            //          每个元素的值为 0
    T1 t1{};                // 有隐式默认构造函数的类 =>
                            //     t1.mem1 被零初始化，值为 0
                            //     t1.mem2 被默认初始化，值为 ""
//  T2 t2{};                // 错误：类无默认构造函数
    T3 t3{};                // 有用户提供默认构造函数的类 =>
                            //     t3.mem1 被默认初始化为不确定值
                            //     t3.mem2 被默认初始化，值为 ""
    std::vector<int> v(3);  // 值初始化每个元素
                            // 每个元素的值为 0
    std::cout << s.size() << ' ' << n << ' ' << f << ' ' << a[9] << ' ' << v[2] << '\n';
    std::cout << t1.mem1 << ' ' << t3.mem1 << '\n';
    delete[] a;
}

输出结果：

3.直接初始化（direct initialization）

直接初始化是指采用小括号的方式进行变量初始化（小括号里一定要有初始值，如果没提供初始值，那就是值初始化了！）

#include <string>
#include <iostream>
#include <memory>

struct Foo {
    int mem;
    explicit Foo(int n) : mem(n) {}
};

int main()
{
    std::string s1("test"); // 自 const char* 的构造函数
    std::string s2(10, 'a');

    std::unique_ptr<int> p(new int(1)); // OK：允许 explicit 构造函数
//  std::unique_ptr<int> p = new int(1); // 错误：构造函数为 explicit

    Foo f(2); // f 被直接初始化：
              // 构造函数形参 n 从右值 2 复制初始化
              // f.mem 从形参 n 直接初始化
//  Foo f2 = 2; // 错误：构造函数为 explicit

    std::cout << s1 << ' ' << s2 << ' ' << *p << ' ' << f.mem  << '\n';
}

输出结果：

4.拷贝初始化（copy initialization）

拷贝初始化是指采用等号（=）进行初始化的方式。

#include <string>
#include <utility>
#include <memory>
 
struct A 
{
  operator int() { return 12; }
};
 
struct B 
{
  B(int) {}
};
 
int main()
{
    std::string s = "test"; // OK：构造函数非 explicit
    std::string s2 = std::move(s); // 此复制初始化进行移动
 
//  std::unique_ptr<int> p = new int(1); // 错误：构造函数为 explicit
    std::unique_ptr<int> p(new int(1)); // OK：直接初始化
 
 
    int n = 3.14;    // 浮点整型转换
    const int b = n; // 不受 const 与否
    int c = b;       // ……影响
 
 
    A a;
    B b0 = 12;
//    B b1 = a; // < 错误：要求从 'A' 到非标量类型 'B' 的转换
    B b2{a};        // < 等同：调用 A::operator int() ，然后是::B(int)
    B b3 = {a};     // <
    auto b4 = B{a}; // <
 
//    b0 = a; // < 错误：需要重载赋值运算符
}

（1）对于内置类型变量（如int，double，bool等），直接初始化与拷贝初始化差别可以忽略不计。

（2）对于类类型的变量（如string或其他自定义类型），直接初始化调用类的构造函数（调用参数类型最佳匹配的那个），拷贝初始化调用类的拷贝构造函数。

特别的，当对类类型变量进行初始化时，如果类的构造函数采用了explicit修饰而且需要隐式类型转换时，则只能通过直接初始化而不能通过拷贝初始化进行操作。

统一初始化（Uniform initialization）

在C++ 11之前，所有对象的初始化方式是不同的。

直接初始化（小括号）

拷贝初始化（等号）

值初始化（花括号） C++ 11努力创造一个统一的初始化方式。其语法是使用{}和std::initializer_list。（列表初始化）

它采用一对花括号（即｛｝）进行初始化操作。能用直接初始化和拷贝初始化的地方都能用列表初始化，而且列表初始化能对容器进行方便的初始化。

int values[]{1,2,3};
vector<int> v{2,3,5,7,11,12,17};
vector<string> cities{"Berlin","New York","London"};
complex<double> c{4.0,3.0};

原理：

编译器看到{t1,t2,…tn}的参数列表，首先自动调用参数初始化，将其转换成initializer_list,它关联至一个array<T,n>。调用函数时该array内的元素可被编译器分解逐一传给函数，但若函数参数是个initializer_list,调用者却不能给予数个T参数然后以为它们会被自动转为一个initializer_list传入。

int i;   //i没有定义值
int j{};   //初始化为0
int *p;  // 没有定义值
int *q{};  //初始化为nullptr

构造函数

#include <string>
#include <iostream>
#include <memory>
using namespace std;
class P {
public:
  P(int a,int b) { cout << "P(int, int), a=" << a << ", b=" << b << endl; }
  
};
int main()
{
    P p(77,5);
    P q{77,5};
    P r{77,5,42};
    P s = {77, 5};
    return 0;
}

C++会先使用{}中的参数生成一个std::initializer_list对象，然后调用赋值对象的构造函数。

在stl库中出现大量的这种使用方式。

forward_list.h

stl_map.h

stl_algo.h

stl_bvector.h

stl_set.h

stl_list.h

basic_string.h

#include <string>
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{
    vector<int> v1{2, 5, 7, 13, 69, 83, 50};
    vector<int> v2({2, 5, 7, 13, 69, 83, 50});
    vector<int> v3;
    v3 = {2, 5, 7, 13, 69, 83, 50};
    v3.insert(v3.begin() + 2, {0, 1, 2, 3, 4});

    for (auto i : v3)
        cout << i << ' ';
    cout << endl;

    cout << max({string("Ace"), string("Stacy"), string("Sabrina"),
               string("Barkley")})<<endl; // Stacy  字典排序
    cout << min({string("Ace"), string("Stacy"), string("Sabrina"),
               string("Barkley")})<<endl; // Ace
    cout << max({54, 16, 48, 5})<<endl;     // 54
    cout << min({54, 16, 48, 5})<<endl;     // 5
    return 0;
}

可能出现的问题(Narrowing Initializations)

  int x1(5.3);                     // x1的值为5
  int x2 = 5.3;                    // x2的值为5
  int x3{5.0};                     // error
  int x4{5.3};                     // error
  char c1{7};                      // OK,c1的值是ascii码对应的字符
  char c2{99999};                  // error ,99999不能与一个字符对应
  std::vector<int> v1{1, 2, 4, 5}; // OK
  std::vector<int> v2{1, 2.3, 4, 5.6}; // Error
  int a {}

Read All

11/14

Welcome to CherieLi's Blog!

开发者测试

开发者测试 (DT， Developer Testing)

单元测试（UT， Unit Test）

集成测试（IT， Integration Test）

系统测试（ST， System Test）

测试驱动开发（TDD, Test Driven Development）

UT中的替身对象

自测

测试框架

字符串复制与缓冲区复制

1.strlen函数与sizeof关键字

2.strcpy,strncpy, strncpy_s（字符串复制）

2.1 strcpy

2.2 strncpy

2.3 strncpy_s

3. memcpy与memcpy_s（缓冲区复制）

3.1 memcpy

3.2 memcpy_s

gcc编译

安装GCC（以4.8.5为例）：

15个最常用的GCC编译器参数

1. 指定编译输出的名字

2. 通过-Wall参数启用所有警告

3. 使用-E参数只产生预处理输出

4. 使用-S参数只产生汇编代码

5. 使用-C参数只产生编译的代码

6. 使用-save-temps参数产生所有的中间步骤的文件

7. 使用-l参数链接共享库

8. 使用-fPIC产生位置无关的代码

9. 使用-V打印所有的执行命令

10. 使用-ansi参数支持 ISO C89程序

11. 使用-funsigned-char将char解释为符号的char

12. 使用-fsigned-char将char解释为有符号的char

13. 使用-D参数可以使用编译时的宏

14. 使用-Werror将警告升级为错误

15. 使用@参数从文件中读取参数

16. 使用参数-I指定头文件的文件夹

17. 使用参数-std指定支持的c++/c的标准

18. 使用-static生成静态链接的文件

19. 使用-static-libstdc++静态链接libstdc++

20. 使用-M生成文件关联的信息

gcc 命令的常用选项

gcc -O0 -O1 -O2 -O3 四级优化选项及每级分别做什么优化

gcc参数详解

100个gcc小技巧

流控

流控常见算法

参考文档

统一初始化

初始化

1.默认初始化（default initialization）

2.值初始化（value initialization）

3.直接初始化（direct initialization）

4.拷贝初始化（copy initialization）

统一初始化（Uniform initialization）