c++类与对象详解

谁借莪１个温暖的怀抱￠ 2023-10-14 13:10 12阅读 0赞

### c++类与对象详解 ###

*  对象
 *  类
 *  方法
 *  自定义类型
 *  类的特性
 *  this
 *  类的六个默认成员函数
 *  static成员
 *  友元
 *  内部类

# 对象 #

在C++中，对象是类的实例。定义对象的语法为：

<class_name> object_name;

其中，class\_name 是定义类时指定的类名，object\_name 是对象的名称。

例如，在以下示例中，我们定义了一个名为 Rectangle 的类和两个对象 rect1 和 rect2：

class Rectangle {
        
      int width, height;
    public:
      void set_values (int,int);
      int area () {
        return width*height;}
    };
    
    Rectangle rect1; // 定义第一个对象
    Rectangle rect2; // 定义第二个对象

这里我们创建了两个 Rectangle 类的对象：rect1 和 rect2。

# 类 #

在C++中，类可以通过以下方式定义：

class MyClass {
        
      public:
        // 公有成员函数
        void publicFunc();
    
      private:
        // 私有成员函数
        void privateFunc();
    
      protected:
        // 保护成员函数
        void protectedFunc();
    
      public:
        // 公有成员变量
        int publicVar;
    
      private:
        // 私有成员变量
        int privateVar;
    
      protected:
        // 保护成员变量
        int protectedVar;
    };

上述代码定义了一个名为MyClass的类。其中，public表示公有部分，可以在类的外部访问；private表示私有部分，只能在类的内部访问；protected表示保护部分，可以在类的派生类中访问。

在类的定义中，可以定义成员函数和成员变量。成员函数通常用于操作成员变量，可以是公有的、私有的或受保护的。成员变量可以是公有的、私有的或受保护的，也可以是静态的（在类中共享）。

下面是一个简单的类定义示例：

class MyClass {
        
      public:
        int publicVar;
        void publicFunc() {
        
            // ...
        }
    
      private:
        int privateVar;
        void privateFunc() {
        
            // ...
        }
    
      protected:
        int protectedVar;
        void protectedFunc() {
        
            // ...
        }
    };

在上述示例中，定义了一个名为MyClass的类，其中包含了三种类型的成员：公有、私有和受保护。公有成员包括一个整型变量publicVar和一个名为publicFunc的成员函数；私有成员包括一个整型变量privateVar和一个名为privateFunc的成员函数；受保护成员包括一个整型变量protectedVar和一个名为protectedFunc的成员函数。

类定义完成后，就可以使用MyClass类来创建对象。例如：

MyClass myObject;

上述代码创建了一个名为myObject的MyClass对象。可以通过点运算符.来访问对象的成员，例如：

myObject.publicVar = 10;
    myObject.publicFunc();

上述代码分别访问了myObject对象的公有成员变量publicVar和公有成员函数publicFunc。

# 方法 #

C++中的函数定义有两个主要部分：函数声明和函数体。

函数声明是指在函数定义之前声明函数名称、参数类型和返回类型等信息，以便程序在调用函数时知道该函数的参数类型和返回类型。函数声明通常放在头文件中，以便在需要的地方包含头文件即可使用函数。

函数体是指函数定义的具体实现，包括函数的功能、算法和代码。函数体中包括一组语句，用于执行函数的具体功能。

函数定义的基本格式如下：

返回类型 函数名(参数列表)
    {
        
        // 函数体
    }

其中，返回类型指示函数返回的数据类型，函数名是函数的名称，参数列表是指函数接受的参数类型和名称。函数体由一组语句组成，这些语句定义了函数的具体功能。

下面是一个简单的函数定义示例：

int add(int x, int y)
    {
        
        return x + y;
    }

这个函数的名称是add，参数列表是两个int类型的参数x和y，返回类型是int。函数体中只有一条语句，计算x和y的和并返回结果。

注意，在函数定义中，如果函数的参数列表为空，则需要使用void关键字表示参数列表为空，如下所示：

void printHello()
    {
        
        cout << "Hello, World!" << endl;
    }

这个函数的名称是printHello，参数列表为空，返回类型也为空(void)。函数体中只有一条语句，输出一条字符串。

# 自定义类型 #

C++支持定义自定义类型，主要有以下四种方法：

