c++类和对象---上

文章目录

类的介绍
类的声明 1.1 类名 1.2 成员变量 1.3 成员函数 1.4 访问权限
类的定义 2.1 成员变量的初始化 2.2 成员函数的实现
对象的创建和销毁 3.1 默认构造函数 3.2 析构函数 3.3 拷贝构造函数 3.4 对象的实例化 3.5 对象的销毁
成员访问控制 4.1 公有成员 4.2 私有成员 4.3 保护成员
类的封装性 5.1 封装的概念 5.2 封装的好处

前言

这篇文章主要主要介绍了c++类和对象的前半部分内容，包含类的声明，定义，对象的创建和销毁，成员的访问和控制，类的封装性。

类的介绍

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

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

一、类的声明

1、类名

类的声明通常包括类名和它的成员列表，但不包括成员函数的实际代码。类声明的基本语法如下：

class 类名;

这种声明被称为前向声明，它是必须的，尤其是当类A中用到了类B，而类B的声明出现在类A的后面时。前向声明只能作为指针或引用，不能定义类的对象，也就不能调用对象中的方法。

2、成员变量

成员变量（也称为属性或字段）是类中用于存储数据的变量。成员变量可以是任何数据类型，例如整数、浮点数、字符、字符串、甚至是其他对象。

class Person {
    int age;      // 整数类型的成员变量
    std::string name; // 字符串类型的成员变量
};

3、成员函数

成员函数（也称为方法）是类中用于定义对象行为的函数。成员函数可以访问类的成员变量，并且可以对它们进行操作。

class Person {
    int age;
    std::string name;

public:
    void setName(const std::string& newName) {
        name = newName;
    }

    std::string getName() const {
        return name;
    }
};

4、访问权限

访问权限定义了类成员（包括成员变量和成员函数）的可见性。常见的访问权限有三种：`public`、`protected` 和 `private`。

public：成员在任何地方都可以访问。
protected：成员只能在类内部和派生类中访问。
private：成员只能在类内部访问。

class Person {
private:
    int age;
    std::string name;

public:
    void setName(const std::string& newName) {
        name = newName;
    }

    std::string getName() const {
        return name;
    }

protected:
    // 保护成员
    // ...

private:
    // 私有成员
    // ...
};

二、类的定义

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

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

以下实例我们使用关键字 class 定义 Box 数据类型，包含了三个成员变量 length、breadth 和 height：

class Box
{
   public:
      double length;   // 盒子的长度
      double breadth;  // 盒子的宽度
      double height;   // 盒子的高度
};

关键字 public 确定了类成员的访问属性。在类对象作用域内，公共成员在类的外部是可访问的。也可以指定类的成员为 private 或 protected，这个我们稍后会进行讲解。

2.1 成员变量的初始化

在C++中，成员变量可以在构造函数中初始化，或者使用初始化列表来初始化。

class Person {
private:
    int age;
    std::string name;

public:
    // 构造函数
    Person(int initialAge, const std::string& initialName)
        : age(initialAge), name(initialName) {}

    // 其他成员函数
    // ...
};

2.2 成员函数的实现

成员函数通常声明在类的声明中，但可以在类的外部实现。如果在类声明中直接实现了成员函数（称为内联函数），则该函数的定义也会出现在类声明中。

#include <iostream>
#include <string>

class Person {
private:
    int age;
    std::string name;

public:
    Person(int initialAge, const std::string& initialName)
        : age(initialAge), name(initialName) {}

    void setName(const std::string& newName) {
        name = newName;
    }

    std::string getName() const {
        return name;
    }

    void display() const {
        std::cout << "Name: " << name << ", Age: " << age << std::endl;
    }
};

int main() {
    Person person(25, "John Doe");
    person.display();
    return 0;
}

在这个例子中，`Person` 类有一个构造函数，用于初始化 `age` 和 `name` 成员变量。成员函数 `setName` 和 `getName` 用于设置和获取 `name` 成员变量的值。成员函数 `display` 用于打印 `Person` 对象的信息。

三、对象的创建和销毁

3.1 默认构造函数：

默认构造函数是一个类的特殊成员函数，当对象被创建时自动调用的函数。它没有任何参数，用于初始化对象的成员变量。如果一个类没有显式定义默认构造函数，编译器会自动生成一个默认构造函数。

下面是一个默认构造函数的代码示例：

#include <iostream>

