const和define的比较


在C++中const 和#define 都能够定义常量。但是前者与后者相比，有一些优点。


1.const定义的常量有数据类型，而#define定义的常量没有数据类型。编译器会对前者进行安全类型检查，对后者编译时只是做简单的字符替换替换。


没有安全检查，而且在替换的时候经常出现意想不到的错误，唯一能做的是不要吝啬（）。


2.有些集成化调试工具会对const常量进行调试，但是不能对宏常量进行调试。


//不能再类声明中初始化const数据成员，因为类的对象为被创建时，编译器不知道SIZE是多少。
class A
{
           const int SIZE = 100;
           int array[SIZE];
};

//const数据成员的初始化只能在类构造函数的初始化列表中进行。
class A
{
public:
           //构造函数
          A( int size )
                   :SIZE( size)
          {}

public:
          A( int size);
           const int SIZE;
};

int main()
{
           A a(100);
           A b(200);
          system( "pause");
           return 0;
}




//在整个类中建立恒定的常量，可以用枚举类型
class A
{
           enum{SIZE1=100,SIZE2=200};

           int array1[SIZE1];
           int array2[SIZE2];
};






对于赋值函数，应当使用“引用传递”的方式返回String对象，如果用值传递的话，return *this 语句会把*this 拷贝到返回值的外部存储单元中，增加了不必要的开销，降低了赋值函数的效率。




对于相加函数，应当使用值传递方式返回String对象，如果改为“引用传递”，那么返回值是一个局部变量的引用，局部变量temp在出了函数作用域时会被自动销毁，导致引用无效。




如果函数返回值是一个对象，则应考虑return 语句的效率


  • return  String( s1 + s2) ; //这是临时对象的语法，表示传进一个临时对象并返回它。


String temp(s1+s2）


return temp;


首先，temp对象被创建，同时完成初始化，然后拷贝构造函数把temp拷贝到返回外部存储单元中，最后temp在函数结束时被销毁（调用析构函数），它与上面是不同的，上面的过程中，编译器直接调用构造函数把临时对象创建并初始化在外部存储单元中，省去了拷贝构造和析勾函数的过程，提高了效率。



引用和指针的比较：


引用时C++的产物，他相当于个者个东西起了个别名，实质上还是这个东西。


引用的规则如下：


1.引用被创建的同时必须初始化（指针则可以再任何时候都能被初始化）。


2.不能有NULL引用，必须引用合理的存储单元。


3.一旦引用被初始化，就不能改变引用关系（指针可以改变引用的关系）。 



#include<iostream>
using namespace std;
int main()
{
           char a[] = "hello" ;
          a[0] = 'X';
          cout << a << endl;
           char *p = "hello" ;   //指针p指向常量字符串
          p[0] = 'X';               //运行时会崩溃
          cout << p << endl;
          system( "pause");
           return 0;
}






1.在C++中，尽量用const来定义常量。
2.不能再类中初始化const型数据。


3.赋值函数--->引用传递


4.相加函数---->值传递


5.额....自己看吧