1.  结构体（struct）：结构体是一种自定义类型，它允许将不同的数据类型组合在一起形成一个单独的类型，常用于表示一组有关联的数据。例如：

struct Student
    {
        int id;
        char name[20];
        float gpa;
    };

1.  枚举（enum）：枚举是一种自定义类型，它允许将一组有限的命名常量组合在一起表示一个类型，例如：

enum Color
    {
        red,
        green,
        blue
    };

1.  类（class）：类是一种自定义类型，它允许将数据和函数封装在一起形成一个独立的数据类型，可以通过类的实例来访问它的成员变量和成员函数，例如：

class Shape
    {
        public:
            virtual float getArea() = 0;
            virtual float getPerimeter() = 0;
    };
    
    class Rectangle : public Shape
    {
        private:
            float width, height;
    
        public:
            Rectangle(float w, float h) : width(w), height(h) {}
    
            float getArea() override { return width * height; }
            float getPerimeter() override { return 2 * (width + height); }
    };

1.  typedef：typedef是一种类型定义语法，它可以将已经存在的类型命名为一个新的类型名。例如：

typedef int Integer;
    Integer x = 42;

以上就是C++定义自定义类型的四种方法。使用不同的方法可以根据实际需求选择最合适的方式。

# 类的特性 #

C++类具有以下特性：

1.  封装（Encapsulation）：将数据和行为封装在一起，以防止直接访问和修改数据。通过公共接口访问和修改数据，可以保证数据的安全性和一致性。
2.  继承（Inheritance）：允许从一个类派生出其他类，派生类继承了基类的属性和方法，并且可以添加自己的属性和方法。通过继承可以实现代码的重用和扩展。
3.  多态（Polymorphism）：同一种行为具有多种形态。通过重载（Overloading）和虚函数（Virtual Function）实现多态性。
4.  抽象（Abstraction）：从具体事物中抽象出通用的概念或者模型，以便于代码的设计和实现。
5.  成员访问控制（Member Access Control）：类的成员可以设置为私有（Private）、公共（Public）或保护（Protected），以控制对成员的访问权限。
6.  构造函数和析构函数：构造函数用于初始化对象的属性，析构函数用于销毁对象和释放资源。这两个函数在类的生命周期中起着非常关键的作用。
7.  操作符重载（Operator Overloading）：可以重载运算符，使其适用于类对象。可以通过操作符重载实现自定义的类型转换和运算。

总之，C++类的特性非常丰富，可以提供很多灵活性和功能性，但是也需要开发者具有一定的设计和实现经验才能发挥出这些特性的优势。

# this #

在C++中，this指针是一个指向当前对象的指针。它是一个隐式的参数，用于成员函数中，以表示当前对象的地址。当一个成员函数被调用时，编译器会在参数列表中自动传递this指针给函数。这样，函数就可以访问对象中的成员变量和成员函数。

使用this指针可以避免命名冲突和歧义，并且可以在成员函数中访问非静态成员变量和成员函数。例如：

class MyClass {
    public:
        void setValue(int value) {
            this->value = value;
        }
        
        int getValue() {
            return this->value;
        }
        
    private:
        int value;
    };
    
    int main() {
        MyClass obj;
        obj.setValue(10);
        cout << obj.getValue() << endl;
        return 0;
    }

在上面的示例中，使用this指针来引用类的成员变量value并设置它的值。在getValue()函数中，使用this指针来访问成员变量value并返回它的值。由于this指针是隐式传递的，因此在调用setValue()和getValue()函数时不需要显式地传递对象指针。

# 类的六个默认成员函数 #

C++类的六个默认成员函数如下：

1.  默认构造函数：当不显式地定义构造函数时，编译器会自动生成一个默认构造函数。
2.  析构函数：同样地，当不显式地定义析构函数时，编译器会自动生成一个默认的析构函数。该函数用于释放对象使用的资源，例如动态分配的内存。
3.  拷贝构造函数：当使用一个对象来初始化另一个对象时，就会调用拷贝构造函数。如果不显式定义拷贝构造函数，编译器会自动生成一个默认的拷贝构造函数。
4.  拷贝赋值运算符：当使用赋值操作符对一个对象进行赋值时，就会调用拷贝赋值运算符。如果不显式定义拷贝赋值运算符，编译器会自动生成一个默认的拷贝赋值运算符。
5.  移动构造函数：C++11引入了一个新的特性——移动构造函数。该函数用于将一个右值引用的对象移动到另一个对象中，以避免不必要的内存拷贝操作。如果不显式定义移动构造函数，编译器会自动生成一个默认的移动构造函数。
6.  移动赋值运算符：类似地，C++11还引入了移动赋值运算符，用于实现右值引用对象的赋值操作。如果不显式定义移动赋值运算符，编译器会自动生成一个默认的移动赋值运算符。

