一,类的最基本的函数

一个类至少有默认构造函数, 拷贝构造函数,拷贝构造运算符,和析构函数四个最基本的函数,在下面的例子中将对这些函数进行讲解。

代码如下:

#include<iostream>
using namespace std;
class SuperOne
{
public:
         SuperOne();//默认构造函数
         SuperOne(intpubSuperOne,int proSuperOne,int priSuperOne);//含参数的构造函数,
         SuperOne(SuperOne & source);//拷贝构造函数
         SuperOne&operator=(SuperOne & source);//拷贝赋值运算符
         ~SuperOne();//析构函数
         int getPubSuperOne();
         int getProSuperOne();
         int getPriSuperOne();
         void setPubSuperOne(int pubSuperOne);
         void setProSuperOne(int proSuperOne);
         void setPriSuperOne(int priSuperOne);
         void PublicSuperOne();
         void Print();
protected:
       void    ProtectedSuperOne();
private:
         void   PrivateSuperOne();
         //Members
public:
         int    pubSuperOne;
protected:
         int    proSuperOne;
private:
         int     priSuperOne;
};
 
SuperOne::SuperOne()
{
         this->pubSuperOne= 0;
         this->proSuperOne= 0;
         this->priSuperOne= 0;
         cout<<"Defaultstructure function is called!"<<endl;
}
 
SuperOne::SuperOne(intpubSuperOne,int proSuperOne,int priSuperOne)
{
         this->pubSuperOne= pubSuperOne;
         this->proSuperOne= proSuperOne;
         this->priSuperOne= priSuperOne;
         cout<<"Structurefunction with three parameters is called!"<<endl;
}
 
SuperOne::SuperOne(SuperOne &source)
{
         this->pubSuperOne= source.pubSuperOne;
         this->proSuperOne= source.getProSuperOne();
         this->priSuperOne= source.getPriSuperOne();
         cout<<"Copystructure function is called!"<<endl;
}
 
SuperOne& SuperOne::operator=(SuperOne & source)
{
         this->pubSuperOne= source.pubSuperOne;
         this->proSuperOne= source.getProSuperOne();
         this->priSuperOne= source.getPriSuperOne();
         cout<<"Copystructure operator is called!"<<endl;
        
         return* this;
}
 
SuperOne::~SuperOne()
{
         cout<<"UnStructurefunction is called!"<<endl;
}
 
void SuperOne::Print()
{
         cout<<"SuperOnedata:\t";
         cout<<this->pubSuperOne<<""<<this->proSuperOne<<""<<this->priSuperOne<<endl;
}
int SuperOne::getPubSuperOne()
{
         returnthis->pubSuperOne;
}
 
void SuperOne::setPubSuperOne(intpubSuperOne)
{
         this->pubSuperOne= pubSuperOne;
}
 
int SuperOne::getProSuperOne()
{
         returnthis->proSuperOne;
}
 
void SuperOne::setProSuperOne(intproSuperOne)
{
         this->proSuperOne= proSuperOne;
}
 
int SuperOne::getPriSuperOne()
{
         returnthis->priSuperOne;
}
 
void SuperOne::setPriSuperOne(intpriSuperOne)
{
   this->priSuperOne = priSuperOne;
}
 
void SuperOne::PublicSuperOne()
{
         cout<<"PublicSuperOne is called!"<<endl;
}
 
void SuperOne::ProtectedSuperOne()
{
         cout<<"ProtectedSuperOne is called!"<<endl;
}
 
void SuperOne::PrivateSuperOne()
{
         cout<<"PrivateSuperOne is called!"<<endl;
}
 
 
 
int main()
{
	cout<<"1:\t";
	SuperOne s0;
 
 
	cout<<"2:\t";
	SuperOne s1(1,1,1);
 
 
	cout<<"3:\t";
	SuperOne s2(s0);
 
 
	cout<<"4:\t";
	SuperOne s3 = s1;
  
	cout<<"5:\t";
	s0.Print();
 
 
	cout<<"6:\t";
	s1.Print();
 
 
    cout<<"7:\t";
	s2.Print();
 
 
	cout<<"8:\t";
	s3.Print();
 
 
	cout<<"9:\t";
	s1=s0;
 
 
	cout<<"10:\t";
	s1.Print();
 
 
	cout<<"11:\t";
    SuperOne * s4 = new SuperOne();
 
	cout<<"12:\t";
	delete s4;
 
	cout<<"13:\t";
	SuperOne * s5 = new SuperOne(1,2,3);
 
	cout<<"14:\t";
	delete s5;
 
	return 1;
}

代码讲解:

1, 默认构造函数

声明:类名 (); 比如本例中的 SuperOne(); 注意:没有返回值类型哦

用法: (1), 在声明一个对象时被调用,比如 1,SuperOne s0; 这个时候默认的构造函 数被调用,输出窗口的第 1 行就是。

(2), 在使用 new 运算符构造对象时使用,

比如 20,SuperOne *s4 = new SuperOne();

输出窗口中第 11 行就是。

2, 带参数的构造函数

声明:类名 (参数列表); 本例中的 SuperOne(intpubSuperOne,int proSuperOne,int priSuperOne);// 构造函数就是,

用法:(1), 用来对类中的数进行初始化,比如 4 ,SuperOne s1(1,1,1)

在初始化的时候使用 this-> 指针,比如更好的初始化方法是用下面的风格;

SuperOne::SuperOne(intpub,int pro,int pri)

    :pubSuperOne(pub),proSuperOne(pro),priSuperOne(pri)

{

                  cout<<"Structure functionwith three parameters is called!"<<endl;

}

窗口输出的第 2 行就是。

(2). 用 new 运算符构造对象时使用

比如 24,SuperOne *s5 = new SuperOne(1,2,3);

输出窗口中的第 13 行就是。

3, 拷贝构造函数

声明:类名 (类名 & 变量); 本例中的 SuperOne(SuperOne& source);// 拷贝构造函数用法:用一个类的变量来初始化另一个类的变量,比如 6,SuperOne s2(s0);

  输出窗口中的第 3 行就是。

4,拷贝构造运算符;

声明:类名 & operator=(类名 & 变量);

本例中 SuperOne&operator=(SuperOne & source);// 拷贝赋值运算符

用法:用一个对象初始化另一个对象,或者用一个对象对象对另一个对象赋值。

(1),代码 8 ,SuperOnes3 = s1; 中是在对象声明是初始化。

  对应的输出为第 4 行

(2), 代码 17,s1=s0; 是对一个已经存在的对象赋值,

  对应的输出为第 9 行。

注意:如果在对象的声明的时候进行初始化,则调用的是拷贝构造函数。

      如果对象已经初始化过了,则调用拷贝构造函数。

5,析构函数

声明:~ 类名 (); 没有返回值哦,并且不能重载,只有一个。

用法:(1), 在对象声明周期结束后被自动调用。

        输出的最后四行就是。

     (2), 调用 delete 运算符删除对象指针时被调用。


        代码 22 delete s4, 26 delete s5; 都是这种用法

        输出的 12, 14 就是。

小结:对于 C++ 中的类来说,一个类的函数至少有四个即,默认的不带参数的构造函数,默认拷贝构造函数,默认拷贝构造运算符,默认析构函数,如果你没有写,编译器会自动生成,如果你写了,编译器就不自动生成了。