c++中的const用法（很详细）——转

http://www.cnblogs.com/ymy124/archive/2012/04/16/2451433.html

const给人的第一印象就是定义常量。

(1)const用于定义常量。

例如：const int N = 100;const int M = 200;

     这样程序中只要用到 N、M 就分别代表为整型100、200，N、M 为一常量，在程序中不可改变。

     但有人说他编程时从来不用const定义常量。我相信。但他是不懂得真正的编程艺术，用const定义常量不仅能方便我们编程而且能提高程序的清晰性。你是愿意看到程序中100、200 满天飞，还是愿意只看到简单清晰的N、M。相信有没有好处你慢慢体会。

     还有人说他不用const定义常量，他用#define宏定义常量。可以。但不知道你有没有发现有时#define宏并没有如你所愿在定义常量。下面我们比较比较const和#define。

     1。

     (a) const定义常量是有数据类型的：

     这样const定义的常量编译器可以对其进行数据静态类型安全检查，而#define宏定义的常量却只是进行简单的字符替换，没有类型安全检查，且有时还会产生边际效应(不如你愿处)。所谓边际效应举例如下：

           #define N 100

           #define M 200 + N

           当程序中使用 M*N 时，原本想要 100 * （200+ N ）的却变成了 100 * 200 + N。

     (b)#define宏定义常量却没有。#define <宏名><字符串>，字符串可以是常数、表达式、格式串等。在程序被编译的时候，如果遇到宏名就哟内指定的字符串进行替换，然后再进行编译。

     2。

     有些调试程序可对const进行调试，但不对#define进行调试。

     3。

     当定义局部变量时，const作用域仅限于定义局部变量的函数体内。但用#define时其作用域不仅限于定义局部变量的函数体内，而是从定义点到整个程 序的结束点。但也可以用#undef取消其定义从而限定其作用域范围。只用const定义常量，并不能起到其强大的作用。const还可修饰函数形式参 数、返回值和类的成员函数等。从而提高函数的健壮性。因为const修饰的东西能受到c/c++的静态类型安全检查机制的强制保护，防止意外的修改。

(2)const修饰函数形式参数

形式参数有输入形式参数和输出形式参数。参数用于输出时不能加const修饰，那样会使函数失去输出功能。因为const修饰的东西是不能改变的。

     const只能用于修饰输入参数。

     谈const只能用于修饰输入参数之前先谈谈C++函数的三种传递方式。

     C++函数的三种传递方式为：值传递、指针传递和引用传递。简单举例说明之，详细说明请参考别的资料。

     值传递：

       void fun(int x){

             x += 5;       //修改的只是y在栈中copy x，x只是y的一个副本，在内存中重新开辟的一块临时空间把y的值 送给了x；这样也增加了程序运行的时间，降低了程序的效率。

       }

       void main(void){

             int y = 0;

             fun(y);

             cout<</"y = /"<<y<<endl;  //y = 0;

       }

     指针传递：

        void fun(int *x){

             *x += 5;      //修改的是指针x指向的内存单元值

        }

        void main(void){

             int y = 0;

             fun(&y);

             cout<<<</"y = /"<<y<<endl;  //y = 5;

        }

      引用传递：

         void fun(int &x){

             x += 5;      //修改的是x引用的对象值 &x = y;

        }

        void main(void){

             int y = 0;

             fun(y);

             cout<<<</"y = /"<<y<<endl;  //y = 5;

        }

      看了传递方式后我们继续来谈“const只能用于修饰输入参数”的情况。

当输入参数用“值传递”方式时，我们不需要加const修饰，因为用值传递时，函数将自动用实际参数的拷贝初始化形式参数，当在函数体内改变形式参数时，改变的也只是栈上的拷贝而不是实际参数。

         但要注意的是，当输入参数为ADT/UDT（用户自定义类型和抽象数据类型）时，应该将“值传递”改为“const &传递”，目的可以提高效率。

         例如：

            void fun(A a);//效率底。函数体内产生A类型的临时对象用于复制参数 a，但是临时对象的

                          //构造、复制、析构过程都将消耗时间。

            void fun(A const &a);//提高效率。用“引用传递”不需要产生临时对象，省了临时对象的

                                 //构造、复制、析构过程消耗的时间。但光用引用有可能改变a,所以加const

