C++ 类与对象Oop

已于 2024-02-14 00:02:58 修改
阅读量1.3k 收藏 51
点赞数 53
文章标签： c++ 开发语言
于 2024-01-18 19:52:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74154295/article/details/135577119
版权

类与对象Oop

同Java一样，C++具备这面向对象的概念。我们也可以和java对比着学习，发现他们的不同：
此处是我的java博客的链接：
我在VScode学Java类与对象（Java的类与对象、this关键字）

先了解下面的概念

过程性编程（Procedural programming）是一种编程范式，它将程序分解为一系列的步骤或过程。这些过程按照顺序执行，通常涉及函数和指令的调用。过程性编程强调程序的执行过程，以及数据和功能之间的分离。

面向对象编程（Object-oriented programming）是另一种编程范式，它将数据和功能组合成对象。对象可以包含数据（称为属性或成员变量）和操作数据的方法（称为方法或成员函数）。面向对象编程强调数据和功能的封装，继承和多态性。

一、类：用户定义的数据类型，用于封装数据和方法

类是一种用户定义的数据类型，用于封装数据和方法。
它可以包含成员变量（数据）和成员函数（方法），并且可以通过实例化创建对象。
提供了一种组织和管理代码的方式，以及实现数据抽象和封装的能力。

在面向对象编程中，类的定义通常包括类声明和类方法定义两部分。

类声明描述了类的数据部分，通常以数据成员的方式描述。同时，它也描述了类的公有接口，即类的方法或成员函数。这部分提供了类的蓝图，定义了类的结构和公有接口。

类方法定义描述了如何实现类的成员函数，即方法的具体实现细节。这部分提供了类成员函数的具体实现，包括方法的功能和操作。

#include <iostream>

using namespace std;

// Class declaration
class MyClass {
private:
    int data; // Data member

public:
    void setData(int value); // Member function declaration
    int getData(); // Member function declaration
};

// Class method definition
void MyClass::setData(int value) {
    data = value;
}

int MyClass::getData() {
    return data;
}

int main() {
    MyClass obj;
    obj.setData(42);
    cout << "Data: " << obj.getData() << endl;
    return 0;
}

1.1 对比结构体

C++中的结构体（struct）和类（class）都可以用来定义自定义数据类型。它们的主要区别在于默认的访问权限和成员函数。结构体的默认访问权限是公共的（public），而类的默认访问权限是私有的（private）。
此外，类可以包含成员函数和构造函数，而结构体不能包含成员函数，但可以包含构造函数。在实际使用中，结构体通常用于简单的数据聚合，而类用于更复杂的数据抽象和封装。

结构体示例

// 结构体示例
#include <iostream>
using namespace std;

struct Person {
    string name;
    int age=123;
};

int main() {
    Person person1;
    person1.name = "Alice";
    person1.age = 25;

    cout << "Name: " << person1.name << ", Age: " << person1.age << endl;

    return 0;
}

类示例


#include <iostream>
using namespace std;

class Person {
public:
    string name;
    int age;
    float score;
};

int main() {
    Person person1;
    person1.name = "Bob";
    person1.age = 30;
    person1.score = 89.5;
    cout << "Name: " << person1.name << ", Age: " << person1.age <<"score" <<person1.score<<endl;

    return 0;
}

警告–>主要目的：初始化

Clang-Tidy 提示 “Constructor does not initialize these fields: age” 是因为在代码中没有显式地在构造函数中初始化类的成员变量 age。而对于 name，因为它是一个 std::string 类型的成员变量，它有一个默认的构造函数，因此即使没有显式初始化，它也会被默认初始化为空字符串。

所以写成：

class Person {
public:
    string name;
    int age{};
    float score{};
};

1.2 定义类的过程并定义一个对象

1.2.1 定义类

class MyClass {
    // class members and methods go here
};

