C++中的类、结构体、指针和引用

C++中的类、结构体、指针和引用

习惯上：只有数据的，函数比较少的，和数据相关的定义为结构体，把一些比较复杂的，比较抽象的，含义比较混乱的，比较麻烦的，代码比较长的，打包成class，这样比较方便。

让我们一步步来了解 C++ 中的类与对象吧。

1. 面向过程和面向对象

在介绍类和对象之前，我们先来简单了解一下面向过程和面向对象的概念。

面向过程是指程序的设计者关注于问题的解决过程，通过将问题分解为多个步骤和函数，并将这些步骤按照顺序组合起来实现程序的功能。这种方法的优点是结构清晰、容易理解和调试。但是随着程序的规模增大，面向过程的程序会变得越来越复杂，难以维护和扩展。

而面向对象则是一种更高级别的程序设计方式，它强调将数据和对数据的操作封装起来，形成一个对象。对象既包含数据又包含操作数据的方法，可以直接对外提供服务。这种方法具有高度的灵活性、可重用性和扩展性，易于维护和修改。

2. 类的引入

类就是面向对象编程的基本单位，它通过封装数据和方法来实现对现实世界中事物的建模。在 C++ 中，我们可以使用 class 关键字定义一个类，例如：

class Student {
public:
    int id;
    string name;
    void show() {
        cout << "id: " << id << ", name: " << name << endl;
    }
};
1
2
3
4
5
6
7
8

这个类名为 Student，其中包含了两个成员变量（id 和 name）和一个成员函数（show）。我们可以根据这个类定义多个对象，每个对象都有自己的 id 和 name 属性，并且可以通过调用 show() 函数来展示自己的信息。

3. 类的定义

一个类的定义由以下几个部分组成：

• class 关键字
• 类名，通常使用首字母大写的驼峰命名法（例如 Student）
• 成员变量，可以是任意类型的数据
• 成员函数，用于访问和修改成员变量

在 C++ 中，成员变量和成员函数可以使用访问限定符指定其访问权限。C++ 中的访问限定符有三种：

• public：表示成员在类内外都可以被访问。
• protected：表示成员只能在类内部和子类中被访问。
• private：表示成员只能在类内部被访问。

默认情况下，C++ 中的成员变量和成员函数都是 private 的。

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

class Student {
public:
    int id;
    string name;

    void show() {
        cout << "id: " << id << ", name: " << name << endl;
    }

private:
    int age;
};
1
2
3
4
5
6
7
8
9
10
11
12

在这个示例中，成员变量 id 和 name 是公开的，而 age 则是私有的。show() 函数是公开的，可以在类内外进行调用。

4. 类的访问限定符及封装

以下是一个使用了不同访问限定符的示例：

class Student {
public:
    int id; // 公开成员
    string name;

    void show() { // 公开成员函数
        cout << "id: " << id << ", name: " << name << endl;
    }

protected:
    int score; // 受保护成员

private:
    int age; // 私有成员
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

在这个示例中，id 和 name 是公开成员，可以被任意对象访问。show() 函数也是公开成员函数，可以在类内外进行调用。

score 是受保护成员，只能被子类对象或本类对象访问。

age 是私有成员，只能被本类对象访问。

使用访问限定符来控制成员变量和成员函数的访问权限，可以对数据进行封装，增强程序的安全性和稳定性。

5. 类的作用域

类的作用域是指类定义所处的范围。在 C++ 中，类的作用域分为两种：类内作用域和类外作用域。

类内作用域是指类定义内部的作用域，包括成员变量、成员函数、嵌套类、枚举类型等。在类内定义的成员函数可以直接访问类的成员变量和其他成员函数，无需使用类名或对象名进行限定。

类外作用域是指类定义外部的作用域，也就是类定义所在的命名空间。在类外定义成员函数时，需要使用类名或对象名进行限定。

以下是一个示例：

class Student {
public:
    int id;
    string name;

