const

时间 2019-11-19

标签 const 繁體版

原文原文链接

const 是constant 的缩写，“恒定不变”的意思。被const 修饰的东西都受到强制保护，能够预防意外的变更，能提升程序的健壮性。因此不少C++程序设计书籍建议：“Use const whenever you need”。数组

const常量
修饰函数参数、返回值，甚至函数的定义体

一、用const 修饰函数的参数

（1）用函数参数进行返回值的：不用const修饰，不然“指针传递/引用传递”都不能正确返回参数值；函数

（2）函数参数做输入：this

输入参数采用“指针传递”，加const 修饰能够防止意外地改动该指针，起到保护做用。

例如StringCopy 函数：spa

void StringCopy(char *strDestination, const char *strSource);.net

其中strSource 是输入参数，strDestination 是输出参数。给strSource 加上const修饰后，若是函数体内的语句试图改strSource 的内容，编译器将指出错误。设计

输入参数采用“值传递”，因为函数将自动产生临时变量用于复制该参数，该输入参数原本就无需保护，因此不要加const 修饰。

不要将函数void Func1(int x) 写成void Func1(const int x)指针

不要将函数void Func2(A a) 写成void Func2(const A a)code

关于内部和非内部数据类型参数传递：对象

对于非内部数据类型的参数而言，void Func2(A a)效率低，由于调用时，须要产生对实参赋值，产生一个临时对象，临时对象构造、拷贝、析构耗时，可改为void Func(A &a)；而引用可能会修改a，故改为void Func(const A &a)。
对于内置数据类型，没有必要写成void Func(const int &x)，由于内部数据类型的参数不存在构造、析构的过程，复制也很是快，“值传递”和“引用传递”的效率几乎至关。

“const &”修饰输入参数的用法：blog

对于非内部数据类型的输入参数，应该将“值传递”的方式改成“const 引用传递”，目的是提升效率。例如将void Func(A a) 改成void Func(const A &a)。
对于内部数据类型的输入参数，不要将“值传递”的方式改成“const 引用传递”。不然既达不到提升效率的目的，又下降了函数的可理解性。例如void Func(int x) 不该该改成void Func(const int &x)。

二、用const 修饰函数的返回值

（1）若是给以“指针传递”方式的函数返回值加const 修饰，那么函数返回值（即指针）的内容不能被修改，该返回值只能被赋给加const 修饰的同类型指针。

例如函数：const char * GetString(void);

以下语句将出现编译错误：char *str = GetString();

正确的用法是：const char *str = GetString();

（2）若是函数返回值采用“值传递方式”，因为函数会把返回值复制到外部临时的存储单元中，加const 修饰没有任何价值。

例如不要把函数int GetInt(void) 写成const int GetInt(void)。

同理不要把函数A GetA(void) 写成const A GetA(void)，其中A 为用户自定义的数据类型。

若是返回值不是内部数据类型，将函数A GetA(void) 改写为const A & GetA(void)的确能提升效率。
此时千万千万要当心，必定要搞清楚函数到底是想返回一个对象的“拷贝”仍是仅返回“别名”就能够了，不然程序会出错。

函数返回值采用“引用传递”的场合并很少，这种方式通常只出如今类的赋值函数中，目的是为了实现链式表达。

示例：

class A  
{  
   A & operate = (const A &other); // 赋值函数
}; 
 
A a, b, c; // a, b, c 为A 的对象
a = b = c; // 正常的链式赋值
(a = b) = c; // 不正常的链式赋值，但合法

解答：

若是将赋值函数的返回值加const 修饰，那么该返回值的内容不容许被改动。
上例中，语句 a = b = c 仍然正确，可是语句 (a = b) = c 则是非法的，由于a=b调用重载函数运算，a=b是成了const对象。

三、const 成员函数(const的做用：说明其不会修改数据成员)

任何不会修改数据成员的函数都应该声明为const 类型。若是在编写const 成员函数时，不慎修改了数据成员，或者调用了其它非const 成员函数，编译器将指出错误，这无疑会提升程序的健壮性。

示例：

如下程序中，类stack 的成员函数GetCount 仅用于计数，从逻辑上讲GetCount 应当为const 函数。编译器将指出GetCount 函数中的错误。

class Stack  
{  
public:  
    void Push(int elem);  
    int Pop(void);  
    int GetCount(void) const; // const 成员函数
private:  
    int m_num;  
    int m_data[100];  
};  
int Stack::GetCount(void) const
{  
     ++m_num; // 编译错误，企图修改数据成员m_num
     Pop(); // 编译错误，企图调用非const 函数
     return m_num;  
}

const 成员函数的声明看起来怪怪的：const 关键字只能放在函数声明的尾部，大概是由于其它地方都已经被占用了。

关于const函数的几点规则：

