类的构造、使用与析构

 1.类的定义与使用

class m_class{
	private:
	  int a,b,c;//定义成员变量时不能赋初值 
	  m_class *p;//指针类型为正在定义的类，可行 
	protected:
	public:
	int d; 
	void fun_1(){
		a=1;
	}
	void fun_2(int,int);//成员函数既可以在类中定义，也可以类内声明类外定义 
};//类定义结束后，大括号后的分号不能少 
void m_class::fun_2(int a,int b){//‘::’是类的作用域分辨符 
	this->a=a;//this是一个特殊的指针，总是指向当前对象 
	this->b=b;
} 
int main(){
	m_class o_a;//建立对象 
	//创建对象时，编译器只为其成员变量分配空间；成员函数则不分配，各对象共享 
	o_a.d=1;//对象名.成员变量 
	o_a.fun_2(1,2);//对象名.成员函数 
	
	m_class *o_b=&o_a; 
	o_b->d=1;//对象指针采用‘->’运算符来访问成员变量和成员函数
	
	m_class &o_c=o_a;
	o_c.d=1; //引用类型对象用‘.’运算符访问内部成员

	return 0;
} 

C++还支持类的嵌套定义。

//类的嵌套定义 
#include 
using namespace std;
class A{
	public:
    int a;
	class B{
		public:
		int b;
		B(int x):b(x){}
		void show();
	};
	B obj_b;
	A():a(3),obj_b(4){}
	void show(){
		cout<

类中除了能定义成员，还可以定义类型。

class A{
public:
    typedef int cc_int;
    };
int main(int argc, char *argv[])
{
    A::cc_int x=1;
    cout<<x; //1
	return 0;
}

 2.类的构造函数、复制构造函数 与析构

//类的构造与析构 
#include 
using namespace std;
class m_class{
	public:
	int a; 
	m_class(int);//构造函数，constructor，专门用于对象初始化的函数
	m_class();//重载构造函数 
/*
如果没有定义构造函数，编译系统会生成一个默认的隐含的构造函数,函数体为空。
如果用户定义了构造函数，则不再生成默认的。 构造函数可以重载。 
构造函数只能在创建对象时由编译器自动调用。 
*/ 
    m_class(m_class &ob); //拷贝构造函数,形参是本类对象的引用类型
/*如果用户没有定义拷贝构造函数，系统会自动生成，用于对象之间的位拷贝。
 用户可根据实际问题需要进行自定义。用已有的对象初始化本类的一个新对象时，
 编译系统自动调用。 
*/	 
    m_class::~m_class();//析构函数 
/*
析构函数可以是虚函数，但不能被重载。
如果用户没定义，编译器生成默认的函数体为空的析构函数。
清理语句须由用户自己添加。 
*/    
};
int main( )
{
	m_class o_a;//如果只定义带参数的构造函数，此语句会因找不到相应构造函数而报错 
	m_class o_b(4); 
	m_class o_c=o_b;//调用复制构造函数
	m_class o_d(o_b);//调用复制构造函数,等价于上一行 
	m_class o_e;
	o_2=o_b;//此时不调用复制构造函数！ 
	return 0;
}
m_class::m_class(int a){
	this->a=a;
}
m_class::m_class(){
	this->a=3;
}
m_class::m_class(m_class &ob){
	static int t=0;
	cout<<++t<<"次调用复制构造函数：\n";
  a=ob.a; 
} 
m_class::~m_class(){
/*
先建立全局对象，再建立局部对象，同普通变量建立顺序相同 。
局部对象在栈中建立，故其对象的消失顺序与建立顺序相反。 
全局对象消失顺序与建立顺序相同。 
*/
}
/*用已有的对象初始化本类的一个新对象时，
 编译系统自动调用复制构造函数。具体分为以下三种情况
 1.用已有的对象初始化本类的一个新对象。如 	
    m_class o_c=o_b;//调用复制构造函数
	m_class o_d(o_b);//调用复制构造函数,等价于上一行 
 2.函数的形参是类的对象 
 3.函数的返回值是类的对象 
 */ 

 

类的有冲突构造函数

//类的有冲突构造函数 
#include 
using namespace std;
class A{
	public:
    int a;
    A(){a=1;}
	A(int x=2):a(x){} 
	
};
int main(int argc, char *argv[])
{
	A ob;       
	A*p=new A;
	A*pp=new A();
	cout<

编译报错如下：

 

 问：构造函数不能是虚函数,编译器不允许，为什么？

答：首先，编译规则不允许。虚函数是为了实现动态绑定，根据具体的对象选择合适的函数。而在调用构造函数以前，对象还没建立，谈何绑定？

问：类与结构体的区别是什么?

答：类的默认权限是private；结构体是public。仅此一点区别。结构体中构造函数之类的同class完全一样。