    void show();

private:
    int age;
};

void Student::show() {
    cout << "id: " << id << ", name: " << name << endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

在这个示例中，show() 函数是在类外定义的，需要使用 Student 类进行限定。

6. 类的实例化

类只是一种抽象的数据类型，需要通过实例化来创建具体的对象。在 C++ 中，可以使用关键字 new 来动态分配内存并实例化一个类对象。

以下是一个示例：

Student *stu = new Student();
stu->id = 123;
stu->name = "Tom";
stu->show();
delete stu;
1
2
3
4
5

在这个示例中，我们使用 new 关键字动态分配内存，并将内存地址赋值给指针 stu。然后可以通过指针访问对象的成员变量和成员函数。最后使用 delete 关键字释放内存，避免内存泄漏。

除了使用 new 关键字进行动态分配对象之外，还可以直接定义对象或使用对象数组来实例化一个类对象：

Student stu1;
stu1.id = 123;
stu1.name = "Tom";
stu1.show();

Student stuArray[10];
for (int i = 0; i < 10; i++) {
    stuArray[i].id = i + 1;
    stuArray[i].name = "Student" + to_string(i + 1);
    stuArray[i].show();
}
1
2
3
4
5
6
7
8
9
10
11

7. 类的对象大小的计算

类的对象大小取决于其成员变量和成员函数的大小。其中，成员变量占用的空间是它们各自的大小之和，而成员函数不占用对象的空间，只是在对象创建时为其分配代码段。

在 C++ 中，使用 sizeof 关键字可以获取一个对象或类型的大小：

cout << sizeof(Student) << endl; // 输出: 16
1

8. 类成员函数的 this 指针

类成员函数可以访问类的成员变量和其他成员函数，但是需要使用 this 指针来指向当前对象。this 指针是一个类成员函数可以访问类的成员变量和其他成员函数，但是需要使用 this 指针来指向当前对象。this 指针是一个隐含的参数，在调用成员函数时会自动传递给函数。

以下是一个使用 this 指针的示例：

class Student {
public:
    int id;
    string name;

    void show() {
        cout << "id: " << this->id << ", name: " << this->name << endl;
    }
};

int main() {
    Student stu;
    stu.id = 123;
    stu.name = "Tom";
    stu.show();
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

在这个示例中，show() 函数使用 this 指针来访问 id 和 name 成员变量，其中 this 指向当前的 stu 对象。

需要注意的是，this 指针是一个指向当前对象的常量指针，不能被修改。因此，不能在成员函数中对 this 进行赋值操作。

---

9.如何在类外部实现成员函数

当你需要在类的外部实现一个类函数时，需要进行声明和定义。具体步骤如下：

1. 在类的定义中声明该函数：通常将函数声明放在类的公共接口（public）中，以便其他代码可以调用该函数。在声明时，需要使用类名来指明该函数是该类的成员函数，并在函数名称后加上圆括号和分号，例如：

class Example {
public:
    void printValue();  // 声明printValue函数
};
1
2
3
4

2. 在类的外部进行定义和实现：定义和实现类函数时，需要使用作用域解析运算符::来指明函数所属的类。同时，不需要再加上关键字inline或static。例如：

void Example::printValue() {
    std::cout << "Hello World!" << std::endl;
}
1
2
3

3. 包含相关的头文件：如果你要在类的外部使用该类，需要包含相关的头文件，例如：

#include "Example.h"  // 包含Example类的头文件

int main() {
    Example ex;
    ex.printValue();   // 调用Example类中的printValue函数
    return 0;
}
1
2
3
4
5
6
7

总之，在类的外部定义和实现类函数时，需要注意使用作用域解析运算符::来指明函数所属的类，并且不需要再加上关键字inline或static。此外，如果要在类的外部使用该类，需要包含相关的头文件。

---

一道开胃菜一把梭

点和圆的关系

有圆类（Circle）和点类（Pointer），请在圆类中实现一个 isPointerInCircle方法，该方法传入一个点类对象，判断点和圆的关系，并在该方法中输出。

点类（Pointer）:
成员变量：x轴坐标（int x） y轴坐标（int y）
成员方法：成员变量的公共访问方法
圆类（Circle）:
成员变量：圆心（Point center） 半径（int radius）
成员方法：成员变量的公共访问方法 判断点和圆关系的方法（isPointerInCircle）

点和圆的关系：
1.点在圆外
2.点在圆上
3.点在圆内

输入描述

键盘输入两个整数，分别是点的 x 坐标和 y 坐标（圆的参数已经给定）

输出描述：

圆类中实现 isPointInCircle 方法，在该方法中输出点和圆的关系，

如果点在圆外，则输出“out”；

如果点在圆上，则输出“on”；

如果点在圆内，则输出“in”。

#include 
using namespace std;

// 点类
class Pointer {

    private:
        int x;  // x 坐标
        int y;  // y 坐标

    public:
        void setX(int x) {
            this->x = x;
        }

        int getX() {
            return x;
        }

        void setY(int y) {
            this->y = y;
        }

        int getY() {
            return y;
        }

};

// 圆类
class Circle {

    private:  //变量私有化
        Pointer center; // 圆心
        int radius; // 半径

    public:
        void setCenter(int x, int y) {
            center.setX(x);
            center.setY(y);
        }

        void setRadius(int radius) {
            this->radius = radius;
        }
       
        void isPointerInCircle(Pointer p)
        {  // 公共函数
              if(((p.getX()-5)*(p.getX()-5)+p.getY()*p.getY())>25)
              {
                  cout<<"out";
              }
              else if(((p.getX()-5)*(p.getX()-5)+p.getY()*p.getY())==25)
              {
                           cout<<"on";
              }
              else{
                 cout<<"in";
              }
        }
        // write your code here......
        

};

int main() {

    // 键盘输入点的坐标
    int x, y;
    cin >> x;
    cin >> y;

    // 创建一个点
    Pointer p;
    p.setX(x);
    p.setY(y);

    // 创建一个圆
    Circle c;
    c.setCenter(5, 0);
    c.setRadius(5);

    // 判断点和圆的关系
    c.isPointerInCircle(p);

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

面向对象之时间类

#include
using namespace std;
class Time
{
    private:
        int h;
        int m;
        int s;
    public:
        int set(int s)
        {
            this->h=s/3600;
            this->m=(s-this->h*3600)/60;
            this->s=s%60; 
            return 0;
        }
        int display()
        {
            cout<h<<":"<m<<":"<s<>n;
    time.set(n);
    time.display();
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

类和对象（中篇）

好的，让我们逐一来看类与对象中的这些内容。

类的6个默认成员函数

在 C++ 中，每个类都有6个默认成员函数，如果没有显式定义它们，编译器会自动生成它们。这6个函数包括：

• 默认构造函数（Default Constructor）：如果一个类没有定义任何构造函数，则编译器会提供一个默认的构造函数。默认构造函数不接受任何参数，其作用是初始化对象的数据成员。

• 析构函数（Destructor）：析构函数与构造函数相反，当对象销毁时，析构函数被调用。析构函数的作用是释放对象占用的资源，例如动态分配的内存或打开的文件等。

• 拷贝构造函数（Copy Constructor）：拷贝构造函数用于将一个对象的值复制到另一个对象中，例如通过值传递方式传递对象或者在函数返回对象时使用。拷贝构造函数的参数为同类对象的常引用。

• 移动构造函数（Move Constructor）：移动构造函数用于将一个对象的资源转移到另一个对象中，例如在容器类中进行元素的插入和移动时，可以利用移动构造函数提高效率。

• 赋值运算符重载函数（Copy Assignment Operator）：赋值运算符重载函数用于将一个对象赋值给另一个对象，例如 a = b，其中 a 和 b 是同类对象。赋值运算符重载函数的参数为同类对象的常引用。

• 移动赋值运算符重载函数（Move Assignment Operator）：移动赋值运算符重载函数用于将一个对象的资源转移到另一个对象中，例如 a = std::move(b)，其中 a 和 b 是同类对象。移动赋值运算符重载函数的参数为同类对象的右值引用。

  构造函数

构造函数是一种特殊的成员函数，它在创建对象时被调用，用于初始化对象的数据成员。构造函数与类同名，没有返回值类型，并且可以有多个重载的版本。例如：

class Person {
public:
    Person(); // 默认构造函数
    Person(const char* name, int age); // 带参数的构造函数
};
1
2
3
4
5

默认构造函数不接受任何参数，其作用是初始化对象的数据成员。带参数的构造函数可以接受初始化参数，在创建对象时将这些参数传递给构造函数，然后进行初始化操作。

构造函数的有参构造

#include 
#include 

using namespace std;

// Person类
class Person {
    public:
        string name;    // 姓名
        int age;    // 年龄
       Person(string name,int age)
       {
           this->name  = name;
           this->age = age;
       }
        // write your code here......
        

        void showPerson() {
            cout << name << " " << age << endl;
        }
};

int main() {

    string name;
    int age;

    cin >> name;
    cin >> age;

    Person p(name, age);
    p.showPerson();

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

构造函数调用规则

默认情况下，C++编译器默认给类添加3个函数

1.默认无参构造（无参）

2.默认析构函数（无参）

3.拷贝构造函数（有参）

案例演示

1. 默认无参构造函数

class Person {
public:
    Person() { // 默认的无参构造函数
        name = "";
        age = 0;
    }
private:
    std::string name;
    int age;
};
1
2
3
4
5
6
7
8
9
10

在上面的代码中，我们定义了一个Person类，并使用默认的无参构造函数来初始化其成员变量。

2. 默认析构函数

class Person {
public:
    ~Person() { // 默认的析构函数
        std::cout << "Object destroyed." << std::endl;
    }
private:
    std::string name;
    int age;
};
1
2
3
4
5
6
7
8
9

在上面的代码中，我们定义了一个Person类，并使用默认的析构函数来释放该对象所占用的内存。当一个Person对象被销毁时，会自动调用该对象的析构函数。

3. 默认拷贝构造函数

class Person {
public:
    Person(const Person& other) { // 默认的拷贝构造函数
        name = other.name;
        age = other.age;
    }
private:
    std::string name;
    int age;
};
1
2
3
4
5
6
7
8
9
10

在上面的代码中，我们定义了一个Person类，并使用默认的拷贝构造函数来创建新的Person对象。当我们将一个Person对象赋值给另一个Person对象时，会自动调用该对象的拷贝构造函数。

---

析构函数

析构函数与构造函数相反，当对象销毁时，析构函数被调用。析构函数的作用是释放对象占用的资源，例如动态分配的内存或打开的文件等。析构函数与类同名，但前面加上了波浪号（~），例如：

class Person {
public:
    ~Person(); // 析构函数
};
1
2
3
4

拷贝构造函数

拷贝构造函数用于将一个对象的值复制到另一个对象中，例如通过值传递方式传递对象或者在函数返回对象时使用。拷贝构造函数的参数为同类对象的常引用，并且通常采用浅拷贝（即直接复制指针）的方式来实现。例如：

class Person {
public:
    Person(const Person& p); // 拷贝构造函数
};
1
2
3
4

如果不显式定义拷贝构造函数，则编译器会自动生成一个默认的拷贝构造函数。默认拷贝构造函数会对对象进行逐一复制，包括所有数据成员和成员变量。

CPP 62 数组类的拷贝构造函数

#include
using namespace std;
class Array{
	private:
		int n;//数组大小 
		int *a;//数组 
	public:
		Array(){
			cin>>n;
			a=new int [n];
			for (int i=0;i>a[i];
		}
		~Array(){
			delete []a;
		}
		int getlen(){
			return n;
		}
		int get(int i){
			return a[i];
		}
		// write your code here......
        
		void show(){
			for (int i=0;i

class Person{
     private:
      int age;
      string name;
      public:
      // 该处使用了初始化列表
     Person(int _AGE,string NAME):age(_AGE),name(NAME){
         
     }
    
    
}
1
2
3
4
5
6
7
8
9
10
11
12

class Person {
public:
    Person& operator=(const Person& p); // 赋值运算符重载函数
};
1
2
3
4

class Person {
public:
    void PrintName() const; // const 成员函数
};
1
2
3
4

class Person {
public:
    int age;
    const int* operator&() const; // const 取地址操作符重载函数
    int* operator&(); // 非 const 取地址操作符重载函数
};

const int* Person::operator&() const {
    return &age;
}

int* Person::operator&() {
    return &age;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14