定义一个类的过程就是使用关键字class后面跟着类名，然后在大括号内定义类的成员变量和方法。明确我们需要的成员属性，在给定我们需要方法使得类更佳完整。

例子
class Cube {
private:
    int L, W, H;
public:
//    setter 和 getter
    void setL(int l) {
        L = l;
    }

    int getL() const {
        return L;
    }

    void setW(int w) {
        W = w;
    }

    int getW() const {
        return W;
    }

    void setH(int h) {
        H = h;
    }

    int getH() const {
        return H;
    }

//    表面积
    int area() const {
        return 2 * (L * W + L * H + W * H);
    }

//    体积
    int volume() const {
        return L * W * H;
    }
}

1.2.2 定义一个对象

//    在C++中
Cube c{};

// 使用大括号初始化语法对对象进行值初始化。这确保了对象的所有成员变量都被初始化为其默认值，
// 即int类型的成员变量会被初始化为0。
// 这种初始化方式在C++11标准中引入，它提供了更加一致和可靠的初始化语法，尤其是在涉及到类类型的初始化时。

//    在C++中，使用*操作符可以用来解引用指针。在你提供的代码中，
 Cube cube = *new Cube();

// 在C++中，使用*操作符可以用来解引用指针。在你提供的代码中，
// *new Cube()创建了一个新的Cube对象，并返回指向该对象的指针。
// 然后，*操作符被用来解引用这个指针，以便将指针指向的对象赋值给cube变量。
//简而言之，new Cube()创建了一个新的Cube对象，并操作符用来解引用指针，以便将指针指向的对象赋值给cube变量。

在这里插入图片描述

1.2.3 注意事项+例子

在C++中定义类时需要注意以下几点：

  1. 类的成员默认是私有的，需要使用public、protected或者private关键字来指定访问权限。
  2. 类的成员函数可以在类内部定义，也可以在类外部定义。
  3. 类的成员变量和方法可以通过对象的实例来访问。
// 2023/11/13日创建
#include <iostream>

using namespace std;

//PointClass
class Point {
private:
    // x,y坐标
    int X;
    int Y;
public:
    void setX(int x) { // 设置X坐标
        X = x;
    }

    int getX() { // 获取X坐标
        return X;
    }

    void setY(int y) { // 设置Y坐标
        Y = y;
    }

    int getY() { // 获取Y坐标
        return Y;
    }
};

//CircleClass
class Circle {
private:
    int C_R; // 圆的半径
    Point C_Center; // 圆心坐标
public:
    void setC_R(int r) { // 设置圆的半径
        C_R = r;
    }

    int getC_R() { // 获取圆的半径
        return C_R;
    }

    void setC_Center(Point p) { // 设置圆心坐标
        C_Center = p;
    }

    Point getC_Center() { // 获取圆心坐标
        return C_Center;
    }

    bool isPointInside(Point p) { // 判断点是否在圆内部
        int dx = p.getX() - C_Center.getX();
        int dy = p.getY() - C_Center.getY();
        int distanceSquared = dx * dx + dy * dy;
        int radiusSquared = C_R * C_R;
        return distanceSquared <= radiusSquared;
    }
};

int main() {
    // 创建Point对象
    Point p;
    p.setX(3); // 设置X坐标为3
    p.setY(4); // 设置Y坐标为4
    cout << "Point坐标: (" << p.getX() << ", " << p.getY() << ")" << endl;

    // 创建Circle对象
    Circle c;
    c.setC_R(5); // 设置圆的半径为5
    c.setC_Center(p); // 设置圆心坐标为Point对象p
    cout << "Circle半径: " << c.getC_R() << endl;
    cout << "Circle圆心坐标: (" << c.getC_Center().getX() << ", " << c.getC_Center().getY() << ")" << endl;

    // 判断点是否在圆内部
    Point testPoint;
    testPoint.setX(2);
    testPoint.setY(3);
    if (c.isPointInside(testPoint)) {
        cout << "点在圆内部" << endl;
    } else {
        cout << "点不在圆内部" << endl;
    }

    return 0;
}