当输入参数用“指针传递”方式时，加const修饰可防止意外修改指针指向的内存单元，起到保护作用。

         例如：

            void funstrcopy(char *strdest,const char *strsrc)//任何改变strsrc指向的内存单元，

                                                             //编译器都将报错

            些时保护了指针的内存单元，也可以保护指针本身，防止其地址改变。

         例如：

           void funstrcopy(char *strdest,const char *const strsrc)

(3)const修饰函数的返回值

如给“指针传递”的函数返回值加const，则返回值不能被直接修改，且该返回值只能被赋值给加const修饰的同类型指针。

     例如：

        const char *GetChar(void){};

      赋值 char *ch = GetChar();//错误    const char *ch = GetChar();//正确

(4)const修饰类的成员函数(函数定义体)

任何不会修改数据成员的函数都应用const修饰，这样当不小心修改了数据成员或调用了非const成员函数时，编译器都会报错。

     const修饰类的成员函数形式为：int GetCount(void)  const;

（5）用传引用给const取代传值

缺 省情况下，C++ 以传值方式将对象传入或传出函数（这是一个从 C 继承来的特性）。除非你特别指定其它方式，否则函数的参数就会以实际参数（actual argument）的拷贝进行初始化，而函数的调用者会收到函数返回值的一个拷贝。这个拷贝由对象的拷贝构造函数生成。这就使得传值（pass-by- value）成为一个代价不菲的操作。例如，考虑下面这个类层级结构：

class Person {

　public:

　　Person(); // parameters omitted for simplicity

　　virtual ~Person(); // see Item 7 for why this is virtual

　　...

　private:

　　std::string name;

　　std::string address;

};

class Student: public Person {

　public:

　　Student(); // parameters again omitted

　　~Student();

　　...

　private:

　　std::string schoolName;

　　std::string schoolAddress;

};

　　现在，考虑以下代码，在此我们调用一个函数—— validateStudent，它得到一个 Student 参数（以传值的方式），并返回它是否验证有效的结果：

bool validateStudent(Student s); // function taking a Student

// by value

Student plato; // Plato studied under Socrates

bool platoIsOK = validateStudent(plato); // call the function

　　当这个函数被调用时会发生什么呢？

　　很明显，Student 的拷贝构造函数被调用，用 plato 来初始化参数 s。同样明显的是，当 validateStudent 返回时，s 就会被销毁。所以这个函数的参数传递代价是一次 Student 的拷贝构造函数的调用和一次 Student 的析构函数的调用。

　　但这还不是全部。一个 Student 对象内部包含两个 string 对象，所以每次你构造一个 Student 对象的时候，你也必须构造两个 string 对象。一个 Student 对象还要从一个 Person 对象继承，所以每次你构造一个 Student 对象的时候，你也必须构造一个 Person 对象。一个 Person 对象内部又包含两个额外的 string 对象，所以每个 Person 的构造也承担着另外两个 string 的构造。最终，以传值方式传递一个
Student 对象的后果就是引起一次 Student 的拷贝构造函数的调用，一次 Person 的拷贝构造函数的调用，以及四次 string 的拷贝构造函数调用。当 Student 对象的拷贝被销毁时，每一个构造函数的调用都对应一个析构函数的调用，所以以传值方式传递一个 Student 的全部代价是六个构造函数和六个析构函数！

　　好了，这是正确的和值得的行为。毕竟，你希望你的全部对象都得到可靠的初始化和销毁。尽管如此，如果有一种办法可以绕过所有这些构造和析构过程，应该变得更好，这就是：传引用给 const（pass by reference-to-const）：

bool validateStudent(const Student& s);

　　这样做非常有效：没有任何构造函数和析构函数被调用，因为没有新的对象被构造。被修改的参数声明中的 const 是非常重要的。 validateStudent 的最初版本接受一个 Student 值参数，所以调用者知道它们屏蔽了函数对它们传入的 Student 的任何可能的改变；validateStudent 也只能改变它的一个拷贝。现在 Student 以引用方式传递，同时将它声明为 const 是必要的，否则调用者必然担心 validateStudent
改变了它们传入的 Student。

　　以传引用方式传递参数还可以避免切断问题（slicing problem）。当一个派生类对象作为一个基类对象被传递（传值方式），基类的拷贝构造函数被调用，而那些使得对象的行为像一个派生类对象的特殊特性被 “切断”了。你只剩下一个纯粹的基类对象——这没什么可吃惊的，因为是一个基类的构造函数创建了它。这几乎绝不是你希望的。例如，假设你在一组实现一个图 形窗口系统的类上工作：