const对象只能访问const成员函数，而非const对象能够访问任意的成员函数，包括const成员函数。
（由于const对象不能被修改，与const成员函数一致；而非const对象能够修改/不修改）
const对象的成员是不可修改的，然而const对象经过指针维护的对象倒是能够修改的。
const成员函数不能够修改对象的数据，无论对象是否具备const性质，它在编译时，以是否修改为员数据为依据进行检查。
加上mutable修饰符的数据成员,对于任何状况下经过任何手段均可修改,天然此时的const成员函数是能够修改它的。

const function使用实例：

（1）const 函数只能调用 const 函数，即便某个函数本质上没有修改任何数据，但没有声明为const，也是不能被const函数调用的。

示例1：

class my {  
public:  
    string& operator[](const string& s) const
    { return table[s]; }  //编译错误
private:  
    map table;  
};

解答：

当本重载函数声明为const后，就只能调用其余的一样也声明为const的函数；而table[s]实际上调用的是map的下标重载运算函数，该函数并无声明为const。因此去掉本函数的const声明，就能够顺利经过编译了。

示例2：

class A{  
public:  
    A(int n) { num = n; }  
    void incr() { num += 5; }  

    void disp() const 
    { cout << numspan>
    
    int times(int m)  
    { return num * m; }  

     int f() const
    {
    　　incr();//passing `const A' as `this' argument of `void A::incr()' discards qualifiers
    　　disp();// ok
    　　times(2);//passing `const A' as `this' argument of `int A::times(int)' discards qualifiers
    　　return num;  
    }  

private: 
    int num;  
};  

 
int main(int argc, char *argv[])  
{  
    A a(5);  
    a.f();  
    system("PAUSE");  
    return EXIT_SUCCESS;  
}

示例3：

DateTime类是自定义的，isvalid是DateTime类的方法。

bool DateTime::earlier(const DateTime &dt){
    if(!isvalid()) return true;
    if(!dt.isvalid()) return false;
    //出错，提示 The non-const member function "DateTime::isvalid()" is called for "const DateTime"
｝

解答：

每一个非static非const成员函数都有一个隐含的this指针，是非const型的，不能接受const型实参；
在你的函数里，dt是const DateTime &型的，dt.isvalid()至关于将const对象传给非const的this指针，因此出错。
若是isvalid不改变对象状态，能够将earlier成员函数定义为const型。

若是用const来修饰函数，那么函数必定是类的成员函数。

const 类型的成员函数不能返回非const类型的引用。

示例：

class Test  
{  
public :  
    int & GetValue()const;  
    private:  
    int value;  
};  

int &Test::GetValue() const
{  
    return value; //value此时具备const属性，与返回值类型int &的非const属性不匹配
}

解答：

这样的代码在vs2003中提示的错误：error C2440: “return” : 没法从“const int”转换为“int &”。
在const函数中传递this的时候把this变成了const T* const this,因此一个非const的引用指向一个const类型的变量，就会error。

修改：

把int value 改为mutable int value，mutable修饰的变量使之在const函数中能够被改变的。
return value 改为。 return const_cast(value)。const_cast去掉了const性质。
把函数写成const int &Test::GetValue() const ,.这样作的目的是使引用的变量也是const类型的，就至关于const int & b 。
把引用去掉，写成返回值类型的。
把函数后面的const去掉。
返回值不是类的成员变量。

int &Test::GetValue() const
{  
    int temp = value;  
    return temp;  
}

cosnt函数（const放在函数后面）：

在调用成员函数时，对象的传递是经过this隐藏的，const实际上修饰了this指向的对象，假如定义了：

int &Test::GetValue() const
{  
    int temp = value;  
    return temp;  
}

f函数其实有两个参数，第一个是A * const this（this指向的对象是不能改变的）另外一个才是int类型的参数。
若是咱们不想f函数改变参数的值，能够把函数原型改成f(const int),但若是咱们不容许f改变this指向的对象呢？由于this是隐含参数，const无法直接修饰它，就加在函数的后面了，表示this的类型是const A *const this。
const修饰*this是本质，至于说“表示该成员函数不会修改类的数据，不然会编译报错”之类的说法只是一个现象，根源就是由于*this是const类型的。

在C中，常量只的是字面值，如0x1，1L等，const称为只读常量。
const声明的变量在栈里面，只是其内容不能在代码中改变，它不是在静态内存中的，访问它的时候弹栈。
访问cosnt变量时，不能像真正的常量同样从一个已知的固定内存地址中取得，这对早期的C语言编译器是不可能的。
因为const是定义在栈里面的，它在程序运行时才能肯定里面的值是多少，因此在编译的时候不能用它来定义数组大小了。

转载自：http://blog.csdn.net/zcf1002797280/article/details/7816977（侵权即删）