在这里插入图片描述

1.2.4 分成头文件和源文件的方式

（0）注意事项

#ifndef和#define是C/C++中的预处理指令，用于防止头文件被多次包含。

#ifndef <标识>
#define <标识>
...
#endif

当头文件被包含到多个源文件中时，防止多次定义同一个标识符。如果标识符已经被定义过，则#ifndef和#define之间的代码会被忽略，直到#endif。

这样可以避免由于重复包含头文件而导致的重复定义错误。

（1）Point.h
// Point.h
#ifndef POINT_H
#define POINT_H

class Point {
private:
    int X;
    int Y;
public:
    void setX(int x);
    int getX();
    void setY(int y);
    int getY();
};

#endif
（2） Point.cpp
// Point.cpp
#include "Point.h"

void Point::setX(int x) {
    X = x;
}

int Point::getX() {
    return X;
}

void Point::setY(int y) {
    Y = y;
}

int Point::getY() {
    return Y;
}
（3） Circle.h
// Circle.h
#ifndef CIRCLE_H
#define CIRCLE_H
#include "Point.h"

class Circle {
private:
    int C_R;
    Point C_Center;
public:
    void setC_R(int r);
    int getC_R();
    void setC_Center(Point p);
    Point getC_Center();
    bool isPointInside(Point p);
};

#endif
（4） Circle.cpp
// Circle.cpp
#include "Circle.h"

void Circle::setC_R(int r) {
    C_R = r;
}

int Circle::getC_R() {
    return C_R;
}

void Circle::setC_Center(Point p) {
    C_Center = p;
}

Point Circle::getC_Center() {
    return C_Center;
}

bool Circle::isPointInside(Point p) {
    int dx = p.getX() - C_Center.getX();
    int dy = p.getY() - C_Center.getY();
    int distanceSquared = dx * dx + dy * dy;
    int radiusSquared = C_R * C_R;
    return distanceSquared <= radiusSquared;
}
（5）main.cpp
// main.cpp
#include <iostream>
#include "Point.h"
#include "Circle.h"

using namespace std;

int main() {
    Point p;
    p.setX(3);
    p.setY(4);
    cout << "Point coordinates: (" << p.getX() << ", " << p.getY() << ")" << endl;

    Circle c;
    c.setC_R(5);
    c.setC_Center(p);
    cout << "Circle radius: " << c.getC_R() << endl;
    cout << "Circle center coordinates: (" << c.getC_Center().getX() << ", " << c.getC_Center().getY() << ")" << endl;

    Point testPoint;
    testPoint.setX(2);
    testPoint.setY(3);
    if (c.isPointInside(testPoint)) {
        cout << "Point is inside the circle" << endl;
    } else {
        cout << "Point is not inside the circle" << endl;
    }

    return 0;
}

1.3 构造函数和析构函数

对象的初始化和清除是C++中两个非常重要的操作，它们分别对应于构造函数和析构函数。

构造函数：主要作用是在创建对象是为对象的成员赋值，构造函数由编辑器自动调用，无需手动调用

构造函数用于对象的初始化，主要作用是在创建对象时为对象的成员赋值。构造函数的名称与类名相同，没有返回类型，可以有参数。当对象被创建时，构造函数会自动调用，无需手动调用。

析构函数：主要作用是在于对象销毁前系统自动调用，执行一些清除工作

析构函数用于对象的清理，主要作用是在对象销毁前执行一些清除工作，如释放动态分配的内存、关闭文件等。析构函数的名称是在类名前加上波浪号(~)，没有返回类型，不接受任何参数。当对象被销毁时（例如超出作用域、delete操作符被调用），析构函数会自动调用，无需手动调用。