class Window {

　public:

　　...

　　std::string name() const; // return name of window

　　virtual void display() const; // draw window and contents

};

class WindowWithScrollBars: public Window {

　public:

　　...

　　virtual void display() const;

};

　　所有 Window 对象都有一个名字，你能通过 name 函数得到它，而且所有的窗口都可以显示，你可一个通过调用 display 函数来做到这一点。display 为 virtual 的事实清楚地告诉你：一个纯粹的基类的 Window 对象的显示方法有可能不同于专门的 WindowWithScrollBars 对象的显示方法。

　　现在，假设你想写一个函数打印出一个窗口的名字，并随后显示这个窗口。以下这个函数的写法是错误的：

void printNameAndDisplay(Window w) // incorrect! parameter

{ 

　// may be sliced!

　std::cout << w.name();

　w.display();

}

　　考虑当你用一个 WindowWithScrollBars 对象调用这个函数时会发生什么：

WindowWithScrollBars wwsb;

printNameAndDisplay(wwsb);

　　参数 w 将被作为一个 Window 对象构造——它是被传值的，记得吗？而且使 wwsb 表现得像一个 WindowWithScrollBars 对象的特殊信息都被切断了。在 printNameAndDisplay 中，全然不顾传递给函数的那个对象的类型，w 将始终表现得像一个 Window 类的对象（因为它就是一个 Window 类的对象）。特别是，在 printNameAndDisplay 中调用 display 将总是调用 Window::display，绝不会是
WindowWithScrollBars::display。

　　绕过切断问题的方法就是以传引用给 const 的方式传递 w：

void printNameAndDisplay(const Window& w) // fine, parameter won’t

{

　// be sliced

　std::cout << w.name();

　w.display();

}

　　现在 w 将表现得像实际传入的那种窗口。

　　如果你掀开编译器的盖头偷看一下，你会发现用指针实现引用是非常典型的做法，所以以引用传递某物实际上通常意味着传递一个指针。由此可以得出结 论，如果你有一个内建类型的对象（例如，一个 int），以传值方式传递它常常比传引用方式更高效。那么，对于内建类型，当你需要在传值和传引用给 const 之间做一个选择时，没有道理不选择传值。同样的建议也适用于 STL 中的迭代器（iterators）和函数对象（function objects），因为，作为惯例，它们就是为传值设计的。迭代器（iterators）和函数对象（function
objects）的实现有责任保证拷贝的高效并且不受切断问题的影响。（这是一个“规则如何变化，依赖于你使用 C++ 的哪一个部分”的实例。）

　　内建类型很小，所以有人就断定所有的小类型都是传值的上等候选者，即使它们是用户定义的。这样的推论是不可靠的。仅仅因为一个对象小，并不意味 着调用它的拷贝构造函数就是廉价的。很多对象——大多数 STL 容器也在其中——容纳的和指针一样，但是拷贝这样的对象必须同时拷贝它们指向的每一样东西。那可能是非常昂贵的。

　　即使当一个小对象有一个廉价的拷贝构造函数，也会存在性能问题。一些编译器对内建类型和用户定义类型并不一视同仁，即使他们有同样的底层表示。 例如，一些编译器拒绝将仅由一个 double 组成的对象放入一个寄存器中，即使在常规上它们非常愿意将一个纯粹的 double 放入那里。如果发生了这种事情，你以传引用方式传递这样的对象更好一些，因为编译器理所当然会将一个指针（引用的实现）放入寄存器。

　　小的用户定义类型不一定是传值的上等候选者的另一个原因是：作为用户定义类型，它的大小常常变化。一个现在较小的类型在将来版本中可能变得更 大，因为它的内部实现可能会变化。甚至当你换了一个不同的 C++ 实现时，事情都可能会变化。例如，就在我这样写的时候，一些标准库的 string 类型的实现的大小就是另外一些实现的七倍。

　　通常情况下，你能合理地假设传值廉价的类型仅有内建类型及 STL 中的迭代器和函数对象类型。对其他任何类型，请遵循本 Item 的建议，并用传引用给 const 取代传值。

　　Things to Remember

　　·用传引用给 const 取代传值。典型情况下它更高效而且可以避免切断问题。

　　·这条规则并不适用于内建类型及 STL 中的迭代器和函数对象类型。对于它们，传值通常更合适。

   

只在总结，也许不够专业，不够全面，请大家指教。