c++类详解：访问权限，构造函数，拷贝构造函数，析构函数

类的定义

类可以看做是一种数据类型，类这种数据类型是一个包含成员变量和成员函数的集合。类的成员变量和普通变量一样，也有数据类型和名称，占用固定长度的内存。但是，在定义类的时候不能对成员变量赋值，因为类只是一种数据类型或者说是一种模板，本身不占用内存空间，而变量的值则需要内存来存储。
类的成员函数也和普通函数一样，都有返回值和参数列表，它与一般函数的区别是：成员函数是一个类的成员，出现在类体中，它的作用范围由类来决定；而普通函数是独立的，作用范围是全局的，或位于某个命名空间内。实例1：

#include <iostream>
using namespace std;

//类通常定义在函数外面
class Student{
public:
	//类包含的变量
	char *name;
	int age;
	float score;
	//类包含的函数
	void say()
	{
		cout << name << "的年龄是" << age << "，成绩是" << score << endl;
	}
};

int main(){
	//创建对象
	Student stu;
	stu.name = "小明";
	stu.age = 15;
	stu.score = 92.5f;
	stu.say();
	return 0;
}

实例1中在类体中定义了成员函数，也可以只在类体中声明函数，在类体中直接定义函数时，不需要在函数名前面加上类名，因为函数属于哪一个类是很明显的。但当成员函数定义在类外时，就必须在函数名前面加上类名予以限定。::被称为域解析符（也称作用域运算符或作用域限定符），用来连接类名和函数名，指明当前函数属于哪个类。
成员函数必须先在类体中作原型声明，然后在类外定义，也就是说类体的位置应在函数定义之前。

class Student{
public:
	//成员变量
	char *name;
	int age;
	float score;
	//成员函数
	void say();  //函数声明
};
//函数定义
void Student::say(){
	cout << name << "的年龄是" << age << "，成绩是" << score << endl;
}

虽然 C++ 支持将内联函数定义在类的外部，但建议将函数定义在类的内部，这样它会自动成为内联函数，何必费力不讨好地将它定义在类的外部呢，这样并没有任何优势。类的定义可以使用指针形式，并使用“->”初始化，实例2：

#include <iostream>
using namespace std;

class Student{
public:
	char *name;
	int age;
	float score;

	void say()
	{
		cout << name << "的年龄是" << age << "，成绩是" << score << endl;
	}
};

int main(){
	Student *pStu = new Student;
	pStu->name = "小明";
	pStu->age = 15;
	pStu->score = 92.5f;
	pStu->say();
	delete pStu;  //删除对象
	return 0;
}

实例2在堆上创建对象，需要使用new关键字，在栈上创建出来的对象都有一个名字，比如 stu，使用指针指向它不是必须的。但是通过 new 创建出来的对象就不一样了，它在堆上分配内存，没有名字，只能得到一个指向它的指针，所以必须使用一个指针变量来接收这个指针，否则以后再也无法找到这个对象了，更没有办法使用它。也就是说，使用 new 在堆上创建出来的对象是匿名的，没法直接使用，必须要用一个指针指向它，再借助指针来访问它的成员变量或成员函数。

类成员的访问权限：

C++通过 public、protected、private 三个关键字来控制成员变量和成员函数的访问权限，它们分别表示公有的、受保护的、私有的，被称为成员访问限定符。所谓访问权限，就是你能不能使用该类中的成员。C++ 中的 public、private、protected 只能修饰类的成员，不能修饰类，C++中的类没有共有私有之分。
在类的内部（定义类的代码内部），无论成员被声明为 public、protected 还是 private，都是可以互相访问的，没有访问权限的限制。在类的外部（定义类的代码之外），只能通过对象访问成员，并且通过对象只能访问 public 属性的成员，不能访问 private、protected 属性的成员。见实例3：

