C++ 类 & 对象_c++ & . 撖寡情-CSDN博客

本文链接：https://blog.csdn.net/qq_51753728/article/details/140335611

C++ 在 C 语言的基础上增加了面向对象编程，C++ 支持面向对象程序设计。类是 C++ 的核心特性，通常被称为用户定义的类型。

类用于指定对象的形式，是一种用户自定义的数据类型，它是一种封装了数据和函数的组合。类中的数据称为成员变量，函数称为成员函数。类可以被看作是一种模板，可以用来创建具有相同属性和行为的多个对象。

类可以这样理解，一个类可以看做一个公司，比如建筑公司。成员变量可以看作这个公司的员工，成员函数可以看作这个公司的各种工具，比如一个建筑公司可能有挖掘机、推土机、起重机等。类解决问题的机制类似于让一个员工（成员变量）使用使用针对性的工具（成员函数）去解决针对性的问题。

所以，类：可以比作某个公司蓝图或模板，它定义了公司（对象）应该有哪些员工（成员变量）和工具（成员函数）。

C++ 类定义

定义一个类需要使用关键字 class，然后指定类的名称，类的主体是包含在一对花括号中，主体包含类的成员变量和成员函数。

定义一个类，本质上是定义一个数据类型的蓝图，它定义了类的对象包括了什么，以及可以在这个对象上执行哪些操作。

class 类名{ //类名，类似一个公司名，由自己设置，最好向公司名一样简单易懂
    
public://访问修饰符public,公共权限,这个修饰符下的成员函数和成员变量,类内可以访问,类外可以访问,
//类似一个公司的普通技术和普通员工，公司内的人可以知道，公司外的人也可以知道
       
         成员变量

         成员函数

private://访问修饰符private，私有权限，这个修饰符下的成员函数和成员变量，只能在类的内部访问。
//即，只有该类的成员函数和友元函数可以访问private成员。
//当一个类继承自另一个类时，基类的private成员不能被派生类直接访问,派生类即子类和父类的关系。
//类似一个公司的核心机密，只能在总公司访问其子公司也不能访问。

         成员变量

         成员函数

protected://访问修饰符protected，保护权限，除了类的内部和友元函数外，还可以被该类的派生类访问。
//当一个类继承自另一个类时，基类的protected成员可以被派生类访问。
//类似一个公司的一般机密，其子公司也能访问。
         成员变量

         成员函数


}；

/*
继承方式
public继承

基类的public成员在派生类中保持为public。
基类的protected成员在派生类中保持为protected。
基类的private成员不能在派生类中直接访问。
protected继承

基类的public成员在派生类中变为protected。
基类的protected成员在派生类中保持为protected。
基类的private成员不能在派生类中直接访问。
private继承

基类的public成员在派生类中变为private。
基类的protected成员在派生类中变为private。
基类的private成员不能在派生类中直接访问。

*/

以下实例我们使用 class （类）定义Cube(立方体) 数据类型，包含了三个成员变量 length（长）、breadth （宽）和 height（高），两个成员函数getArea()(计算立方体表面积) getVolume()（计算立方体体积）：



//设置立方体类
class Cube{

public:
    //成员变量
    //设置长宽高
    int m_L;
    int m_W;
    int m_H;

    //成员函数
    //获取立方体面积
    int getArea(){

        int area = m_L * m_W * 2 + m_L * m_H * 2 + m_W * m_H * 2;
        return area;

    }
    //获取立方体体积
    int getVolume(){

        int volume = m_H * m_W * m_L;
        return volume;

    }
    //打印输出结果
    void outputArea(){

        cout << "立方体面积: " << getArea() << endl;
        cout << "立方体体积： " << getVolume() << endl;

    }

};

定义 C++ 对象

类提供了对象的蓝图，所以基本上，对象是根据类来创建的。声明类的对象，就像声明基本类型的变量一样。下面的语句声明了类 Cube的两个对象：

