GOOGLE C++编程风格笔记(一)

1.使代码易于管理的方法之一是增强代码一致性

也就是说自己写的代码保持一种风格？

2.通常，每一个.cc文件（C++的源文件）都有一个对应的.h文件（头文件）

参考了C++ Primer Plus第五版中文版 P8

C++实现               源代码的扩展名
UNIX                                C、cc、cxx、c
GNU C++                         C、cc、cxx、cpp、c++
Borland C++                    Cpp
Microsoft Visual C++       cpp、cxx、cc

至少VS2012，G++没有问题

3.头文件保护

一般来说使用工程全路径避免重复问题

4.头文件依赖

可以参考一下代码：

classA.h

class A
{
public:
    A();
    ~A();
    void test1();
};

classA.cpp

#include "classA.h"
#include <stdio.h>
A::A()
{
    printf("A construct\n");
}

A::~A()
{
    printf("A deconstruct\n");
}

void A::test1()
{
    printf("test1\n");
    return;
}

classB.h

class A;
//如果AB是继承的关系，那么就必须包括了
class B
{
public:
    B();
    ~B();
    void testB(A a); //这里只有声明
    void testB1(); 
private:
    //A a;//error C2079: “B::a”使用未定义的 class“A”
    A* a;//数据类型成员 指针可以 到底是用成员或者指针，这是个问题
    static A a1;//静态数据成员变量，可以,但是定义的时候需要依赖
};

classB.cpp

#include "ClassB.h"
#include "classA.h"

A B::a1; //静态成员需要的定义,这时候需要依赖

B::B()
{
    return;
}

B::~B()
{
    return;
}

void B::testB(A a)
{
    //这里使用了A的实现，一定要依赖头文件
    a.test1();
    a1.test1();
    return;
}

void B::testB1()
{
    a1.test1();
    return;
}

test.cpp

#include "classB.h"
#include "classA.h"
int main()
{
    A a;
    B b;
    b.testB1();
    b.testB(a);
    return 1;
}

其中classB对classA存在依赖关系

5.内联函数

不要内联超过10行的函数，主要用于存取函数（accessor、mutator）以及其他一些比较短的关键执行函数。

6.内联函数的头文件

-inl.h文件 例子

#ifndef INLINE_H
#define INLINE_H
#include <stdio.h>
void inline test(){
    printf("COME HERE\n");
}

#endif

1.cc

#include "1-inl.h"
int main()
{
    test();
    return 1;
}

7.函数参数顺序

输入在前，输出在后

8.头文件次序

主要为了防止隐藏依赖，源文件对应的头文件应该放在第一个 例子

1.h

void test1(struct_test* t1);//其中结构体定义没有引用2.h 1.h没有解决自己的依赖问题

2.h

typedef struct 
{
    int a;
    int b;
}struct_test;

1.cc

#include "2.h"
#include "1.h"
//1.h没有排在第一个，形成隐式依赖
#include <stdio.h>
void test1(struct_test* t1)
{
    printf("test1\n");
} 

test.cc

#include "2.h"
#include "1.h"
//1.h没有排在第一个，形成隐式依赖
int main()
{
    struct_test a = {0};
    test1(&a);
    return 1;
}

这样的话，2.h帮助1.h形成隐藏依赖，虽然编译通过，但是1.h单独使用的话，会导致编译错误。