# static成员 #

在C++中，static关键字主要有以下几种用法：

1.  声明静态变量：在函数或类中，使用static关键字声明的变量为静态变量，它的生命周期与程序的生命周期相同，即从程序开始运行到程序结束都存在。静态变量在声明时会被默认初始化为0，其作用域为当前声明它的文件或作用域内。
2.  声明静态函数：在函数前面加上static关键字，表示该函数只能在当前文件或作用域内被调用，无法被其他文件或作用域所访问。静态函数与普通函数的区别在于，静态函数没有this指针，所以无法访问非静态成员变量和非静态成员函数。
3.  声明静态类成员变量：在类的成员变量前面加上static关键字，表示该变量为类的静态成员变量，它的生命周期与程序的生命周期相同，即从程序开始运行到程序结束都存在。静态成员变量在声明时同样会被默认初始化为0，它的作用域为整个类。
4.  声明静态类成员函数：在类的成员函数前面加上static关键字，表示该函数为类的静态成员函数，它只能访问类的静态成员变量和静态成员函数，无法访问非静态成员变量和非静态成员函数。静态成员函数不能使用关键字this。

总之，static关键字可以用来控制变量和函数的作用域和生命周期，而且可以实现数据共享和数据隔离的功能。

# 友元 #

C++友元（friend）是指可以访问类的私有成员的非成员函数或者其他类的成员函数。友元是实现类与类之间通信的方式，可以让需要访问私有成员的函数或类获得更高的访问权限。

在C++中，可以使用以下方式定义友元：

*  将函数声明为类的友元函数，可以在类的内部或外部定义该函数，该函数可以访问类的私有成员。

class MyClass {
        
      private:
        int privateMember;
      public:
        friend void friendFunction(); //声明友元函数
    };
    
    void friendFunction() {
        
      MyClass obj;
      obj.privateMember = 10; //可以访问私有成员
    }

*  将另一个类声明为友元类，可以让该类的所有成员函数都访问当前类的私有成员。

class MyClass {
        
      private:
        int privateMember;
      public:
        friend class FriendClass; //声明友元类
    };
    
    class FriendClass {
        
      public:
        void someFunction() {
        
          MyClass obj;
          obj.privateMember = 10; //可以访问私有成员
        }
    };

# 内部类 #

C++中的内部类是一个定义在另一个类内部的类，与普通类相比，它具有更加灵活的访问权限，并且可以直接访问外围类的成员变量和成员函数。

下面是一个简单的例子：

class OuterClass {
    private:
        int x;
    public:
        class InnerClass {
        public:
            void printX(OuterClass oc) {
                cout << oc.x;
            }
        };
    };
    
    int main() {
        OuterClass oc;
        OuterClass::InnerClass ic;
        ic.printX(oc);  // 输出 oc.x
        return 0;
    }

在这个例子中，`InnerClass` 是 `OuterClass` 的内部类，可以直接访问 `OuterClass` 的私有成员变量 `x`。在 `main` 函数中，我们创建了 `OuterClass` 和 `OuterClass::InnerClass` 的对象 `oc` 和 `ic`，然后通过调用 `ic` 的成员函数 `printX` 来输出 `oc.x` 的值。

需要注意的是，内部类的定义在外部类的声明中，而不是在其实现中。当内部类实现时，它的名称必须是外部类的名称加上内部类的名称，例如 `OuterClass::InnerClass`。

> 今天的分享到这里就结束了，感谢大家的支持  
> ![在这里插入图片描述][9f5e422252f44c5cb7a283156c506dd1.png]

[9f5e422252f44c5cb7a283156c506dd1.png]: https://img-blog.csdnimg.cn/9f5e422252f44c5cb7a283156c506dd1.png