#include <iostream>
using namespace std;
//类的声明
class Student{
private:  //私有的
	char *m_name;
	int m_age;
	float m_score;
public:  //共有的
	void setname(char *name)
	{
		m_name = name;
	}
	void setage(int age)
	{
		m_age = age;
	}
	void setscore(float score)
	{
		m_score = score;
	}
	void show()
	{
		cout << m_name << "的年龄是" << m_age << "，成绩是" << m_score << endl;
	}
};

int main(){
	//在栈上创建对象
	Student stu;
	stu.setname("小明");
	stu.setage(15);
	stu.setscore(92.5f);
	stu.show();
	//在堆上创建对象
	Student *pstu = new Student;
	pstu->setname("小红");
	pstu->setage(16);
	pstu->setscore(96);
	pstu->show();
	return 0;
}

成员变量大都以m_开头，这是约定成俗的写法，不是语法规定的内容。以m_开头既可以一眼看出这是成员变量，又可以和成员函数中的形参名字区分开。实例3中的m_name、m_age、m_score 是私有成员变量，不能在类外部通过对象访问。如下定义就是一种错误的表示：

Student stu;
stu.m_name = "小明";
stu.m_age = 15;
stu.m_score = 92.5f;
stu.show();

这种将成员变量声明为 private、将部分成员函数声明为 public 的做法体现了 类的封装性。所谓封装，是指尽量隐藏类的内部实现，只向用户提供有用的成员函数。private 关键字的作用在于更好地隐藏类的内部实现，该向外暴露的接口（能通过对象访问的成员）都声明为 public，不希望外部知道、或者只在类内部使用的、或者对外部没有影响的成员，都建议声明为 private。
根据C++软件设计规范，实际项目开发中的成员变量以及只在类内部使用的成员函数（只被成员函数调用的成员函数）都建议声明为 private，而只将允许通过对象调用的成员函数声明为 public。另外还有一个关键字 protected，声明为 protected 的成员在类外也不能通过对象访问，但是在它的派生类内部可以访问。
声明为 private 的成员和声明为 public 的成员的次序可以是任意的，既可以先出现 private 部分，也可以先出现 public 部分。如果既不写 private 也不写 public， 默认为 private。在一个类体中，private 和 public 可以分别出现多次。但是为了使程序清晰，应该养成使每一种成员访问限定符在类定义体中只出现一次的习惯。

类的构造函数：

在C++中，有一种特殊的成员函数，它的名字和类名相同，没有返回值，不需要用户显式调用（用户也不能调用），而是在创建对象时自动执行。这种特殊的成员函数就是构造函数。实例3中，通过成员函数 setname()、setage()、setscore() 分别为成员变量 name、age、score 赋值，这样做虽然有效，但显得有点麻烦。有了构造函数，我们就可以简化这项工作，在创建对象的同时为成员变量赋值。见实例4：

#include <iostream>
using namespace std;
class Student
{
private:
	char *m_name;
	int m_age;
	float m_score;
public:
	//声明构造函数
	Student(char *name, int age, float score);
	//声明普通成员函数
	void show();
};
//定义构造函数
Student::Student(char *name, int age, float score)
{
	m_name = name;
	m_age = age;
	m_score = score;
}
//定义普通成员函数
void Student::show()
{
	cout << m_name << "的年龄是" << m_age << "，成绩是" << m_score << endl;
}
int main()
{
	//创建对象时向构造函数传参
	Student stu("小明", 15, 92.5f);
	stu.show();
	//创建对象时向构造函数传参
	Student *pstu = new Student("小红", 16, 96);
	pstu->show();
	return 0;
}

实例4，在 Student 类中定义了一个构造函数Student(char *, int, float)，它的作用是给三个 private 属性的成员变量赋值。要想调用该构造函数，就得在创建对象的同时传递实参，并且实参由( )包围，和普通的函数调用非常类似。在栈上创建对象时，实参位于对象名后面，例如Student stu("小明", 15, 92.5f)；在堆上创建对象时，实参位于类名后面，例如new Student("小红", 16, 96)。
构造函数必须是 public 属性的，否则创建对象时无法调用。设置为 private、protected 属性不会报错，但没有意义。构造函数没有返回值，因为没有变量来接收返回值，即使有也毫无用处，这意味着：（1）不管是声明还是定义，函数名前面都不能出现返回值类型，即使是 void 也不允许；（2）函数体中不能有 return 语句。
构造函数的调用是强制性的，一旦在类中定义了构造函数，那么创建对象时就一定要调用，不调用是错误的。如果有多个重载的构造函数，那么创建对象时提供的实参必须和其中的一个构造函数匹配；反过来说，创建对象时只有一个构造函数会被调用。
实例4中的代码，如果写作Student stu或者new Student就是错误的，因为类中包含了构造函数，而创建对象时却没有调用。