Cube c1;          // 声明 c1，类型为 Cube
Cube c2;          // 声明 c2，类型为 Cube

对象 c1 和 c2 都有它们各自的数据成员。

访问数据成员

类的对象的公共数据成员可以使用直接成员访问运算符 . 来访问。

为了更好地理解这些概念，让我们尝试一下下面的实例：

#include "iostream"

using namespace std;

//设置立方体类
class Cube{

public:
    //成员变量
    //设置长宽高
    int m_L;
    int m_W;
    int m_H;

    //成员函数
    //获取立方体面积
    int getArea(){

        int area = m_L * m_W * 2 + m_L * m_H * 2 + m_W * m_H * 2;
        return area;

    }
    //获取立方体体积
    int getVolume(){

        int volume = m_H * m_W * m_L;
        return volume;

    }

    void outputArea(){

        cout << "立方体面积: " << getArea() << endl;
        cout << "立方体体积： " << getVolume() << endl;

    }

};

int main(){

    //实例化,建立一个具体的类
    Cube c1;

    //对长宽高赋值
    c1.m_H = 2;
    c1.m_W = 2;
    c1.m_L = 2;
    //打印立方体体积和面积
    c1.outputArea();
    return 0;
}

/*
 * 输出结果：
 * 立方体面积: 24
 *立方体体积： 8

上述访问修饰符是public，如果是private或protected,类内可访问，
类外可访问，在主函数main()中将无法访问类中的成员变量和成员函数
 * */

在C++中，类和对象是面向对象编程（OOP）的核心概念。类是一个用户定义的数据类型，它封装了数据和操作这些数据的函数；对象是类的实例。

类

类是一种抽象数据类型，用于定义对象的属性（数据成员）和行为（成员函数）。它是创建对象的模板或蓝图。类定义了对象的结构和功能，但本身并不占用内存空间。

class Car {
public:
    // 数据成员
    std::string brand;
    std::string model;
    int year;

    // 成员函数
    void displayInfo() {
        std::cout << "Brand: " << brand << ", Model: " << model << ", Year: " << year << std::endl;
    }
};

对象

对象是类的实例化。创建对象的过程就是根据类的定义分配内存，并初始化数据成员。对象是实际存在的实体，可以访问和操作类中定义的数据成员和成员函数。

int main() {
    // 创建Car类的对象
    Car myCar;

    // 设置对象的属性
    myCar.brand = "Toyota";
    myCar.model = "Corolla";
    myCar.year = 2020;

    // 调用对象的成员函数
    myCar.displayInfo();

    return 0;
}

类和对象的关系

类是对象的模板：类定义了对象的结构和行为，但只有在创建对象时才会在内存中分配空间。
对象是类的实例：通过类可以创建多个对象，每个对象都有独立的内存空间和数据成员。
访问控制：类可以使用public、protected和private关键字来控制对象对数据成员和成员函数的访问权限。
封装：类通过将数据成员和成员函数封装在一起，实现数据隐藏和信息保护。对象可以通过公共接口（成员函数）与外界交互。

类和对象的进一步理解

类的成员访问控制

class Example {
private:
    int privateVar; // 私有成员
protected:
    int protectedVar; // 受保护成员
public:
    int publicVar; // 公共成员

    // 构造函数
    Example(int pv, int ptv, int pubv) : privateVar(pv), protectedVar(ptv), publicVar(pubv) {}

    // 公共成员函数
    void display() {
        std::cout << "privateVar: " << privateVar << ", protectedVar: " << protectedVar << ", publicVar: " << publicVar << std::endl;
    }
};

创建和使用对象

int main() {
    Example ex(1, 2, 3); // 创建对象并初始化

    // ex.privateVar = 10; // 错误：不能访问私有成员
    // ex.protectedVar = 20; // 错误：不能访问受保护成员
    ex.publicVar = 30; // 正确：可以访问公共成员

    ex.display(); // 调用公共成员函数

    return 0;
}