c++ 语法 类和对象

类的特性: 封装,继承,多态

封装:

将属性和行为作为一个整体,表现生活中的事务

将属性和行为加以权限控制

语法

class 类名{访问权限:属性/行为}

//
//  main.cpp
//  cpplearn
//
//  Created by KING on 2024/2/1.
//

#include 
#include "mathutil.hpp"
#include 
using namespace std;
const double PI = 3.14;
class Circle {
    //访问权限
    
public:
    //属性
    double m_r;
    //行为
    double caculate() {
        return 2 * m_r * PI;
    }
    
};

class Person {
    // 属性 成员属性 成员变量
    //行为 成员函数 方法
private:
    string m_name;
    int  cardId;
    int  m_age;
public:
    
    string getName() {
        return m_name;
    }
    
    int getCardId() {
        return cardId;
    }
    
    void personInfo() {
        std::cout << m_name << "cardID =" << cardId << std::endl;
    }
    
    void setAge(int age) {
        if (age < 0 || age > 150) {
            std::cout << "age shu ru you  wu" << std::endl;
            return;
        }
        m_age = age;
        
    }
    void setName(string name) {
        m_name = name;
    }
    void setId(int id) {
        cardId = id;
    }
};


int main(int argc, const char * argv[]) {
    // insert code here...
    std::cout << "Hello, World!\n";
    // 实例化 通过类创建对象
    Circle c1;
    //属性赋值
    c1.m_r = 10;
    std::cout << "周长=" << c1.caculate() << std::endl;
    Person person;
    person.setName("李斯");
    person.setId(411323);
    person.personInfo();
    std::cout << person.getName() << "cardID =" << person.getCardId() << std::endl;

    return 0;
}

权限

public: 公共权限:类内类外都可访问

protected  保护权限:类内可以访问 类外不可访问 子类可访问父类保护属性

private 私有权限:类内可以访问 类外不可以访问 子类不能访问父类私有属性

struct 和 class的区别

struct默认权限为公共

class默认权限为私有

demo

#include 
#include "mathutil.hpp"
#include 
using namespace std;
class  Cube{
private:
    double m_width;
    double m_height;
    double m_length;
public:
    void setHeight(double height) {
        m_height = height;
    }
    void setWidth(double width) {
        m_width = width;
    }
    void setLength(double length){
        m_length = length;
    }
    double getWidth() {
        return m_width;
    }
    double getHeight() {
        return m_height;
    }
    double getLength() {
        return m_length;
    }
    
    double getarea() {
        return 2 * m_height * m_width + 2 * m_length * m_height + 2 * m_length * m_width;
    }
    double getcubeaV() {
        return m_width * m_height * m_length;
    }
    bool isSamplecube(Cube &c) {
        if (getWidth() == c.getWidth() && getHeight() == c.getHeight() && getLength() == c.getLength()) {
            return  true;
        }
        return false;
    }

};

bool isSampleCube(Cube &c1, Cube &c2) {
    if (c1.getWidth() == c2.getWidth() && c1.getHeight() == c2.getHeight() && c1.getLength() == c2.getLength()) {
        return  true;
    }
    return false;
}

int main(int argc, const char * argv[]) {
    // insert code here...
    std::cout << "Hello, World!\n";
    Cube cube;
    cube.setWidth(10.0);
    cube.setHeight(13.0);
    cube.setLength(23.0);
    
    std::cout << "面积=" << cube.getarea() << "\t 体积=" << cube.getcubeaV() << std::endl;
    
    Cube cube2;
    cube2.setWidth(10.0);
    cube2.setHeight(13.0);
    cube2.setLength(23.0);
   
    if (isSampleCube(cube, cube2)) {
        std::cout  << "cube == cube2" << std::endl;
    } else {
        std::cout  << "cube != cube2" << std::endl;
    }
    
    Cube cube3;
    cube3.setWidth(11.0);
    cube3.setHeight(16.0);
    cube3.setLength(28.0);
    if (cube2.isSamplecube(cube3)) {
        std::cout  << "cube2 == cube3" << std::endl;
    } else {
        std::cout  << "cube3 != cube2" << std::endl;
    }

    
    return 0;
}

  类内有其他类作为成员变量

   

#include 
#include "mathutil.hpp"
#include 
using namespace std;
class Point {
private:
    double m_x;
    double m_y;
public:
    void setX(double x) {
        m_x = x;
    }
    void setY(double y) {
        m_y = y;
    }
    double getX() {
        return m_x;
    }
    double getY() {
        return m_y;
    }
};
class Circle1 {
private:
    double m_r;
    Point  m_point;
    
public:
    void setR(double r) {
        m_r = r;
    }
    void setPoint(Point point) {
        m_point = point;
    }
    double getR() {
        return m_r;
    }
    