如果用户没有定义构造函数，那么编译器会自动生成一个默认的构造函数，只是这个构造函数的函数体是空的，没有形参，也不执行任何操作。比如上面的 Student 类，默认生成的构造函数如下：Student(){}。
一个类必须有构造函数，要么用户自己定义，要么编译器自动生成。一旦用户自己定义了构造函数，不管有几个，也不管形参如何，编译器都不再自动生成。和普通成员函数一样，构造函数是允许重载的。一个类可以有多个重载的构造函数，创建对象时根据传递的实参来判断调用哪一个构造函数。

#include <iostream>
using namespace std;
class Student
{
private:
	char *m_name;
	int m_age;
	float m_score;
public:
	Student();
	Student(char *name, int age, float score);
	void setname(char *name);
	void setage(int age);
	void setscore(float score);
	void show();
};
Student::Student()
{
	m_name = NULL;
	m_age = 0;
	m_score = 0.0;
}
Student::Student(char *name, int age, float score)
{
	m_name = name;
	m_age = age;
	m_score = score;
}
void Student::setname(char *name)
{
	m_name = name;
}
void Student::setage(int age)
{
	m_age = age;
}
void Student::setscore(float score)
{
	m_score = score;
}
void Student::show()
{
	if (m_name == NULL || m_age <= 0)
	{
		cout << "成员变量还未初始化" << endl;
	}
	else
	{
		cout << m_name << "的年龄是" << m_age << "，成绩是" << m_score << endl;
	}
}
int main(){
	//调用构造函数 Student(char *, int, float)
	Student stu("小明", 15, 92.5f);
	stu.show();
	//调用构造函数 Student()
	Student *pstu = new Student();
	pstu->show();
	pstu->setname("小红");
	pstu->setage(16);
	pstu->setscore(96);
	pstu->show();
	return 0;
}

类的拷贝构造函数：

拷贝构造函数是一种特殊的构造函数，函数的名称必须和类名称一致，它唯一的一个参数是本类型的一个引用变量，该参数是const类型，不可变的。例如：类X的拷贝构造函数的形式为X(X& x)。

#include <iostream>  
using namespace std;

class CExample {
private:
	int a;
public:
	//构造函数  
	CExample(int b)
	{
		a = b;
	}
	//拷贝构造函数  
	CExample(const CExample& C)
	{
		a = C.a;
	}
	//一般函数  
	void Show()
	{
		cout << "a的值为："<<a<< endl;
	}
};

int main()
{
	CExample A(10);
	CExample B = A; // CExample B(A); 也是一样的  
	B.Show();
	return 0;
}

上面的例子中，CExample(const CExample& C)　就是自定义的拷贝构造函数。拷贝分为浅拷贝和深拷贝两种，浅拷贝，指的是在对象复制时，只对对象中的数据成员进行简单的赋值，默认拷贝构造函数执行的也是浅拷贝。大多情况下“浅拷贝”已经能很好地工作了，但是一旦对象存在了动态成员，那么浅拷贝就会出问题了。在某些状况下，类内成员变量需要动态开辟堆内存，如果实行浅拷贝，即把对象里的值完全复制给另一个对象，如A=B。这时，如果B中有一个成员变量指针已经申请了内存，那A中的那个成员变量也指向同一块内存。这就出现了问题：当B把内存释放了（如：析构），这时A内的指针就是野指针了，出现运行错误。举个错误的例子：

