臻于巅峰：C++高阶编程之路

最新推荐文章于 2023-10-30 18:40:19 发布
最新推荐文章于 2023-10-30 18:40:19 发布
阅读量113 收藏
点赞数
分类专栏： 代码绽放：探索C++的奇妙世界与技艺传承 文章标签： c++ 开发语言 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qwsbcjendb/article/details/131872052
版权

类的高级主题

1. 深复制与浅复制

1.1 浅复制

浅复制是指将对象的值直接拷贝给新对象，这样新对象和原对象会共享同一个内存地址。当其中一个对象修改了共享的数据时，另一个对象也会受到影响。

【例1-1】使用默认的拷贝构造函数进行浅复制：

#include <iostream>
using namespace std;
class Person 
{
public:
    Person() 
    {
        name = "";
        age = 0;
    }    
    Person(string n, int a) 
    {
        name = n;
        age = a;
    }    
    void display() 
    {
        cout << "Name: " << name << ", Age: " << age << endl;
    }    
private:
    string name;
    int age;
};
int main() 
{
    Person p1("Alice", 20);
    Person p2 = p1;  // 浅复制    
    p1.display();  // 输出：Name: Alice, Age: 20
    p2.display();  // 输出：Name: Alice, Age: 20    
    // 修改p1的值
    p1.name = "Bob";
    p1.age = 25;    
    p1.display();  // 输出Name: Bob, Age: 25
    p2.display();  // 输出：Name: Bob, Age: 25，受到影响    
    return 0;
}

1.2 深复制

深复制是指创建一个新对象，并将原对象的值拷贝给新对象，新对象拥有属于自己的内存空间。这样，当其中一个对象修改自己的数据时，另一个对象不会受到影响。

【例11-2】使用拷贝构造函数实现深复制：

#include <iostream>
using namespace std;
class Person 
{
public:
    Person() 
    {
        name = "";
        age = 0;
    }    
    Person(string n, int a) 
    {
        name = n;
        age = a;
    }    
    Person(const Person& p) {  // 拷贝构造函数
        name = p.name;
        age = p.age;
    }    
    void display() 
    {
        cout << "Name: " << name << ", Age: " << age << endl;
    }    
private:
    string name;
    int age;
};
int main() 
{
    Person p1("Alice", 20);
    Person p2 = p1;  // 深复制
    
    p1.display();  // 输出：Name: Alice, Age: 20
    p2.display();  // 输出：Name: Alice, Age: 20
    
    // 修改p1的值
    p1.name = "Bob";
    p1.age = 25;
    p1.display();  // 输出：Name: Bob, Age: 25
    p2.display();  // 输出：Name: Alice, Age: 20，不影响
    
    return 0;
}

2. 类的组合

2.1 什么是类的组合

类的组合是指一个类中包含另一个类的对象作为其成员变量。通过组合，一个类可以同时包含多个其他类的功能。

【例1-3】类的组合：

#include <iostream>
using namespace std;
class Engine 
{
public:
    void start() 
    {
        cout << "Engine started" << endl;
    }
};

class Car {
public:
    Car() {
        // 在Car的构造函数中创建Engine对象
        engine = new Engine();
    }
    
    ~Car() {
        // 在Car的析构函数中释放Engine对象的内存
        delete engine;
    }
    
 void startCar() {
        engine->start();
    }
    
private:
    Engine* engine;
};

int main() {
    Car myCar;
    myCar.startCar();  // 输出：Engine started
    
    return 0;
}

2.2 组合类的构造过程

在组合关系中，当一个类对象被创建时，它的成员对象也会被创建。
【例1-4】三角形类：

#include <iostream>
using namespace std;

class Point {
public:
    Point() {
        x = 0;
        y = 0;
    }
    
    Point(int a, int b) {
        x = a;
        y = b;
    }
    
    void display() {
        cout << "Point: (" << x << ", " << y << ")" << endl;
    }
    
private:
    int x;
    int y;
};

class Triangle {
public:
    Triangle() {
        // 构造三个点对象
        p1 = Point(0, 0);
        p2 = Point(0, 0);
        p3 = Point(0, 0);
    }
    
    Triangle(Point a, Point b, Point c) {
        // 使用传入的点对象构造三角形
        p1 = a;
        p2 = b;
        p3 = c;
    }
    
