常量综述(二)

            参数传递和返回值的小结:
 

void  t( int * ) {}
void  u( const   int   * p)
{
     * p = 2 ;       // error
      int  i =* p;     // OK
      int *  p2 = p;     // error
}

const   char *  v()
{
       return   " result of function v " ;
}

const   int *   const  w()
{
       static   int  i;
       return   & i;
}

int  main()
{
       int  x = 0 ;
       int   * ip =& x;
       const   int   * cip =& x;
      t(ip);         // OK
      t(cip);         // error
      u(ip);         // OK
      u(cip);        // OK
       char *  cp = v();       // error
       const   char   * ccp = v();       // OK
       int   * ip2 = w();      // error
       const   int *   const  ccip = w();       // OK
       const   int *  cip2 = w();             // OK
       * w() = 1 ;         // error
}

              函数t 可以用const和非const 指针做参数，而函数u 只能用const指针作为参数，而且编译器也不允许使用存储在const指针里的地址来建立一个非const指针。
             函数v 返回的是常量的字符数组，编译器把它储存在静态存储区里，所以返回是安全的。
             函数w 返回值要求这个指针和指针所指向的对象均为常量。首先变量i 是静态的，返回后也是有效的地址。但在后面main函数的测试里发现w的返回值可以赋给const int* ，其实这并不矛盾，因为这时w的返回值是当右值来使用的，只有当它用成左值时才会出问题，就像最后一行。
      标准参数传递:
                 在C++里面，对于用户自定义对象我们通常是按引用的方式来传递，但需要注意的一点就是，把一个临时对象传递给接受const引用的函数是可能的，但不能把一个临时对象传递给接受指针的函数。

     类里的常量:
             1.const 成员
        我们如果要在类里面建立一个数组，就需要用const代替#define设置数组大小，这时使用的const意味   着"在这个对象生命期内，它是一个常量"。然而，对这个常量来讲，每个不同的对象可以含有一个不同的值。这样就出现了一个问题，什么时候初始化这个(非static)常量，这里用到了构造函数初始化列表，它出现在函数参数表和冒号后但在构造函数主体开头的花括号前。

 

class  Hony
{
         const   int  size;
     public :
        Hony( int  sz);
         void  print();
};

Hony::Hony( int  sz): size(sz) {}
void  Hony::print()    { cout << size << endl; }

int  main()
{
      Hony a( 1 ),b( 2 ),c( 3 );
      a.print(),b.print(),c.print();
}  

         2.编译期间类里的常量(静态常量)
      还有一种情况就是，如何让一个类有编译期间的常量成员？这里就需要用关键字static ，"不管类的对象被创建多少次，都只有一个实例"，而且必须在static const 定义的地方对它初始化。

#include  < string >
class  StringStack
{
      static   const   int  size = 100 ;
      const   string *  stack[size];
      int  index;
    public :
       StringStack();
        void  push( const   string *  s);
        const   string *  pop();
};

     这里只给出了类的声明，不过可以看出static const 是怎么用的。

       3. 旧代码中的"enum hack"
      在旧版本C++中，不支持在类中使用static const。另外有种典型的解决办法，使用不带实例的无标记enum。

 

class  Bunch
{
          enum  { size = 1000 ; }
          int  i[size];
};

       这里使用的enum不占用对象的存储空间，在编译期间得到枚举值。