VC软件开发规范（参数、返回值以及函数内部实现规则）

4.1 参数的规则

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

void SetValue(int nWidth, int nHeight); // 良好的风格

void SetValue(int, int);               // 不良的风格

float GetValue(void);                  // 良好的风格

float GetValue();                      // 不良的风格

☆ 【规则4.1-2】 参数命名要恰当，顺序要合理；

例如编写字符串拷贝函数StringCopy，它有两个参数，如果把参数 名字起为str1和str2，例如：

void StringCopy(char *str1, char *str2);

那么我们很难搞清楚究竟是把str1拷贝到str2中，还是刚好倒过来，可以把参数名字起得更有意义，如叫strSource和strDestination。这样从名字上就可以看出应该把strSource拷贝到strDestination。还有一个问题，这两个参数那一个该在前那一个该在后？参数的顺序要遵循程序员的习惯。一般地，应将目的参数放在前面，源参数放在后面。如果将函数声明为：

void StringCopy(char *strSource, char *strDestination);

别人在使用时可能会不假思索地写成如下形式：

char str[20];

StringCopy(str, “Hello World”); // 参数顺序颠倒

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

void StringCopy(char *strDestination，const char *strSource);

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

☆ 【建议4.1-1】 避免函数有太多的参数，参数个数尽量控制在5个以内。如果参数太多，在使用时容易将参数类型或顺序搞错；

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

C标准库函数printf是采用不确定参数的典型代表，其原型为：

int printf(const chat *format[, argument]…);

这种风格的函数在编译时丧失了严格的类型安全检查。

4.2 返回值的规则

☆ 【规则4.2-1】 不要省略返回值的类型；

C语言中，凡不加类型说明的函数，一律自动按整型处理，这样做不会有什么好处，却容易被误解为void类型；

C++语言有很严格的类型安全检查，不允许上述情况发生。由于C++程序可以调用C函数，为了避免混乱，规定任何C++/ C函数都必须有类型。如果函数没有返回值，那么应声明为void类型

☆ 【规则4.2-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语句将总是失败，这种“危险”人们一般哪里料得到！导致本例错误的责任并不在用户，是函数getchar误导了使用者

☆ 【规则4.2-3】 不要将正常值和错误标志混在一起返回。正常值用输出参数获得，而错误标志用return语句返回；

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

例如字符串拷贝函数strcpy的原型：

char *strcpy(char *strDest，const char *strSrc);

strcpy函数将strSrc拷贝至输出参数strDest中，同时函数的返回值又是strDest。这样做并非多此一举，可以获得如下灵活性：

char str[20];

int nLength = strlen( strcpy(str, “Hello World”) );

☆ 【建议4.2-2】 如果函数的返回值是一个对象，有些场合用“引用传递”替换“值传递”可以提高效率。而有些场合只能用“值传递”而不能用“引用传递”，否则会出错；

对于建议4.2-2，如果函数的返回值是一个对象，有些场合用“引用传递”替换“值传递”可以提高效率，而有些场合只能用“值传递”而不能用“引用传递”，否则会出错，例如：

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

    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;

    }

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

    c = a + b;

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

4.3 函数内部实现的规则

不同功能的函数其内部实现各不相同，看起来似乎无法就“内部实现”达成一致的观点。但根据经验，我们可以在函数体的“入口处”和“出口处”从严把关，从而提高函数的质量。

☆ 【规则4.3-1】 在函数体的“入口处”，对参数的有效性进行检查；

很多程序错误是由非法参数引起的，我们应该充分理解并正确使用“断言”（assert）来防止此类错误。详见4.5节“使用断言”

☆ 【规则4.3-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的变量不存在构造函数与析构函数，虽然该“临时变量的语法”不会提高多少效率，但是程序更加简洁易读。