    void display() {
        cout << "Triangle has 3 points:" << endl;
        p1.display();
        p2.display();
        p3.display();
    }
    
private:
    Point p1;
    Point p2;
    Point p3;
};

int main() {
    Point a(1, 2);
    Point b(3, 4);
    Point c(5, 6);
    
    Triangle t1;  // 默认构造函数
    Triangle t2(a, b, c);  // 自定义构造函数
    
    t1.display();  // 输出：Point: (0, 0)  Point: (0, 0)  Point: (0, 0)
    t2.display();  // 输出：Point: (1, 2)  Point: (3, 4)  Point: (5, 6)
    
    return 0;
}

3. 友元

友元是C++中的一种特殊关系，允许一个类或函数访问另一个类的私有成员。本节将介绍友元函数和友元类的使用。

3.1 友元函数

友元函数是指在一个类中声明的非成员函数，该函数可以访问该类的私有成员。友元函数可以在类的声明中以关键字 friend 进行声明。

【例1-5】求两点之间的距离
下面是一个实例，演示了如何使用友元函数求两点之间的距离：

#include <iostream>
#include <cmath>

class Point {
private:
    int x;
    int y;

public:
    Point(int a, int b) {
 x = a;
        y = b;
    }

    friend float distance(Point p1, Point p2);
};

float distance(Point p1, Point p) {
    int dx =1.x - p2.x;
    int dy = p1.y - p2.y;
    return sqrt(dx*dx + dy*dy);
}

int main() {
    Point1(3, 4);
    Point p2(1, 2);
    float dist = distance(p1, p2);
    std::cout << "Distance between p1 and p2 is " << dist << std::endl;
    return 0;
}

在上面的例子中，我们定义了一个Point类，其中包含了两个私有成员变量x和y。然后，我们声明了一个友元函数distance，使其能够访问Point类的私有成员。在main函数中创建了两个Point对象1和p2，并通过调用友元函数distance计算出了两点之间的距离。

3.2 友元类

友元类是指能够访问另一个类的私有成员的类。我们可以在类的声明中使用关键字 friend 来声明友元类
【例1-6】友元类的使用
下面是一个示例，演示了如何使用友元：

#include <iostream>

class A {
private:
    int x;

public:
    A(int a) {
        x = a;
    }

    friend class B;
};

class Bprivate:
    int y;

public:
    B(int b) {
        y = b;
    }

    void showA(A a) {
        std::cout << "A's member x is " << a.x << std::endl;
    }
};

int main() {
    A a(10);
    B b(20);
    b.showA(a);
    return 0;
}

在上面的例子中，类A和类B互为友元关系。在类A中，我们声明了类B为友元类，以使其能够访问A的私有成员变量x。类B中的showA函数接受一个A类对象作为参数，并输出A的私有成员x的值。

在main函数中，我们创建了一个A类对象a和一个B类对象b。然后，通过调用b的showA函数，将a传递给它，从而显示了A类的私有成员x的值。

4. 静态成员

4.1 静态数据成员

【例1-7】使用静态数据成员

静态数据成员是类的数据成员，与类的实例对象无关，属于整个类的共享成员。它可以在类定义内部声明为静态成员，然后在类定义外部初始化。通常用于保存所有实例共享的数据。
【例1-7】使用静态数据成员
示例代码如下：

#include <iostream>

class MyClass {
public:
    static int data; // 声明静态数据成员

    MyClass() {
        data++; // 在构造函数中修改静态数据成员的值
    }
};

int MyClass::data = 0; // 静态数据成员的初始化

int main() {
    MyClass obj1; // 创建第一个实例对象
    MyClass obj2; // 创建第二个实例对象

    std::cout << "data: " << MyClass::data << std::endl; // 输出静态数据成员的值

    return 0;
}

上述代码中，我们定义了一个名为MyClass的类，其中包含一个静态数据成员data。在类定义外部，我们对data进行了初始化。

在main函数中，我们创建了两个MyClass的实例对象obj1和obj2。这两个对象共享静态数据成员data。在每个对象的构造函数中，我们对data进行了自增操作。
最后，我们输出了data的值，结果为2，表示两个对象共享了相同的静态数据成员。

4.2 静态成员函数

【例1-8】在Student类中添加静态成员函数

静态成员函数是不依赖于类的实例对象，可以直接通过类名调的成员函数。它不能访问非静态的数据成员和员函数，只能访问静态数据成员和静态成员函数。
【例1-8】在Student类中添加静态成员函数
示例代码如下：

