C++学习笔记1

一，类的最基本的函数

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

代码如下：

#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++ 中的类来说，一个类的函数至少有四个即，默认的不带参数的构造函数，默认拷贝构造函数，默认拷贝构造运算符，默认析构函数，如果你没有写，编译器会自动生成，如果你写了，编译器就不自动生成了。