类的使用（类和对象，构造函数和析构函数）

最近c艹在学类与对象

擅长划水的我并没有听课，害，所以东西有点云里雾里，

所以写下这一篇博客来理解一下。

 

类的使用就像是封装一类的东西，定义为一个类

定义的地方和结构体其实还是有点相似的。

这东西在算法里面用的感觉不多，

以前也没接触过，

现在发现实际运用还是很有意思的。

---

 

首先是定义

class clock{
     public:
         void showtime();
        void settime(int a,int b,int c);  
     private:
         int hour,minute,second;
     protected:
        
};    
/*
class 类的名称{
     public://外部接口
        公有成员  
     private：
         私有成员
    protected：
          保护型成员
};
*/

 

---

 public是外部接口，公有成员，就是所有部分都可以去调用的，就是整个程序的clock形式的class类都可以调用；

而private是私有成员，只能允许内部的成员进行使用和调动，外部无法调用。

简单来说就是，假如定义了clock c；c.公有成员()是合法的，而c.私有成员()是无效的。

---

 

成员函数的实现

void clock::showtime(){
      cout<<hour<<":"<<minute<<":"<<second<<endl;  
}
/*
返回值 类名::函数成员名（参数表）
{
函数体
}
*/

 

 内联成员函数

有两种声明方式

• 隐式声明方式

• class clock{
       public:
           void showtime();
  
          void settime(int a,int b,int c){
                hour=a;
                minute=b;
                second=c;
          } 
  
       private:
           int hour,minute,second;
       protected:
          
  };            

   settime函数就是隐式声明

• 显式声明方式

• class clock{
       public:
           void showtime();
  
          void settime(int a,int b,int c);
  
       private:
           int hour,minute,second;
       protected:
          
  };     
  
  inline void clock::settime(int a,int b,int c){//显式
        hour=a,minute=b,second=c;    
  }

---

 

 构造函数

   　　构造函数是在类创建之初自己生成的，默认的

　　　　　还是以clock为例子来说明一下

class clock{
    public:
      clock(int a,int b,int c);//构造函数
      clock(){//构造函数
           hour=0;minute=0;second=0;
      }
      void showtime();
      void settime(int a,int b,int c);
    private:
      int hour,minute,second;
};

clock::clock(int a,int b,int c){
     hour=a,minute=b,second=c;
}

//其他成员函数略

int main(){
     clock c1(1,1,1);//调用了  有参数  的构造函数
     clock c2;          //调用了  无参数  的构造函数
     //其他略
}

 

ps：如果类里面没有无参数构造函数的那一句话，则 clock c2是会报错的；

 

复制构造函数/拷贝构造函数

 

class 类名{
public：
    类名（形参表）；      //构造函数
    类名（类名 &对象名）；//拷贝构造函数
    ......
}；

类名::类名（类名 &对象名）{//拷贝构造函数的实现
   函数体
}

 

拷贝构造函数有3种调用方式：

（暂时未梳理，先空出来）

 

析构函数

析构函数和构造函数都是直接默认存在的

析构函数的进行清理的，完成对象被删除前的清理工作；

class clock{
      .....
      ~clock();//析构函数
};

 

• 析构函数不接受任何参数
• 被删除前是会自动清理的，~clock析构函数可以用在需要提前清理的时候   （感觉和return  break类似）

---

 

以一个体型来尽量用到所用的以上知识

例4-3
一个圆形游泳池周围需要建圆形过道
在圆形过道外围围上栅栏
栅栏价格为35元/米
过道的建造价格为20元/平方米
过道的宽度为3米
游泳池半径由键盘输入

 

/*
例4-3
一个圆形游泳池周围需要建圆形过道
在圆形过道外围围上栅栏
栅栏价格为35元/米
过道的建造价格为20元/平方米
过道的宽度为3米
游泳池半径由键盘输入 
*/ 
#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<queue>
#include<utility>
#include<stack>
#include<cstdlib>
#define ll long long
#define inf 0x3fffffff
#define pi 3.1415926535
#define concrete_price 20
#define fence_price 35
#define length 3
using namespace std;

class price{                                //类的定义 用来解决费用 
    private:                                //私有数据成员（仅供内部调用 
        double cir,area;
    public:                                    //外部接口  or  公有成员 
        price(double c,double a){            //内联构造函数隐式声明 
            cir=c,area=a;
        }
        double buy_concrete();
        double buy_fence(){                    //内联成员函数隐式声明 
            return area*concrete_price;
        }
};

inline double price::buy_concrete(){        //内联成员函数显式声明 
    return cir*fence_price;
}

class circle{                                //类的定义 用来解决面积和周长 
    private:
        double radius;
        double real_area(){                    //私有成员函数 计算实际面积 
            double r=radius;
            double r=radius+3;
            double s1=pi*r*r;
            double s2=pi*r*r;
            return s2-s1;
        }
    public:
        circle(double r);                    //构造函数 
        circle(){                            //构造函数   初始化私有成员的值 
            radius=0;
        }
        circle(circle &c);                    //拷贝构造函数 or 复制构造函数 
        double make_circumference();
        double make_area();
        ~circle(){};                        //析构函数  （后面跟着的 {} 不能少） 用于删除数据，做清理工作 
};

circle::circle(double r){                    //构造函数的实现 
    radius=r;
}

circle::circle(circle &c){                    //拷贝构造函数的实现 
    radius=c.radius;
}

double circle::make_circumference(){        //成员函数的实现 
    return 2*pi*(radius+3);
}

double circle::make_area(){                    //成员函数的实现 
    return real_area();
}

int main(){
    int r;
    cin>>r;
    circle circle(r);                        //构造函数初始化半径的值 
    circle c1=circle;                        //拷贝构造函数的调用来初始化值 
    circle c2;                                //构造函数直接初始化为0 
    
    double c_a=c1.make_area();
    double c_c=c1.make_circumference();
    cout<<c_c*fence_price<<endl<<c_a*concrete_price;
    
    
    price ans(c_c,c_a);                        //初始化构造函数的值 
    cout<<"栅栏价格："<<ans.buy_fence()<<endl;
    cout<<"过道价格："<<ans.buy_concrete()<<endl;
    return 0;
}

 

 

接下来需要学习类的组合

先预习吧，害