#include <iostream>

class Student {
private:
    static int count; // 静态数据成员

public:
    static void increaseCount() { // 静态成员函数
        count++; // 访问静态数据成员
    }

    static int getCount() {
        return count;
    }
};

int Student::count = 0; // 静态数据成员的初始化

int main() {
    Student::increaseCount(); // 调用静态成员函数
    Student::increaseCount();

    std::cout <<count: " << Student::getCount() << std::endl; // 输出静态数据成员的值

    return 0;
}

上代码中，我们定义了一个名为Student的类，其中包含一个静态数据成员count和两个静态成员函数increaseCount和getCount。
在main函数中，我们通过类名直接调用了increaseCount函数两次，对count进行了两次自增操作。然后，我们调用了getCount函数输出count的值，结果为2。

总结:

  • 静态数据成员是类的共享数据，对于所有实例对象而言，它们拥有相同的值；
  • 静态成员函数是不依赖于实例对象，可以通过类名直接调用的函数。它们只能访问静态数据成员和静态成员函数；
  • 静态成员的声明和初始化需在类的定义外部进行。

5. 常对象与常成员函数

常对象是指在创建对象后，将对象标记为常量，即不允许通过该对象来修改其成员变量的值。常对象的成员函数也被限制为只能调用常成员函数。

5.1 常对象

【例1-9】常对象调用普通成员函数产生的错误

#include<iostream>
using namespace std;

class MyClass {
public:
    int myVar;
    MyClass() { myVar = 0; }
    void modifyVar() { myVar = 10; }
};

int main() {
    const MyClass obj; // 创建一个常对象
    obj.modifyVar(); // 错误，常对象不能用普通成员函数
    cout << obj.myVar << endl; // 正确，常对象可以读取成员变量的值
    return 0;
}

运行结果：

error: member function 'void MyClass::modifyVar()' is declared const here
     void modifyVar() { myVar = 10; }
                               ^

在上述例子中，我们创建了一个常对象 obj，并尝试调用普通成员函数 modifyVar() 。然而，编译器会报错，因为常对象不能调用普通成员函数，只能读取成员变量的值。

5.2 常成员函数
【例11-10】使用常成员函数

#include<iostream>
using namespace std;

class Circle {
private:
    double radius;
public:
    Circle(double r) { radius = r; }
    double getArea() const { return 3.14 * radius * radius; }
};

int main() {
    Circle c(5);
    cout << "Area of circle: " << c.getArea() << endl; // 调用常成员函数获取圆的面积
    return 0;
}

运行结果：

Area of circle: 78.5

在上述例子中，我们定义了一个 Circle 类，其中的 getArea() 函数被声明为常成员函数。这意味着在该函数内部不会修改任何成员变量的值。在主函数中，我们创建了一个 Circle 对象 c，并通过调用常成员函数 getArea() 获取圆的面积，并将结果输出。

6. 对象数组与对象指针

6.1 对象数组

对象数组是一个由多个相同类型的对象组成的数组。当创建对象数组时，会按照声明顺序自动调用每对象的构造函数进行初始化。

【例1-11】对象数组的应用

#include<iostream>
using namespace std;

class Point {
public:
    int x, y;
    Point() { x = 0; y = 0; }
    void display() { cout << "(" << x << ", " << y << ")" << endl; }
};

int main() {
    Point points[3]; // 创建一个 Point 类型的对象数组
    for (int i = 0; i < 3; i++) {
        points[i].x = i + 1;
        points[i].y = i + 1;
        points[i].display();
    }
    return 0;
}

运行结果：

(1, 1)
(2, 2)
(3, 3)

在上述例子中，我们创建了一个 Point 类型的对象数组 points，包含了三个 Point 对象。然后，通过循环为每个对象的成员变量赋值，并调用 display() 函数显示每个对象的坐标。

6.2 对象指针

对象指针是指对象的指针变量。通过对象指针，我们可以访问对象的成员变量和成员函数。
【例1-12】使用对象指针

#include<iostream>
using namespace std;

class Rectangle {
public:
    int width, height;
    Rectangle() { width = 0; height = 0; }
    void setDimensions(int w, int h) { width = w; height = h; }
    int getArea() { return width * height; }
};