class MyClass {
public:
    MyClass() {
        std::cout << "Default constructor called" << std::endl;
    }
};

int main() {
    MyClass obj;
    return 0;
}

在这个示例中，MyClass类有一个默认构造函数。默认构造函数没有任何参数，并在创建对象时被调用。在main函数中，我们创建了一个MyClass对象obj，并输出了一条消息来验证默认构造函数被调用。

#include <iostream>

class MyClass {
public:
    MyClass() {
        std::cout << "Default constructor called" << std::endl;
    }
};

int main() {
    MyClass obj;
    return 0;
}

3.2 析构函数：

析构函数是一个类的特殊成员函数，用于在对象销毁时自动调用。它的名称与类名相同，但前面加上一个波浪号（~）。析构函数主要用来清理对象所占用的资源，如释放内存、关闭文件等。

析构函数没有参数，也没有返回值。当对象的作用域结束、程序执行完毕、delete运算符用于释放动态分配的对象内存时，析构函数会被自动调用。

比如在下面这个栈中：

3.3拷贝构造函数：

拷贝构造函数是一个特殊的构造函数，用于创建一个新的对象，该对象的内容是已有对象的一个副本，形式：（ClassName(const ClassName& obj)）;

拷贝构造函数可以自定义实现，或者使用编译器自动生成的默认拷贝构造函数（当类没有显式定义拷贝构造函数时，编译器会自动生成一个默认的拷贝构造函数，该函数执行的是浅拷贝）。如果类中存在指针或其他资源，通常需要自定义拷贝构造函数，实现深拷贝。

代码示例：

class MyClass {
public:
    MyClass(); // 构造函数
    MyClass(const MyClass& obj); // 拷贝构造函数
    // 其他成员函数和成员变量

private:
    int data;
};

MyClass::MyClass() {
    // 构造函数的实现
}

MyClass::MyClass(const MyClass& obj) {
    // 拷贝构造函数的实现
    data = obj.data; // 执行深拷贝操作
}

3.4 对象的实例化：

在程序中创建一个对象称为对象的实例化。对象的实例化可以通过调用类的构造函数来完成。构造函数负责为对象的成员变量分配内存并进行初始化，从而创建对象的实例。

3.5 对象的销毁：

当对象不再被使用时，它会被销毁。对象的销毁可以通过调用类的析构函数来完成。析构函数主要用来释放对象占用的资源，清理对象的操作。对象销毁的时机通常是在对象超出其作用域、程序结束或者手动调用delete等情况下。

四、成员访问控制

4.1 公有成员：

公有成员是指在类中声明为public的成员。公有成员可以被任何地方的代码访问，包括类的内部和外部。这意味着其他类和对象可以直接访问和修改公有成员。

在这张图片中public:后面的就是公有成员，其他类和对象可以直接访问和修改。

4.2 私有成员：

私有成员是指在类中声明为private的成员。私有成员只能被同一个类的其他成员函数访问，不能被类的外部代码访问。私有成员用于实现类的封装，隐藏类的内部细节。

4.3 保护成员：

保护成员是指在类中声明为protected的成员。保护成员可以被同一个类的其他成员函数和派生类的成员函数访问，但不能被类的外部代码访问。保护成员提供了一种在继承关系中，子类可以访问父类的成员，但其他类不能访问的机制。

#include <iostream>

class Base {
protected:
    int protectedData;

public:
    Base() : protectedData(0) {}

    void printProtectedData() {
        std::cout << "Protected Data: " << protectedData << std::endl;
    }
};

class Derived : public Base {
public:
    void setProtectedData(int newData) {
        protectedData = newData;
    }
};

int main() {
    Derived derivedObj;
    derivedObj.setProtectedData(10);
    derivedObj.printProtectedData();

    return 0;
}

在这个例子中，Base 类中的 protectedData 是一个保护成员变量，只能在派生类中访问。Derived 类继承自 Base 类，并可以访问和修改 protectedData。

在 main 函数中，我们创建了一个 Derived 类的对象 derivedObj，并使用 setProtectedData 函数将 protectedData 设置为 10。然后，我们调用 printProtectedData 函数来输出 protectedData 的值。

由于 protectedData 是一个保护成员变量，它不能在类的外部直接访问。只有派生类中的成员函数才能直接访问和修改它。因此，这个例子演示了如何使用保护成员来限制对类成员的访问。