    Point getPoint() {
        return m_point;
    }
};
void isInCircle(Circle1 &circle, Point &point) {
    double distance = (circle.getPoint().getX() - point.getX()) *  (circle.getPoint().getX() - point.getX()) + (circle.getPoint().getY() - point.getY()) * (circle.getPoint().getY() - point.getY());
    double mr = circle.getR() * circle.getR();
    
    if (distance == mr) {
        std::cout << "点在圆上" << std::endl;
    } else if (distance < mr) {
        std::cout << "点在圆内" << std::endl;

    } else {
        std::cout << "点在圆外" << std::endl;
    }
}
int main(int argc, const char * argv[]) {
    // insert code here...
    std::cout << "Hello, World!\n";
    Point center;
    center.setX(10.0);
    center.setY(0.0);
    Circle1 circle;
    circle.setR(10.0);
    circle.setPoint(center);
    
    
    Point point;
    point.setX(-1.0);
    point.setY(0.0);
    
    
    isInCircle(circle, point);
    return 0;
}

构造函数析构函数

构造函数初始化类

析构函数销毁类资源

对象的初始化和清理工作是由编译器强制要求我们做的 因此我们如果不提供构造函数和析构函数编译器会提供 编译器提供的构造和析构函数是空实现

构造函数: 主要用于创建对象时为对象的成员属性赋值 构造函数由编译器自动调用无需手动调用

析构函数: 主要作用于对象销毁前系统自动调用 执行一些清理工作。

构造函数语法:

类名(){}

1.构造函数没有返回值也不用写void

2.函数名称与类名相同

3.构造函数可以有参数 因此可以重载

4.程序在调用对象的时候会自动调用构造函数 无需手动调用 并且只调用一次。

析构函数语法

1.析构函数没有返回值也不用写void

2.函数名称与类名相同在类名前面加上~

3.析构函数有没有参数 因此不可以重载

4.程序对象销毁前会自动调用析构函数 无需手动调用 并且只会调用一次。

.h文件

#ifndef People_hpp
#define People_hpp

#include 
class People {
public:
    People();
    ~People();
    
};


#endif /* People_hpp */

.cpp文件

#include "People.hpp"
#include 
People:: People() {
    std::cout << "people 构造函数调用了" << std::endl;
}

People:: ~People() {
    std::cout << "people 析构函数调用了" << std::endl;

}
 

调用

#include 
#include "People.hpp"
using namespace std;
int main(int argc, const char * argv[]) {
    // insert code here...
    std::cout << "Hello, World!\n";
    People people;
    People p = People();
    return 0;
}

构造函数的分类和调用

按参数分类: 有参构造函数和无参构造函数

按类型分类:普通构造函数和拷贝构造函数

调用方式

1.括号调用

2.显式调用

3.隐式转换法

#ifndef People_hpp
#define People_hpp

#include 
class People {
    int m_age;
public:
    // 有参构造
    People(int age);
    //无参构造
    People();
    //拷贝构造
    People(const People  &p);
    ~People();
    
};


#endif /* People_hpp */
#include "People.hpp"
#include 
//无参构造 或者默认构造函数
People:: People() {
    std::cout << "people 构造函数调用了。无参构造 或者默认构造函数" << std::endl;
}

People:: ~People() {
    std::cout << "people 析构函数调用了" << std::endl;

}
 
// 有参构造
People:: People(int age) {
    m_age = age;
    std::cout << "people 构造函数调用了。  有参构造" << std::endl;
}

//拷贝构造
People:: People(const People &p) {
    m_age = p.m_age;
    std::cout << "people 构造函数调用了。 拷贝构造" << std::endl;

}
#include 
#include "People.hpp"
using namespace std;
int main(int argc, const char * argv[]) {
    // insert code here...
    std::cout << "Hello, World!\n";
    // 默认构造函数调用
    // 括号调用法
    People p1; // 默认构造函数 注意调用的时候不需要使用小括号 否则编译器会把它当成函数声明People p()
    People p2(25);
    People p3(p2);
    
    //显式法
    People p4 = People(10); // 有参构造
    People p5 = People(p4); // 拷贝构造
    
    //People(22); // 匿名对象 当前行执行结束后系统会立即回收其内存
    // 不要用拷贝对象初始化一个匿名构造函数 编译器会认为是重定义  People(p5)
    
    //隐式转换
    People p6 = 10; //相当于 People p6 = People(10); 有参构造
    People p7 = p6; // 拷贝构造
    return 0;
}
拷贝构造的使用场景

1.使用已经创建完成的对象创建一个新对象

    People p4 = People(10); // 有参构造
    People p5 = People(p4); // 拷贝构造

2.值传递的方式给函数参数传值. (调用函数传值的时候 实参给形参赋值的时候)

#include 
#include "People.hpp"
using namespace std;
void peopleInfo(People p) {
    std::cout << "peopleInfo!\n" << std::endl;

}
int main(int argc, const char * argv[]) {
    // insert code here...
    std::cout << "Hello, World!\n";
    People p;
    peopleInfo(p);
    return 0;
}








Hello, World!
people 构造函数调用了。无参构造 或者默认构造函数
people 构造函数调用了。 拷贝构造
peopleInfo!