如果我们自己不提供构造函数或析构函数，编译器会自动生成默认的构造函数和析构函数，这些默认的函数会执行空实现。但是在某些情况下，我们可能需要自定义构造函数和析构函数来完成特定的初始化和清理工作。

1.3.1 构造函数： 类名(){}

构造函数的特点包括：

  1. 没有返回值也不写void。
  2. 构造函数的名称与类名相同。
  3. 构造函数可以有参数，因此可以发生重载。
  4. 程序在创建对象时会自动调用构造函数，无需手动调用，且只会调用一次。
分类方式：
	按参数分为： 有参构造和无参构造
	按类型分为： 普通构造和拷贝构造
调用方式：
​	括号法
	显示法
​	隐式转换法
（1）有无参构造
class Person
{
public:
    int age;
    //1.无参构造
    Person(){
        cout << "无参构造Person()演示" << endl;
    }

    // 2.有参构造
    Person(int a){
        age = a;
        cout << "有参构造Person(int a)演示" << endl;
    }
};
（2）拷贝构造函数

调用时机

  • 使用一个已经创建完毕的对象来初始化一个新对象
  • 值传递的方式给函数参数传值
  • 以值方式返回局部对象

规则：

  • 如果用户定义有参构造函数，c++不在提供默认无参构造，但是会提供默认拷贝构造

  • 如果用户定义拷贝构造函数，c++不会再提供其他构造函数

类名(const 类名& obj);

Person(const Person &p) {
		// 将传入的对象p的值赋值给当前对象
        age = p.age;
        cout << "拷贝构造Person(const Person &p)演示" << endl;
}

int main(){
	Person x2(10);
    Person x3(x2);
	cout<<"x2's age is "<<x2.age<<endl;
    cout<<"x3's age is "<<x3.age<<endl;
}

。

1.3.2 析构函数： ~类名(){}

析构函数的特点包括：

  1. 析构函数的名称是在类名前加上波浪号()，例如ClassName。
  2. 析构函数没有返回类型，也不接受任何参数。
  3. 析构函数在对象被销毁时自动调用，用于执行对象的清理工作，如释放资源、关闭文件等。
  4. 如果用户没有显式定义析构函数，编译器会提供一个默认的空实现的析构函数。
  5. 如果类中有动态分配的资源（如使用new关键字分配的内存），通常需要在析构函数中释放这些资源，以避免内存泄漏。
  6. 每个类只能有一个析构函数，析构函数不可以有参数,因此不可以发生重载

1.3.3 示例

class Person {
public:
//    1.构造函数
/*没有返回值也不写void、和类名相同、可以有参数，因此可以发生重载*/
    Person() {
        cout << "Person()空参构造的调用" << endl;
    }
//     2. 析构函数：主要作用是在于对象销毁前系统自动调用，执行一些清除工作
/* 没有返回值也不写void、函数名称与类名相同,在名称前加上符号~、不可以有参数,因此不可以发生重载*/
    ~Person() {
        cout << "~Person()析构构造的调用" << endl;

    }

};

//构造和析构都是必须实现的，如果不成，编译器会给一个空实现
void test() {
    Person p;
/*栈上的数据，test执行完毕后，释放该对象*/
}

int main() {
// 公共作用域下
// 2.构造函数用外部函数调用
    test();
//或者这样的内部直接用方式
//Person();


//如果写在main函数中，那么main函数执行完毕，对象就释放了
    Person s;
    system("pause");


}

在这里插入图片描述

//构造和析构都是必须实现的，如果不成，编译器会给一个空实现
void test() {
    Person p;
/*栈上的数据，test执行完毕后，释放该对象*/
}
（1）这两种方式都可以创建Person对象，但它们的作用域和生命周期是不同的。

  1. test();：在test函数中创建了一个Person对象。这个对象是test函数的局部变量，所以它的作用域仅限于test函数。当test函数执行完毕后，这个对象就会被销毁，触发析构函数。

  2. Person();：这是一个匿名对象，它在创建后会立即被销毁。因为它没有名称，所以不能在后续的代码中引用它。这种方式通常用于临时对象的创建，或者作为函数参数。

