CSDN博客

img cphj

Thinking again in C++(一)常量性原理

发表于2003/2/1 15:30:00  1208人阅读

    爱死Thinking in系列了,所以起了这个名字。本文的思想也部分来至于这套书,或参照对比,或深入挖掘,或补益拾慧,或有感而发,既包括Thinking in C++,甚至也包括Thinking in Java。

                          Thinking again in C++(一)常量性原理

    关键字:C++,常量,const,constant,引用,指针,形参,实参,函数,返回值

 

    1.不能将const修饰的任何对象、引用和指针作为赋值表达式的左值。
        const int cx=100;
        const int & rcx=cx;
        const int * pcx=&cx;
        cx=200;                 //error
        rcx=200;                //error
        *pcx=200;               //error

    2.const类型的对象不能直接被non-const类型的别名所引用。
    (1)不能将const类型的对象传递给non-const类型的引用。
        const int cx=100;
        int & rx=cx;            //error
    (2)不能将const类型的实参传递给形参为non-const类型引用的函数。
        void f(int a)
        {
        }
        void g(int & ra)
        {
        }
        const int cx=100;
        f(cx);                  //ok
        g(cx);                  //error
    (3)不能将const类型的对象作为non-const类型引用的函数返回值。
        int & f(const int & rca)
        {
              return rca;       //error
        }
        int x=100;
        f(x);

    3.可以使用const类型别名引用non-const对象。此时通过const引用不能修改对象,但对象可以通过non-const引用被修改。
        int x=100;
        int & rx=x;
        const int & rcx=x;      //ok
        x=200;
        rx=200;
        rcx=200;                //error

    4.指针的属性有两个:指针的类型和指针本身的常量性。其中,指向const对象与指向non-const对象,是不同的指针类型。
        int x=100;
        const int * pcx=&x;     //[1]
        int * px=&x;            //[2]
        int y=100;
        int * const cpy=&y;     //[3]
        int * py=&y;            //[4]
[1][2]两个指针的类型不同;[3][4]两个指针的常量性不同。
    对象与指向对象的指针的规则类似于对象与引用。即,const类型的对象不能直接被non-const类型的指针所指示(同2);可以使用const类型的指针指向non-const对象(同3)。

    5.可以将相同类型(包括常量性)的const指针值赋给non-const指针。
        int x=100;
        int * px;
        const int * pcx=&x;
        px=pcx;                 //error
        int * const cpx=&x;
        px=cpx;                 //ok

    6.若函数的返回值为内建类型或是指针,则该返回值自动成为const性质。但自定义类型则为non-const性质。
        int f()                 //相当于返回const int
        {
              return 100;
        }
        int * g(int & ra)       //相当于返回int * const
        {
              return &ra;
        }
        class CTest
        {
              int n;
        public:
              CTest(int n){this->n=n;}
        };
        CTest h()               //返回的就是CTest
        {
              return CTest(200);
        }

        f()=200;                //error

        int x=100;
        int y=200;
        int * px=&x;
        g(y)=px;                //error
        *g(y)=x;                //ok,从这点可以看出g()返回的不是const int *

        CTest t(100);
        h()=t;                  //ok,但却是完全错误的、危险的做法
                                //所以h()的正确写法是返回const CTest

0 0

相关博文

我的热门文章

img
取 消
img