Day7-C++基础之类的权限访问和构造方法

类的访问权限

# include<iostream>
# include<string>
using namespace std;
​
//访问权限
//public:谁来都可以  protected:类外只有儿子可以访问  private:类外都不可以
class Person{
public:
    string name;
protected:
    string car;
private:
    int pwd;
public:
    void func(){
        name="张三";
        car="奔驰";
        pwd=123456;
    }
};
​
//成员属性设置为私有：1.可以自己控制读写权限  2.对于写可以检测数据有效性
class Man{
private:
    string name;//可读可写
    int age=18;//只读  也可以写(0-150)
    string idol;//只写
public://用共有的方法对私有的属性进行操作
    void setName(string mName){
        name=mName;
    }
    string getName(){
        return name;
    }
    int getAge(){
        return age;
    }
    void setIdol(string iName){
        idol=iName;
    }
    void setAge(int mAge){
        if(mAge<0||mAge>150){
            cout<<"年龄输入有误"<<endl;
            return;
        }
        age=mAge;
    }
};
​
int main(){
    Person p1;
    p1.name="李四";
    //p1.car="奔驰" //保护权限的内容在类外访问不到,私有同
    p1.func();
​
    //struct和class区别
    //两者非常相似, 唯一区别在于struct默认访问权限为公共, 而class默认为私有
​
    Man m;
    m.setName("mamba");
    cout<<m.getName()<<endl;
    cout<<m.getAge()<<endl;
    m.setIdol("Kobe");
​
    return 0;
}

案例

# include<iostream>
# include<math.h>
using namespace std;
​
//点和圆的关系案例
class Point{
public:
    void setX(int x_val){
        x=x_val;
    }
    int getX(){
        return x;
    }
    void setY(int y_val){
        y=y_val;
    }
    int getY(){
        return y;
    }
private:
    int x;
    int y;
};
​
class Circle{
public:
    void setR(int r_val){
        r=r_val;
    }
    int getR(){
        return r;
    }
    void setCenter(Point p){
        center=p;
    }
    Point getCenter(){
        return center;
    }
private:
    int r;
    //可以让另一个类作为本类成员
    Point center;
};
​
//判断点和圆关系
void isInCircle(Circle &c,Point &p){
    //计算两点之间距离的平方
    int d=pow((c.getCenter().getX()-p.getX())*(c.getCenter().getY()-p.getY()),2);
    //计算半径平方
    int rD=c.getR()*c.getR();
    //判断
    if(d==rD){
        cout<<"点在圆上"<<endl;
    }else if(d>rD){
        cout<<"点在圆外"<<endl;
    }else{
        cout<<"点在圆内"<<endl;
    }
}
​
int main(){
    Circle c;
    c.setR(10);
    Point p;
    p.setX(10);
    p.setY(0);
    c.setCenter(p);
​
    isInCircle(c,p);
​
    return 0;
}

#include<iostream>
#include<string>
using namespace std;
​
class Cube{
public:
    void setLength(int l){
        length=l;
    }
    int getLenth(){
        return length;
    }
    void setWidth(int w){
        width=w;
    }
    int getWidth(){
        return width;
    }
    void setHeight(int h){
        height=h;
    }
    int getHeight(){
        return height;
    }
    //获取面积
    int calcS(){
        return 2*length*width+2*width*height+2*length*height;
    }
    //获取体积
    int calcV(){
        return length*width*height;
    }
    //利用成员函数判断是否相等
    bool isSameByClass(Cube &c){
        if(length==c.getLenth()&&width==c.getWidth()&&height==c.getHeight()){
            return true;
        }else{
            return false;
        }
    }
​
private:
    int length;//长
    int width;//宽
    int height;//高
};
​
bool isEqual(Cube &c1,Cube &c2){
    if(c1.getHeight()==c2.getHeight()&&c1.getWidth()==c2.getWidth()&&c1.getLenth()==c2.getLenth()){
        return true;
    }else{
        return false;
    }
}
​
int main(){
    Cube c1;
    c1.setHeight(10);
    c1.setLength(10);
    c1.setWidth(10);
​
    cout<<"S="<<c1.calcS()<<endl;
    cout<<"V="<<c1.calcV()<<endl;
​
    Cube c2;
    c2.setLength(10);
    c2.setWidth(20);
    c2.setHeight(10);
​
    bool flag= isEqual(c1,c2);
    bool flag2=c1.isSameByClass(c2);
    cout<<flag<<flag2<<endl;
​
    return 0;
}

构造函数

#include<iostream>
using namespace std;
​
class Person{
public:
    //1.构造函数 进行初始化操作
    //没有返回值，不需要写void，创建对象的时候会自动调用,可以带参数重载
    Person(){
        cout<<"构造函数启动"<<endl;
    }
    Person(int a){
        age=a;
        cout<<"有参构造启动"<<endl;
    }
    //拷贝构造函数
    Person(const Person &p){
        age=p.age;
        cout<<"拷贝构造函数启动"<<endl;
    }
    //析构函数,前加~，无参数不可重载,对象销毁前会调用
    ~Person(){
        cout<<"析构函数启动"<<endl;
    }
private:
    int age;
};
​
//调用
void test(){
    //1.括号法
    Person p1;//默认构造方法
    Person p2(10);//有参构造
    Person p3(p2);//拷贝函数调用
​
    //2.显示法
    Person p4=Person(10);
    Person p5=Person(p4);
    Person(10);//匿名对象创建完后立即被回收
​
    //3.隐式转换法
    Person p6=10;//相当于Person p6=Person(10)
}
​
int main(){
    Person p;
​
    return 0;
}

深拷贝和浅拷贝

#include<iostream>
using namespace std;
​
class Person{
public:
    Person(){
        cout<<"无参构造"<<endl;
    }
    Person(int age,int height){
        m_age=age;
        m_height=new int(height);//创建到堆区
        cout<<"有参构造"<<endl;
    }
    //自己实现拷贝构造函数来解决浅拷贝带来的问题
    Person(const Person &p){
        cout<<"拷贝构造函数的调用"<<endl;
        m_age=p.m_age;
        //m_height=p.m_height; //编译器默认实现
        m_height=new int(*p.m_height);
    }
    ~Person(){
        //析构代码区将堆区开辟的数据做释放
        //浅拷贝带来的问题：堆区内存重复释放->要利用深拷贝来解决
        if(m_height!=NULL){
            delete m_height;
            m_height=NULL;
        }
        cout<<"Person解析构造"<<endl;
    }
    int m_age;
    int* m_height;
};
​
void test(){
    Person p1(18,180);
    cout<<"p1年龄为"<<p1.m_age<<"身高为"<<*p1.m_height<<endl;
    Person p2(p1);
    cout<<"p2年龄为"<<p2.m_age<<"身高为"<<*p2.m_height<<endl;
}
​
int main(){
    test();
    //总结：浅拷贝是简单的赋值操作。深拷贝在堆区重新申请空间，进行拷贝操作
​
    return 0;
}