people 析构函数调用了
people 析构函数调用了
Program ended with exit code: 0

3.值返回局部对象

#include 
#include "mathutil.hpp"
#include 
#include "People.hpp"
using namespace std;

People createPeople() {
    People p;
    std::cout <<  &p << std::endl;
    return p;
}
void test22() {
    People p1 = createPeople();
    std::cout <<  &p1 << std::endl;

}
int main(int argc, const char * argv[]) {
    // insert code here...
    std::cout << "Hello, World!\n";
    test22();
    return 0;
}










Hello, World!
people 构造函数调用了。无参构造 或者默认构造函数
0x7ff7bfeff238
0x7ff7bfeff238
people 析构函数调用了
sh: pause: command not found
Program ended with exit code: 0

    我在xcode上没有试出来  可能不同编译器 处理的不同吧

构造函数调用规则

默认情况下cpp给一个类提供三个函数

1.默认构造函数 函数体为空

2.析构函数 函数体为空

3.默认拷贝构造函数 对属性进行值拷贝

规则

如果自定义了有参构造函数 c++不再提供默认构造函数 但是会提供默认拷贝构造函数

如果自定义了拷贝构造函数 c++不再提供其他构造函数。

深浅拷贝

 使用编译器生层的拷贝构造函数 浅拷贝

 这样在析构释放堆区内存的时候就会crash

#ifndef Phone_hpp
#define Phone_hpp

#include 
class Phone {
private:
    double m_width;
    double* m_height;
public:
    Phone(double width,double height);
    ~Phone();
};
#endif /* Phone_hpp */
#include "Phone.hpp"
#include 

Phone::Phone(double width,double height) {
    m_width = width;
    m_height = new double(height);
    std::cout << "Phone 构造函数调用了。  有参构造" << std::endl;

}

Phone::~Phone() {
    // 清理堆区开辟的内存
    if (m_height != NULL) {
        delete m_height;
        m_height = NULL;
    }
    std::cout << "Phone 析构函数调用了" << std::endl;

}
#include 
#include "Phone.hpp"
using namespace std;
void test23() {
    Phone phone(16,20);
    Phone p(phone);

}

int main(int argc, const char * argv[]) {
    // insert code here...
    std::cout << "Hello, World!\n";
    
    test23();
    std::cout << "end!\n";

    return 0;
}










Hello, World!
Phone 构造函数调用了。  有参构造
Phone 析构函数调用了
cpplearn(5538,0x7ff85f8bc680) malloc: *** error for object 0x600000010030: pointer being freed was not allocated
cpplearn(5538,0x7ff85f8bc680) malloc: *** set a breakpoint in malloc_error_break to debug
(lldb) 

深拷贝 解决类中有在堆区开辟内存的 一定要自己实现拷贝构造函数 防止浅拷贝析构 释放堆区内存时候crash

#ifndef Phone_hpp
#define Phone_hpp

#include 
class Phone {
private:
    double m_width;
    double* m_height;
public:
    Phone(double width,double height);
    Phone(const Phone &p);
    ~Phone();
};
#endif /* Phone_hpp */
#include "Phone.hpp"
#include 

Phone::Phone(double width,double height) {
    m_width = width;
    m_height = new double(height);
    std::cout << "Phone 构造函数调用了。  有参构造" << std::endl;

}
/// 当类中有指针类型的时候 就需要自己实现拷贝构造函数
Phone::Phone(const Phone &p) {
    m_width = p.m_width;
    m_height =  new double(*p.m_height);
    std::cout << "Phone 拷贝构造函数调用了。" << std::endl;
}

Phone::~Phone() {
    // 清理堆区开辟的内存
    if (m_height != NULL) {
        delete m_height;
        m_height = NULL;
    }
    std::cout << "Phone 析构函数调用了" << std::endl;

}
#include 
#include "Phone.hpp"
using namespace std;
void test23() {
    Phone phone(16,20);
    Phone p(phone);

}

int main(int argc, const char * argv[]) {
    // insert code here...
    std::cout << "Hello, World!\n";
    
    test23();
    std::cout << "end!\n";

    return 0;
}









Hello, World!
Phone 构造函数调用了。  有参构造
Phone 拷贝构造函数调用了。
Phone 析构函数调用了
Phone 析构函数调用了
end!
Program ended with exit code: 0

初始化列表

用来初始化属性

构造函数():属性1:(值1)属性2:(值2)...{}

#include 
#include 
using namespace std;
class Car{
private:
    string m_name;
    string m_color;
    double m_version;
public:
    Car(string name, string color, double version): m_name(name), m_color(color), m_version(version) {
        std::cout << "name = " << m_name << "color = " << m_color << "version = " << m_version << std::endl;
    };
    ~Car() {
        std::cout << "~Car()\n";
    }
};




int main(int argc, const char * argv[]) {
    // insert code here...
    std::cout << "Hello, World!\n";
    Car car("bmw","black",8.1);
    std::cout << "end!\n";

    return 0;
}

你可能感兴趣的:(c++,开发语言)