const用法总结以及构造函数、析构函数、拷贝构造函数的深入剖析

     1. 用const时候，通常需要初始化：

#include<iostream>
using namespace std;

int main()
{
int const i;
// error C2734: 'i' : const object must be initialized if not extern

return 0;
}

#include<iostream>
using namespace std;

int main()
{
int i = 1;
const int j = i; // 只能在初始化时赋值

i = j;
//j = i; 此语句错误

return 0;
}

   2. 如果涉及指针，会稍微复杂一点：

#include<iostream>
using namespace std;

int main()
{
int i = 1;
const int *p = &i; // 星在const右，表示*p不能直接改变，但p可变

// *p = 2; 错误：不能直接改变
i = 2; // 正确: *p不能变，但i可以变

int j = 3;
int *q = &j;
p = q; // 正确: p可变

return 0;
}

#include<iostream>
using namespace std;

int main()
{
int i = 1;
int const*p = &i; // 星在const右，表示*p不能直接改变，但p可变

// *p = 2; 错误：不能直接改变
i = 2; // 正确: *p不能变，但i可以变

int j = 3;
int *q = &j;
p = q; // 正确: p可变

return 0;
}

#include<iostream>
using namespace std;

int main()
{
int i = 1;
int *const p = &i; // 星在const左，表示p不能改变，但*p可直接变

*p = 2;
i = 2;

int j = 3;
int *q = &j;
//p = q; 错误：p不能变

return 0;
}

     总结：星在const左，p不能改变；星在const右，*p不能直接改变；星在两个const中间，p不能改变，*p也不能直接改变。

3.  用const来修饰函数参数：

#include<iostream>
using namespace std;

int increase(const int x)
{
// x = x + 1;  错误：x不能改变
return x;
}

int main()
{
return 0;
}

#include<iostream>
using namespace std;

void fun(const int *p)
{
p = NULL; // 正确
// *p = 0; 错误：不能直接改变*p
}

int main()
{
return 0;
}

#include<iostream>
using namespace std;

void fun(const int &x)
{
// x = x + 1; 错误：x不能改变
}

int main()
{
return 0;
}

#include<iostream>
using namespace std;

class A{};

// fun1比fun2的效率要高

void fun1(const A &x) // 不存在对象拷贝
{
}

A fun2(const A x)     // 存在对象拷贝
{
return x;
}

int main()
{
A a;
fun1(a);
a = fun2(a);

return 0;
}

4. 用const修饰函数的返回值

#include<iostream>
using namespace std;

const int fun(int x) // 这种情况下，const没有任何作用
{
x = x + 1;
return x;
}

int main()
{
int a = 1;
int b = fun(a);

return 0;
}

#include<iostream>
using namespace std;

const char *fun(char str[]) // 返回指针的类型是 const char * 类型的
{
return str;
}

int main()
{
char s[] = "hello";
// char *p = fun(s); 错误
const char *p = fun(s);
cout << p << endl;

return 0;
}

#include<iostream>
using namespace std;

class A{};

A fun1()
{
A x;
return x;
}

A *fun2(A *q)
{
return q;
}

A &fun3(A &x)
{
return x;
}

int fun4()
{
int i = 1;
return i;
}

int main()
{
A a, b, *p;
fun1() = a;         // 语法上正确，但风格不好

// fun2(p) = NULL;  // 语法上错误

fun3(b) = a;        // 语法上正确，但风格不好

int i;
// fun4() = i;      // 语法上错误

return 0;
}

    为了防止上述的fun1() = a;和fun3(b) = a;这样的语句，就采用const修饰返回值（其实，我有点纳闷：哪个傻瓜程序员会这么调用函数？），改正后的程序为：

#include<iostream>
using namespace std;

class A{};

const A fun1()
{
A x;
return x;
}

const A *fun2(A *q) // 可以不需要const, 但加上后，肯定不错
{
return q;
}

const A &fun3(A &x)
{
return x;
}

const int fun4()   // 可以不需要const，但加上后，肯定不错
{
int i = 1;
return i;
}

int main()
{
A a, b, *p;
// fun1() = a;         // 语法上错误

// fun2(p) = NULL;     // 语法上错误

// fun3(b) = a;        // 语法上错误

int i;
// fun4() = i;         // 语法上错误

return 0;
}

     现在，一切都明白了吧！在上面的程序中，我们注意到有返回引用的情况，下面来看看引用是如何返回的：

#include <iostream>
using namespace std;

int &fun(int &x)
{
return x;
}

int main()
{
int a = 1;
int &b = fun(a);   // 注意初始化引用的方法
cout << a << endl; // 1
cout << b << endl; // 1

b = 2;
cout << a << endl; // 2
cout << b << endl; // 2

b = 3;
cout << a << endl; // 3
cout << b << endl; // 3

return 0;
}

     一切都明白了。最后欣赏几个程序，补补C++的基本知识：

#include <iostream>
using namespace std;

class A
{
public:
// 构造函数
A()
{
cout << "constructor" << endl;
}

// 析构函数
~A()
{
cout << "destructor" << endl;
}

// 拷贝构造函数
A(A &)
{
cout << "copy constructor" << endl;
}

};

void fun(A a)
{
}

int main()
{
A a;

return 0;
}

    结果为：

constructor

destructor

#include <iostream>
using namespace std;

class A
{
public:
// 构造函数
A()
{
cout << "constructor" << endl;
}

// 析构函数
~A()
{
cout << "destructor" << endl;
}

// 拷贝构造函数
A(A &)
{
cout << "copy constructor" << endl;
}

};

void fun(A a)
{
}

int main()
{
A a;
fun(a);
return 0;
}

    结果为：

constructor

copy constructor

destructor

destructor

#include <iostream>
using namespace std;

class A
{
public:
// 构造函数
A()
{
cout << "constructor" << endl;
}

// 析构函数
~A()
{
cout << "destructor" << endl;
}

// 拷贝构造函数
A(A &)
{
cout << "copy constructor" << endl;
}

};

void fun(A &a)
{
}

int main()
{
A a;
fun(a);
return 0;
}

    结果为：

constructor

destructor

#include <iostream>
using namespace std;

class A
{
public:
// 构造函数
A()
{
cout << "constructor" << endl;
}

// 析构函数
~A()
{
cout << "destructor" << endl;
}

// 拷贝构造函数
A(A &)
{
cout << "copy constructor" << endl;
}

};

A fun(A &a)
{
return a;
}

int main()
{
A a;
fun(a);
return 0;
}

    结果为：

constructor

copy constructor

destructor

destructor

#include <iostream>
using namespace std;

class A
{
public:
// 构造函数
A()
{
cout << "constructor" << endl;
}

// 析构函数
~A()
{
cout << "destructor" << endl;
}

// 拷贝构造函数
A(A &)
{
cout << "copy constructor" << endl;
}

};

A &fun(A &a)
{
return a;
}

int main()
{
A a;
fun(a);
return 0;
}

    结果为：

constructor

destructor

    由此可见，对于ADT数据类型而言，用引用做函数参数或返回值，都能提高效率。