class Rect  
{  
public:  
    Rect()      // 构造函数，p指向堆中分配的一空间  
    {  
        p = new int(100);  
    }  
    ~Rect()     // 析构函数，释放动态分配的空间  
    {  
        if(p != NULL)  
        {  
            delete p;  
        }  
    }  
private:  
    int width;  
    int height;  
    int *p;     // 一指针成员  
};  
  
int main()  
{  
    Rect rect1;  
    Rect rect2(rect1);   // 复制对象  
    return 0;  
}  

上面例子中，执行的是浅拷贝：

　　我们需要的不是两个p有相同的值，而是两个p指向的空间有相同的值，解决办法就是使用“深拷贝”。深拷贝是指：如果一个类拥有资源，当这个类的对象发生复制过程的时候，资源重新分配，这个过程就是深拷贝。正确的例子为：

class Rect  
{  
public:  
    Rect()      // 构造函数，p指向堆中分配的一空间  
    {  
        p = new int(100);  
    }  
    Rect(const Rect& r)  
    {  
        width = r.width;  
        height = r.height;  
        p = new int;    // 为新对象重新动态分配空间  
        *p = *(r.p);  
    }  
    ~Rect()     // 析构函数，释放动态分配的空间  
    {  
        if(p != NULL)  
        {  
            delete p;  
        }  
    }  
private:  
    int width;  
    int height;  
    int *p;     // 一指针成员  
};  

此时rect1的p和rect2的p各自指向一段内存空间，但它们指向的空间具有相同的内容，这就是所谓的“深拷贝”。

类的析构函数（Destructor）

析构函数(destructor) 与构造函数相反，当对象结束其生命周期时（例如对象所在的函数已调用完毕），系统自动执行析构函数。析构函数往往用来做“清理善后” 的工作（例如在建立对象时用new开辟了一片内存空间，应在退出前在析构函数中用delete释放）。触发条件：当对象被销毁时，会自动调用析构函数，释放资源。构造函数在对象实例化时自动调用，析构函数在对象销毁时自动调用。
析构函数（Destructor）也是一种特殊的成员函数，没有返回值，不需要程序员显式调用（程序员也没法显式调用），而是在销毁对象时自动执行。构造函数的名字和类名相同，而析构函数的名字是在类名前面加一个“~”符号。析构函数没有参数，不能被重载，因此一个类只能有一个析构函数。如果用户没有定义，编译器会自动生成一个默认的析构函数。

#include <string.h>
#include <iostream>

using namespace std;

class stud
{
private://私有部分
	int num;
	char name[10];
	char sex;
public://公用部分
	stud(int n, const char nam[], char s)//构造函数
	{
		num = n;
		strcpy_s(name, nam);
		sex = s;
	}

	~stud() //析构函数
	{
		cout << "stud has been destructed!" << endl;//通过输出提示告诉我们析构函数确实被调用了
	}

	void display()//成员函数，输出对象的数据
	{
		cout << "num:" << num << endl;
		cout << "name:" << name << endl;
		cout << "sex:" << sex << endl;
	}
};
int main()
{
	stud stud1(10010, "Wangli", 'f'), stud2(10011, "Zhangfun", 'm');//建立两个对象
	stud1.display();//输出学生1的数据
	stud2.display();//输出学生2的数据
	return 0;
}//主函数结束的同时，对象stud1，stud2均应被“清理”，而清理就是通过调用了析构函数实现的。

参考：

http://www.cnblogs.com/mr-wid/archive/2013/02/18/2916309.html

http://c.biancheng.net/cpp/biancheng/view/185.html

http://blog.csdn.net/lwbeyond/article/details/6202256/

http://baike.baidu.com/link?url=R4MhPpouXzfx9uUINgnUeSnWDzQCEnzLFwy41wmqEjiasMGrxXXI2Ogk6rAcSnpSlCEw_MvLPhQ90NhAXvk23CM2sntilP9UufOMzZ-8bPgqP-XMqrTSDhhCS_92qGu0

http://blog.csdn.net/qq_34803572/article/details/55213551