这两种方式都可以创建对象，但是根据你的需求和对象的使用方式，你可能会选择其中一种。例如，如果你需要在函数中使用一个对象，然后在函数结束时自动销毁它，你可以在函数中创建对象。如果你只需要一个临时对象，你可以创建一个匿名对象。

（2）匿名对象

Person();：这行代码创建了一个匿名对象。这个匿名对象在创建后会立即被销毁，因为它没有名称，所以不能在后续的代码中引用它。这就是匿名对象的生命周期。

Person p =Person();：这行代码首先创建了一个匿名对象，然后通过拷贝构造函数将这个匿名对象的内容复制给了p对象，然后匿名对象被销毁。这样，p对象就拥有了匿名对象的数据，而且p对象的生命周期会持续到它离开其作用域。

这两种方式都可以创建对象，但是根据你的需求和对象的使用方式，你可能会选择其中一种。例如，如果你只需要一个临时对象，你可以创建一个匿名对象。如果你需要一个持久的对象，你可以创建一个具名对象。

你会魔法吗✧(≖ ◡ ≖✿)
关注
  • 53
    点赞
  • 踩
  • 51
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 22
    评论
专栏目录
C++类和对象
C语言实战技术
03-05 857
文章目录一、C++结构体的新特征二、C++ 类和对象三、对象数组四、对象的指针五、对象作为函数的参数六、对象的初始化和占用内存的大小七、小结八、面向对象编程（Object Oriented Programming，OOP）九、课后作业十、版权声明 一、C++结构体的新特征 C语言的结构体不允许有函数，定义结构体变量的方法是：struct 结构体名结构体变量名。 在C++中，结构体的成员可以有函数，...
C++类和对象.ppt
11-13
C++类和对象是面向对象编程（OOP）的基础概念，类是对对象的抽象描述，对象是现实世界中某个具体的物理实体在计算机逻辑中的映射和体现。现实中的对象都具有属性和行为。 类的概念 在C++中，类是一种抽象的数据...
类与对象 C++
生活需要深度
01-16 2151
概念 描述 类成员函数 类的成员函数是指那些把定义和原型写在类定义内部的函数，就像类定义中的其他变量一样。 类访问修饰符 类成员可以被定义为 public、private 或 protected。默认情况下是定义为 private。 构造函数 & 析构函数 类的构造函数是一种特殊的函数，在创建一个新的对象时调用。类的析构函数也是一种特殊的函数，在删除所创建的对象时调用。 C++ 拷贝构造函数 拷贝构造函数，是一种特殊的构造函数，它在创建对象时，是使用同一
【C++学习】面向对象（oop）
weixin_44117376的博客
10-22 420
文章目录一、面向对象编程1.操作符重载2.copy问题3.析构函数4.value 与 reference5.reference 与 pointer二、示例1.类不含指针（Complex）2.类含指针（String） 一、面向对象编程 1.操作符重载 操作符重载的两种方法 成员函数方法：a.op(b); 全局函数+友元函数方法：op(a,b); 不能重载的操作符 . ?: :: sizeof 运算符重载不改变优先级 2.copy问题 深拷贝 和 浅拷贝 浅拷贝：类内变量创建副本，类内指针共享内存 深拷
C++面向对象（OOP）编程-类与结构体的区别
发狂的小花的博客
12-19 1013
class和struct的语法基本相同，从声明到使用，都很相似，但是struct的约束要比class多，理论上，struct能做到的class都能做到，但class能做到的stuct却不一定做的到struct是值类型，class是引用类型，因此它们具有所有值类型和引用类型之间的差异由于堆栈的执行效率要比堆的执行效率高，但是堆栈资源却很有限，不适合处理逻辑复杂的大对象，因此struct常用来处理作为基类型对待的小对象，而class来处理某个商业逻辑。
[C++]类与对象
weixin_45843323的博客
07-13 925
在C++中，类和对象是面向对象编程（OOP）的核心概念。
C++类和对象总结
2401_83427936的博客
06-22 2211
公共部分（public）：这部分包含类的成员函数和可以被外部访问的成员变量（尽管在良好的实践中，成员变量通常被声明为私有的）。public成员可以在任何地方被访问，protected成员只能在类的成员函数和派生类中被访问，而private成员只能在类的成员函数中被访问。在大括号内部，可以定义类的成员变量和成员函数。子类可以添加新的成员变量和成员函数，也可以重写父类的成员函数（通过函数覆盖）。在C++中，类的访问控制是一个重要的特性，它允许程序员定义类的成员（包括成员函数和成员变量）的可见性和可访问性。
【C++ | 面向对象思想】 C++ 的面向对象(OOP)思想详解：抽象、封装、继承、多态
wkd_007的博客
05-30 1138
👉本文介绍了面向过程和面向对象的区别，然后介绍了几个面向对象的特性：抽象、封装、继承、多态。
C++ 类和对象
m0_72625526的博客
06-28 1229
面向过程编程（POP）：专注于过程和步骤，类似于按照菜谱做饭，每一步都是具体的指令。面向对象编程（OOP）：专注于对象和交互，类似于咖啡店中的角色分工，每个对象都有自己的职责，通过对象之间的协作来完成任务。class className// 类名// 类体：由成员函数和成员变量组成// 一定要注意后面的分号class Dateint date;int month;
C++面向对象（OOP）编程-友元（友元函数和友元类）
发狂的小花的博客
12-13 1118
本文主要介绍面向对象编程的友元的使用，以及友元的特性和分类，提供C++代码。
C++面向对象OOP-析构函数
Mr'bian
10-20 268
对象销毁前调用，和构函数相对应，一般用来清理对象构造函数申请的堆区空间。
大学C++ 类与对象 课件
06-14
综上所述，C++的类与对象是实现面向对象编程的关键，它们结合了数据抽象、封装、继承和多态等概念，极大地提高了代码的组织结构和复用性，使得复杂系统的开发变得更加简洁和高效。通过学习和熟练掌握这些知识，非...
C++类与对象
12-09
详细介绍了类与对象方面知识 类（Class）是面向对象程序设计（OOP）实现信息封装的基础。 类是用户定义类型，也称为类类型 每个类包含数据说明和一组操作数据或传递消息的函数。类的 实例称为对象 C++的类由C语言的...
C++ 类和对象.zip
06-18
在C++编程语言中，类和对象是面向对象编程（OOP）的核心概念。类是对象的蓝图，它定义了一组特性和行为，而对象则是类的实例，具备了类所描述的属性和方法。本资料包“C++ 类和对象.zip”很可能是为了深入讲解这些...
c++类与对象 PPT
05-15
面向对象编程（Object-Oriented Programming，简称OOP）是C++语言中的核心特性，它以类和对象为基石。类是创建对象的蓝图，定义了一组属性（数据成员）和行为（成员函数）。对象则是类的实例，拥有类中定义的属性和...
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 233
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
C++ 继承篇
2301_79201049的博客
07-18 658
必须对继承而来的成员进行初始化直接通过初始化列表或者赋值的方式进行初始化调用父类构造函数进行初始化
学懂C语言系列（三）：C语言基本语法
martian665的专栏
07-17 567
学懂C语言系列,C语言基本语法
c++ primer plus 第16章string 类和标准模板库, 16.3.2 可对矢量执行的操作
最新发布
zhyjhacker的博客
07-21 783
c++ primer plus 第16章string 类和标准模板库, 16.3.2 可对矢量执行的操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 22
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

你会魔法吗✧(≖ ◡ ≖✿)

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值