int main() {
    Rectangle rect; // 创建一个 Rectangle 对象
    Rectangle* ptr = &rect; // 创建一个指向 Rectangle 对象的指针
    ptr->setDimensions(5, 4); // 使用指针调用对象的成员函数
    cout << "Area of rectangle: " << ptr->getArea() << endl; // 使用指针访问对象的成员变量
    return 0;
}

运行结果：

Area of rectangle: 20

在上述例子中，我们创建了一个 Rectangle 对象 rect，并创建了一个指向该对象的指针 ptr。通过指针 ptr，我们可以调用对象的成员函数 setDimensions() ，并访问对象的成员变量 width 和 height。在主函数中，我们使用指针 ptr 分别设置矩形的宽度和高度，并通过指针访问对象的成员变量计算矩形的面积。

无敌泡泡糖
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
手撕哈希表（HashTable）——C++高阶数据结构详解
qq_61500888的博客
10-02 8528
带你一命通关哈希表（散列表） 十分钟手撕数据结构原理
项目：俄罗斯方块；编程语言：c++
最新发布
03-17
编程语言：c++项目：俄项目资源具有较高的学习借鉴价值，也可直接拿来修改复现。可以在这些基础上学习借鉴进行修改和扩展，实现其它功能。可下载学习借鉴，你会有所收获。 源码是经过本地编译可运行的，下载完成之后...
＜二叉搜索树＞——《C++高阶》
m0_57859086的博客
08-11 598
＜二叉搜索树＞——《C++高阶》
＜C++的IO流＞——《C++高阶》
m0_57859086的博客
10-12 1399
学习C++中的IO流相关知识。
C++高阶必会操作--模板元编程
kxtxdy的博客
05-09 5086
泛型编程大家应该都很熟悉了，主要就是利用模板实现“安全的宏”，而模板元编程区别于我们所知道的泛型编程，它是一种较为复杂的模板，属于C++的高阶操作了，它最主要的优点就在于把计算过程提前到编译期，能带来可观的性能提升。接下来，一起来学习吧。 1、概述 模板元编程（Template Meta programming，TMP）是编写生成或操纵程序的程序，也是一种复杂且功能强大的编程范式（Programming Paradigm）。 C++模板给C++提供了元编程的能力，但大部分用户对 C++ 模板的使用并不
C++编程：函数高阶
zjjcchina的博客
06-13 80
定义内联函数，只需要在函数声明或者函数定义前加上inline关键字。例如之前写过的函数：比较两个字符串、并返回较长的那个，就可以重写为内联函数：当我们试图打印输出调用结果时：编译器会自动把它展开为：这样就大大提高了运行效率。
c++高阶语法（一）
m0_63932570的博客
05-17 731
一）内联函数inline。解决函数调用的效率问题，在函数声明前加上inline即可，
C++新经典 | 记录在最后的高阶知识点
该用户还没想到好的昵称的博客
10-30 273
std::function、std::bind、万能引用、std::future、std::move、auto、decltype及lambda表达式
C++高阶函数
u010099495的专栏
03-03 3415
在C++中，我们可以借助于函数对象、函数指针以及lambda表达式来实现高阶函数。
c++高阶语法（三）
m0_63932570的博客
05-22 513
今天，我们来分享c++语法中的关键字，在c++学习中，关键字有很多，如const，static，enum等等。 下面是c++语法中的全部关键字（好像是73个） 大部分在基础语法学习中的已经见过了，现在我们来看看几个不常见又有时候起关键作用的关键字吧。 1.char、wchar_t 表示字符型和宽字符型这些整数类型（属于基本类型），但一般只专用于表示字符。char（和signed char、unsigned char一起）事实上定义了字节的大小。char表示单字节字符，wchar_t表示多字节字符
＜模板进阶＞——《C++高阶》
m0_57859086的博客
08-08 364
＜模板进阶＞——《C++高阶》 ——By 作者：新晓·故知
C++的未来之路：C++0x概览
02-27
C++0x的工作已经进入了一个决定性的阶段。...　指导原则　C++是一门偏向于系统编程的通用编程语言。　·是一个更好的C　·支持数据抽象　·支持面向对象编程　·支持泛型编程　当我说“系统编程”时，我是指传统上与操
C++高性能编程之proactor模式代码示例
04-01
C++高性能并发编程之proactor模式应用实例，应用于网络编程领域，包含一下几个部分： 1 服务器端程序：一个server代码展示如何使用现代C++11编程高并发代码，一个Makefile文件 2 客户端程序：一个客户端代码展示如何...
C++游戏编程:创建3D游戏依赖库
09-02
C++游戏编程:创建3D游戏依赖库 C++游戏编程:创建3D游戏依赖库 C++游戏编程:创建3D游戏依赖库
C++ 模板元编程简介
Dablelv 的博客专栏。
09-17 2153
1.概述 模板元编程（Template Metaprogramming，TMP）是编写生成或操纵程序的程序，也是一种复杂且功能强大的编程范式（Programming Paradigm）。C++模板给C++提供了元编程的能力，但大部分用户对 C++ 模板的使用并不是很频繁，大致限于泛型编程，在一些系统级的代码，尤其是对通用性、性能要求极高的基础库（如 STL、Boost）几乎不可避免在大量地使用 C...
【C++】模板和STL库
晚安的博客
02-07 671
本文是我在学习C++过程当中的心得和学习笔记，在学习C++时已经有C语言的基础。文章包含了C++的高阶内容，并附上了学习的代码，仅供大家参考。如果有问题，有错误欢迎大家留言。
c++高阶语法（四）
m0_63932570的博客
05-22 238
今天，我们来分享一个c++的高阶语法——嵌套类。 嵌套类是它所在封装类的一个成员。非静态嵌套类（内部类）可以访问封装类的其他成员，包括声明为private的成员。静态嵌套类不能访问该风状态的其他成员。作为外部类的一个成员，一个嵌套类可以被声明为private，public，protected或者package private。 为什么使用嵌套类？ 使用嵌套类的主要原因：它将仅在一个地方使用的逻辑类组合在一块。如果一个类仅在另外一个类中使用，那么，前者在逻辑上绑定到后者上使得两者在一块。像帮助类的嵌套使
c++高阶语法（二）
m0_63932570的博客
05-21 245
今天，我们来看看c++中的高阶语法——匿名函数Lambda函数，也叫Lambda表达式。下面我们一一来看看这个Lambda函数吧。 1.匿名函数就是没有名字的函数。有一些函数只是临时用一下，而且业务逻辑也比较的简单，相当于是临时工，就没必要给它定义成一个正常函数（包含有函数名，很正式的那种）。使用临时的匿名函数，可以减轻函数的数量，让代码变的清晰易读。 2.Lambda表达式具体形式如下:[capture](parameters)->return-type{body} 如：[](int x, i
如何成为一个C++高级程序员(转帖)
weixin_30478923的博客
11-23 323
忘记在哪看的这篇文章了，觉得还可以 mark一下 原文如下: C++这门语言从诞生到今天已经经历了将近30个年头。不可否认，它的学习难度都比其它语言较高。而它的学习难度，主要来自于它的复杂性。现在C++的使用范围比以前已经少了很多，java、C#、python等语言在很多方面已经可以代替C++。但是也有很多地方是其他语言完全无法替代的，主要集中在需要运行效率比较高的行业，比如游戏、高效的服务器...
c++ 高阶函数
05-25
在 C++ 中，函数也可以作为参数传递给另一个函数，这种函数称为高阶函数。高阶函数允许我们编写更加灵活且可重用的代码。 以下是一个简单的示例，其中 `map` 函数接受一个函数和一个数组，并返回一个新数组，其中每个元素都是原数组元素应用给定函数后的结果： ```c++ #include <iostream> #include <vector> #include <algorithm> using namespace std; // 定义一个高阶函数 map template<typename T, typename Func> vector<T> map(vector<T> v, Func f) { vector<T> result; result.reserve(v.size()); transform(v.begin(), v.end(), back_inserter(result), f); return result; } int main() { vector<int> v = {1, 2, 3, 4, 5}; // 将每个元素都乘以 2 auto doubled = map(v, [](int x) { return x * 2; }); for (auto i : doubled) { cout << i << " "; } cout << endl; return 0; } ``` 输出： ``` 2 4 6 8 10 ``` 在上面的示例中，我们定义了一个 `map` 函数，它接受一个 `vector` 和一个函数对象 `f`，然后使用 `transform` 算法将 `f` 应用于输入 `vector` 的每个元素，并将结果存储在新的 `vector` 中返回。在 `main` 函数中，我们使用 `map` 函数将 `v` 中的每个元素都乘以 2，并将结果存储在 `doubled` 中，最后输出 `doubled` 中的元素。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

无敌泡泡糖

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

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

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

打赏作者

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

抵扣说明：

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

余额充值