GESP四级 - 第二章 - 第1节 -指针与函数参数传递

天秀信奥编程培训

已于 2024-05-30 14:59:06 修改

阅读量364

点赞数 3

分类专栏： # GESP四级课件文章标签： c++ GESP四级

于 2024-05-26 15:58:02 首次发布

本文链接：https://blog.csdn.net/m0_46192147/article/details/139214380

版权

GESP四级课件专栏收录该内容

9 篇文章 0 订阅

订阅专栏

指针与函数参数传递

一、指针

1.1 指针的概念

指针是C++中的一种复合数据类型,它用于存储变量的内存地址。指针变量的值是它所指向的变量或对象的内存地址。通过指针,我们可以间接访问内存中的数据。

1.指针的特点:

指针变量存储的是内存地址,而不是具体的数据值。
指针变量的类型取决于它所指向的数据类型。
指针变量占用的内存空间大小与所在的操作系统和编译器有关,通常为4字节(32位系统)或8字节(64位系统)。
指针可以进行算术运算,如加减运算,以便访问内存中相邻的元素。

2.指针的应用:

动态内存分配:使用指针来分配和管理堆上的内存空间。
访问数组元素:数组名本身就是一个指向数组首元素的指针。
传递函数参数:通过指针,可以在函数间传递变量的地址,实现对原始数据的修改。
构建复杂的数据结构:如链表、树等,指针用于连接不同的数据节点。

理解指针的概念对于学习C++至关重要,因为指针在内存管理、数据结构和算法设计中扮演着重要的角色。同时,指针也是C++中较为复杂和容易出错的部分,需要谨慎使用。

1.2 指针的声明与初始化

在C++中,指针变量的声明和初始化方式如下:

声明指针变量:

数据类型 *指针变量名;

例如:

int *p; // 声明一个指向整型的指针变量p

初始化指针变量:

将指针变量初始化为nullptr(C++11引入)或NULL(C++11之前),表示指针不指向任何有效的内存地址。

int *p = nullptr; // C++11及以后版本
int *p = NULL;    // C++11之前版本

将指针变量初始化为某个变量的地址,使用取地址运算符(&)。

int num = 10;
int *p = &num; // 指针p指向变量num的地址

将指针变量初始化为另一个指针变量的值。

int num = 10;
int *p1 = &num;
int *p2 = p1; // 指针p2和p1指向同一个地址

注意事项:

指针变量声明时,星号(*)要紧挨着数据类型,中间可以有空格。
指针变量在使用之前必须初始化,否则会导致未定义的行为。
在C++中,最好使用nullptr来初始化空指针,而不是NULL。
在指针赋值时,要确保左侧指针类型与右侧指针类型一致,或者右侧指针类型可以隐式转换为左侧指针类型。

下面是一个完整的例子:

#include <iostream>

using namespace std;

int main() {
    int num = 42;
    int *p1 = &num;  // 指针p1指向变量num的地址
    int *p2 = nullptr;  // 指针p2初始化为空指针

    cout << "p1 points to: " << *p1 << endl;  // 输出p1指向的值
    
    p2 = p1;  // 将p1的值赋给p2,现在p2也指向num的地址
    cout << "p2 points to: " << *p2 << endl;  // 输出p2指向的值

    return 0;
}

输出结果:

p1 points to: 42
p2 points to: 42

正确地声明和初始化指针变量是使用指针的基础,这有助于避免许多常见的指针错误。

1.3 指针的算术运算

指针支持几种算术运算,通过这些运算,我们可以方便地访问内存中的数据。指针的算术运算包括:

指针加减整数
指针可以加上或减去一个整数,结果是一个新的指针,指向原指针位置前面或后面的某个元素。指针移动的距离取决于指针类型所指向的数据类型的大小。

int arr[] = {10, 20, 30, 40, 50};
int *p = arr;  // 指针p指向数组arr的首元素

cout << "*p = " << *p << endl;  // 输出10
p = p + 2;  // 指针p向后移动两个int类型的距离
cout << "*p = " << *p << endl;  // 输出30

指针减指针
两个指针相减的结果是一个整数,表示这两个指针在内存中的距离,即它们之间的元素个数。这两个指针必须指向同一个数组或内存块。

int arr[] = {10, 20, 30, 40, 50};
int *p1 = &arr[1];  // 指针p1指向数组arr的第二个元素
int *p2 = &arr[4];  // 指针p2指向数组arr的最后一个元素

cout << "p2 - p1 = " << p2 - p1 << endl;  // 输出3

指针自增自减
指针可以使用自增(++)或自减(--)运算符,使指针向前或向后移动一个元素的距离。

int arr[] = {10, 20, 30, 40, 50};
int *p = arr;  // 指针p指向数组arr的首元素

cout << "*p = " << *p << endl;  // 输出10
p++;  // 指针p向后移动一个int类型的距离
cout << "*p = " << *p << endl;  // 输出20

注意事项:

指针的算术运算结果必须指向有效的内存区域,否则会导致未定义的行为。
对空指针(nullptr或NULL)进行算术运算是未定义的行为。
不同类型的指针之间不能直接进行算术运算,必须先进行类型转换。

下面是一个完整的例子:

#include <iostream>

using namespace std;

int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int *p1 = arr;  // 指针p1指向数组arr的首元素
    int *p2 = &arr[4];  // 指针p2指向数组arr的最后一个元素

    cout << "p2 - p1 = " << p2 - p1 << endl;  // 输出4

    while (p1 != p2) {
        cout << "*p1 = " << *p1 << endl;
        p1++;
    }
    cout << "*p1 = " << *p1 << endl;

    return 0;
}

输出结果:

p2 - p1 = 4
*p1 = 10
*p1 = 20
*p1 = 30
*p1 = 40
*p1 = 50

指针的算术运算是C++中指针的重要特性,它提供了一种高效、灵活的方式来访问和操作内存中的数据。理解并掌握指针的算术运算对于编写高效的C++程序非常重要。

1.4 指针与数组

在C++中,指针和数组有着密切的关系。事实上,数组名在大多数情况下会自动转换为指向数组首元素的指针。指针可以用来访问和操作数组元素,使得数组操作更加灵活和高效。

数组名作为指针
数组名表示指向数组首元素的指针,因此可以直接对数组名进行指针操作。

int arr[] = {10, 20, 30, 40, 50};
cout << "*arr = " << *arr << endl;  // 输出10
cout << "arr[2] = " << arr[2] << endl;  // 输出30
cout << "*(arr + 2) = " << *(arr + 2) << endl;  // 输出30

指针访问数组元素
可以使用指针来访问数组元素,通过指针的算术运算实现对数组元素的遍历和操作。

int arr[] = {10, 20, 30, 40, 50};
int *p = arr;  // 指针p指向数组arr的首元素

for (int i = 0; i < 5; i++) {
    cout << "*(p + " << i << ") = " << *(p + i) << endl;
}

指针作为函数参数传递数组
当数组作为函数参数传递时,实际上传递的是指向数组首元素的指针。通过指针,函数可以访问和修改数组元素。

void printArray(int *arr, int size) {
    for (int i = 0; i < size; i++) {
        cout << "arr[" << i << "] = " << arr[i] << endl;
    }
}

int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int size = sizeof(arr) / sizeof(arr[0]);

    printArray(arr, size);

    return 0;
}

动态分配数组
使用指针和new运算符可以在堆上动态分配数组,这允许在运行时决定数组的大小。

int size;
cout << "Enter the size of the array: ";
cin >> size;

int *arr = new int[size];  // 动态分配一个大小为size的int型数组

for (int i = 0; i < size; i++) {
    arr[i] = i * 10;
}

for (int i = 0; i < size; i++) {
    cout << "arr[" << i << "] = " << arr[i] << endl;
}

delete[] arr;  // 释放动态分配的数组内存

注意事项:

数组名是一个常量指针,不能被修改。
指针访问数组元素时,要确保指针指向有效的数组元素,否则会导致未定义的行为。
动态分配的数组必须使用delete[]运算符释放内存,以避免内存泄漏。

指针与数组的结合使用提供了一种强大而灵活的方式来处理内存中的数据。理解指针与数组的关系,以及如何使用指针来访问和操作数组元素,是编写高效C++程序的关键技能之一。

1.5 指针与字符串

在C++中,字符串可以表示为字符数组或字符指针。指针与字符串的关系类似于指针与数组的关系,指针可以方便地操作和处理字符串。

字符数组与指针
字符串字面量存储在只读内存区域,可以用指向常量的指针来访问它。

const char *str1 = "Hello, world!";  // str1是一个指向常量字符的指针
cout << str1 << endl;  // 输出Hello, world!

char str2[] = "Hello, C++!";  // str2是一个字符数组
cout << str2 << endl;  // 输出Hello, C++!

指针与字符串函数
许多C风格的字符串函数都接受字符指针作为参数,如strlen、strcpy、strcat等。

#include <cstring>

char str1[20] = "Hello";
char str2[] = ", world!";

strcat(str1, str2);  // 将str2连接到str1的末尾
cout << str1 << endl;  // 输出Hello, world!

cout << strlen(str1) << endl;  // 输出13

指针与string对象
C++标准库提供了string类,它封装了字符串的各种操作。可以使用string对象的c_str()成员函数获取一个指向字符数组的指针。

#include <string>

string s1 = "Hello";
string s2 = ", C++!";

s1 += s2;  // 使用+=运算符连接字符串
cout << s1 << endl;  // 输出Hello, C++!

const char *str = s1.c_str();  // 获取指向字符数组的指针
cout << str << endl;  // 输出Hello, C++!

动态分配字符串
使用指针和new运算符可以在堆上动态分配字符串,这允许在运行时决定字符串的大小。

char *str = new char[20];  // 动态分配一个大小为20的字符数组

strcpy(str, "Hello, dynamic!");
cout << str << endl;  // 输出Hello, dynamic!

delete[] str;  // 释放动态分配的字符数组内存

注意事项:

字符串字面量是常量,不能被修改。
使用字符指针操作字符串时,要确保指针指向的内存空间足够大,以容纳字符串及其末尾的空字符。
动态分配的字符串必须使用delete[]运算符释放内存,以避免内存泄漏。
在C++中,建议使用string类来处理字符串,它提供了更安全、方便的字符串操作。

指针与字符串的结合使用是C++中处理文本数据的基础。理解如何使用指针来访问和操作字符串,以及掌握相关的字符串函数和string类的用法,对于编写高效、健壮的C++程序至关重要。

1.6 指针与结构体

在C++中,指针可以与结构体结合使用,提供了一种方便的方式来访问和操作结构体成员。通过指针,我们可以动态分配结构体,并在函数间传递结构体的地址。

指向结构体的指针
可以声明一个指向结构体的指针,用于存储结构体变量的地址。

struct Student {
    string name;
    int age;
    float score;
};

Student stu = {"Tom", 18, 90.5};
Student *p = &stu;  // 指针p指向结构体变量stu

通过指针访问结构体成员
可以使用箭头运算符(->)通过指针访问结构体的成员。

cout << p->name << endl;  // 输出Tom
cout << p->age << endl;  // 输出18
cout << p->score << endl;  // 输出90.5

动态分配结构体
使用指针和new运算符可以在堆上动态分配结构体,这允许在运行时决定结构体的数量。

Student *p = new Student;  // 动态分配一个Student结构体

p->name = "Jerry";
p->age = 20;
p->score = 85.0;

cout << p->name << ", " << p->age << ", " << p->score << endl;

delete p;  // 释放动态分配的结构体内存

指针作为函数参数传递结构体
当结构体作为函数参数传递时,可以传递指向结构体的指针,这样可以避免复制整个结构体,提高程序的效率。

void printStudent(Student *p) {
    cout << p->name << ", " << p->age << ", " << p->score << endl;
}

int main() {
    Student stu = {"Alice", 19, 92.5};
    printStudent(&stu);

    return 0;
}

结构体中的指针成员
结构体中可以包含指针类型的成员,用于存储其他变量或结构体的地址。

struct Node {
    int data;
    Node *next;
};

Node *head = nullptr;  // 链表的头指针

// 创建链表节点
Node *node1 = new Node{1, nullptr};
Node *node2 = new Node{2, nullptr};
Node *node3 = new Node{3, nullptr};

// 连接链表节点
head = node1;
node1->next = node2;
node2->next = node3;

注意事项:

访问结构体指针的成员时,必须使用箭头运算符(->),而不是点运算符(.)。
动态分配的结构体必须使用delete运算符释放内存,以避免内存泄漏。
当结构体包含指针成员时,要特别注意内存的管理,避免悬空指针和内存泄漏。

指针与结构体的结合使用是C++中实现复杂数据结构和算法的基础。掌握指针与结构体的用法,对于编写高效、灵活的C++程序至关重要。

1.7 指针与类

在C++中,指针与类的结合使用提供了一种强大的机制来实现动态对象创建、对象之间的关系以及多态等面向对象的特性。

指向类对象的指针
可以声明一个指向类对象的指针,用于存储对象的地址。

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

Student stu;
Student *p = &stu;  // 指针p指向类对象stu

通过指针访问类的成员
可以使用箭头运算符(->)通过指针访问类的成员。

p->name = "Tom";
p->age = 18;
p->score = 90.5;

cout << p->name << ", " << p->age << ", " << p->score << endl;

动态创建类对象
使用指针和new运算符可以在堆上动态创建类对象,这允许在运行时决定对象的数量。

Student *p = new Student;  // 动态创建一个Student对象

p->name = "Jerry";
p->age = 20;
p->score = 85.0;

cout << p->name << ", " << p->age << ", " << p->score << endl;

delete p;  // 释放动态创建的对象内存

指针作为函数参数传递类对象
当类对象作为函数参数传递时,可以传递指向对象的指针,这样可以避免复制整个对象,提高程序的效率。

void printStudent(Student *p) {
    cout << p->name << ", " << p->age << ", " << p->score << endl;
}

int main() {
    Student stu;
    stu.name = "Alice";
    stu.age = 19;
    stu.score = 92.5;

    printStudent(&stu);

    return 0;
}

类中的指针成员
类中可以包含指针类型的成员,用于存储其他对象的地址或实现自引用的数据结构。

class Node {
public:
    int data;
    Node *next;
};

Node *head = nullptr;  // 链表的头指针

// 创建链表节点
Node *node1 = new Node;
node1->data = 1;
node1->next = nullptr;

Node *node2 = new Node;
node2->data = 2;
node2->next = nullptr;

// 连接链表节点
head = node1;
node1->next = node2;

指针与多态
在继承和多态的场景中,指针可以用来实现运行时的动态绑定。基类指针可以指向派生类对象,通过基类指针调用虚函数时,会根据实际指向的对象类型来执行相应的函数。

class Shape {
public:
    virtual void draw() = 0;
};

class Circle : public Shape {
public:
    void draw() override {
        cout << "Drawing a circle." << endl;
    }
};

class Rectangle : public Shape {
public:
    void draw() override {
        cout << "Drawing a rectangle." << endl;
    }
};

int main() {
    Shape *p1 = new Circle;
    Shape *p2 = new Rectangle;

    p1->draw();  // 输出Drawing a circle.
    p2->draw();  // 输出Drawing a rectangle.

    delete p1;
    delete p2;

    return 0;
}

注意事项:

访问类指针的成员时,必须使用箭头运算符(->),而不是点运算符(.)。
动态创建的类对象必须使用delete运算符释放内存,以避免内存泄漏。
当类包含指针成员时,要特别注意内存的管理,避免悬空指针和内存泄漏。
在多态中,基类的析构函数应该声明为虚函数,以确保派生类对象被正确地销毁。

指针与类的结合使用是C++面向对象编程的核心。掌握指针在类中的应用,对于编写灵活、可扩展的C++程序至关重要。

1.8 指针与动态内存分配

在C++中,指针与动态内存分配密切相关。通过指针,我们可以在运行时动态地分配和释放内存,这提供了更大的灵活性和控制力。

1.8.1 new和delete运算符

new运算符用于在堆上动态分配内存,并返回一个指向新分配内存的指针。delete运算符用于释放由new运算符分配的内存。

int *p = new int;  // 动态分配一个int类型的内存
*p = 42;
cout << *p << endl;  // 输出42

delete p;  // 释放内存

1.8.2 动态数组

使用new[]运算符可以动态分配一个数组,并返回指向数组首元素的指针。使用delete[]运算符释放动态分配的数组内存。

int size = 5;
int *arr = new int[size];  // 动态分配一个大小为5的int数组

for (int i = 0; i < size; i++) {
    arr[i] = i;
}

for (int i = 0; i < size; i++) {
    cout << arr[i] << " ";
}
cout << endl;

delete[] arr;  // 释放数组内存

1.8.3 动态对象

使用new运算符可以动态创建类对象,并返回指向新创建对象的指针。使用delete运算符释放动态创建的对象内存。

class Rectangle {
public:
    int width;
    int height;

    Rectangle(int w, int h) : width(w), height(h) {}

    int area() {
        return width * height;
    }
};

Rectangle *p = new Rectangle(3, 4);  // 动态创建一个Rectangle对象

cout << "Area: " << p->area() << endl;  // 输出Area: 12

delete p;  // 释放对象内存

注意事项:

动态分配的内存必须手动释放,否则会导致内存泄漏。
对于动态分配的数组,必须使用delete[]运算符释放内存,而不是delete运算符。
在类中使用动态内存分配时,要注意在析构函数中释放内存,以避免内存泄漏。
为了避免手动管理内存的复杂性和错误,C++11引入了智能指针(如unique_ptr和shared_ptr),它们可以自动管理动态分配的内存。

下面是一个综合示例,演示了指针与动态内存分配的用法:

class Student {
public:
    string name;
    int age;

    Student(string n, int a) : name(n), age(a) {}
};

int main() {
    int size;
    cout << "Enter the number of students: ";
    cin >> size;

    Student **students = new Student*[size];  // 动态分配Student指针数组

    for (int i = 0; i < size; i++) {
        string name;
        int age;
        cout << "Enter name and age for student " << i + 1 << ": ";
        cin >> name >> age;
        students[i] = new Student(name, age);  // 动态创建Student对象
    }

    cout << "Student information:" << endl;
    for (int i = 0; i < size; i++) {
        cout << students[i]->name << " " << students[i]->age << endl;
        delete students[i];  // 释放Student对象内存
    }

    delete[] students;  // 释放Student指针数组内存

    return 0;
}

指针与动态内存分配是C++中管理内存的基本机制。掌握动态内存分配的原理和用法,对于编写高效、灵活的C++程序至关重要。

1.9 智能指针

智能指针是C++11引入的一种资源管理机制,用于自动管理动态分配的内存,避免手动释放内存导致的错误和内存泄漏。智能指针通过RAII(Resource Acquisition Is Initialization)技术,将资源的生命周期与对象的生命周期绑定,当对象销毁时,资源会自动释放。

C++11提供了三种智能指针:unique_ptr、shared_ptr和weak_ptr。

1.9.1 unique_ptr

unique_ptr是一种独占式的智能指针,它确保同一时间只有一个指针拥有资源的所有权。当unique_ptr离开作用域时,它会自动释放所管理的资源。

#include <memory>

class Rectangle {
public:
    int width;
    int height;

    Rectangle(int w, int h) : width(w), height(h) {}
};

int main() {
    unique_ptr<Rectangle> p1(new Rectangle(3, 4));
    cout << "Area: " << p1->width * p1->height << endl;

    unique_ptr<Rectangle> p2;
    p2 = move(p1);  // 转移所有权,p1变为空

    if (!p1) {
        cout << "p1 is empty" << endl;
    }

    return 0;
}

1.9.2 shared_ptr

shared_ptr是一种共享式的智能指针,它允许多个指针共享同一个资源的所有权。shared_ptr使用引用计数来跟踪资源的所有者数量,当引用计数变为零时,资源会自动释放。

#include <memory>

int main() {
    shared_ptr<int> p1(new int(42));
    cout << "*p1 = " << *p1 << endl;

    shared_ptr<int> p2 = p1;  // 共享所有权
    cout << "p1 use count: " << p1.use_count() << endl;

    p1.reset();  // 释放p1的所有权
    cout << "p2 use count: " << p2.use_count() << endl;

    return 0;
}

1.9.3 weak_ptr

weak_ptr是一种弱引用的智能指针,它不影响shared_ptr的引用计数。weak_ptr用于解决shared_ptr可能导致的循环引用问题,避免内存泄漏。

#include <memory>

class Node {
public:
    int data;
    shared_ptr<Node> next;
    weak_ptr<Node> prev;

    Node(int d) : data(d) {}
};

int main() {
    shared_ptr<Node> node1(new Node(1));
    shared_ptr<Node> node2(new Node(2));

    node1->next = node2;
    node2->prev = node1;

    cout << "node1 use count: " << node1.use_count() << endl;
    cout << "node2 use count: " << node2.use_count() << endl;

    return 0;
}

注意事项:

尽可能使用智能指针来管理动态分配的资源,减少手动内存管理的错误。
unique_ptr应该作为首选,除非需要共享所有权。
使用shared_ptr时,要注意避免循环引用,必要时使用weak_ptr。
智能指针不能完全替代裸指针,在某些场景下(如C风格的API)仍然需要使用裸指针。

智能指针是现代C++中管理动态内存的重要工具。掌握智能指针的原理和用法,可以编写更加安全、可靠的C++程序,避免内存管理的常见错误。

1.10 指针的常见错误与陷阱

在使用指针时,很容易出现一些常见的错误和陷阱。以下是一些需要注意的问题:

未初始化的指针
使用未初始化的指针会导致未定义的行为。在声明指针变量时,应该将其初始化为nullptr或有效的内存地址。

int *p;  // 未初始化的指针
*p = 42;  // 未定义的行为

悬空指针
悬空指针是指向已经释放或无效的内存地址的指针。访问悬空指针会导致程序崩溃或未定义的行为。

int *p = new int(42);
delete p;
cout << *p << endl;  // 访问悬空指针

内存泄漏
动态分配的内存必须手动释放,否则会导致内存泄漏。忘记释放内存或在多个位置释放同一块内存都会引起内存泄漏。

int *p = new int(42);
// 忘记释放内存

数组越界
访问数组时,要确保索引在有效范围内。越界访问会导致缓冲区溢出和未定义的行为。

int arr[5];
arr[5] = 42;  // 数组越界

指针类型不匹配
在进行指针赋值或转换时,要确保指针类型匹配。将不兼容的指针类型赋值会导致未定义的行为。

int *p = new int(42);
double *q = p;  // 指针类型不匹配

野指针
野指针是未经初始化或错误赋值的指针。访问野指针会导致程序崩溃或未定义的行为。

int *p;
*p = 42;  // 野指针

指针运算错误
在进行指针运算时,要确保指针指向有效的内存区域。对空指针或无效指针进行运算会导致未定义的行为。

int *p = nullptr;
p++;  // 对空指针进行运算

常量指针与指针常量混淆
常量指针(const int*)和指针常量(int* const)是不同的概念。常量指针指向常量,而指针常量是指针本身是常量。

int x = 10;
int y = 20;
const int *p1 = &x;  // 常量指针
int* const p2 = &x;  // 指针常量

p1 = &y;  // 正确,可以改变指针指向
*p1 = 30;  // 错误,不能修改指向的值

p2 = &y;  // 错误,不能改变指针指向
*p2 = 30;  // 正确,可以修改指向的值

为了避免这些错误和陷阱,应该遵循以下几点:

声明指针变量时总是初始化。
使用智能指针来管理动态分配的内存。
确保在正确的位置释放内存,避免多次释放或忘记释放。
对数组和指针进行操作时,确保索引和指针运算在有效范围内。
进行指针赋值或转换时,确保类型匹配。
理解常量指针和指针常量的区别。

指针是C++中强大但容易出错的工具。了解常见的指针错误和陷阱,并采取适当的措施来避免它们,可以编写更加健壮和可靠的C++程序。

二、函数参数传递

2.1 值传递

2.1.1 按值传递的概念

按值传递(pass-by-value)是函数参数传递的一种方式,它将实参的值复制给函数的形参。在这种方式下,函数内部对形参的任何修改都不会影响实参的值。

void increment(int num) {
    num++;
    cout << "Inside function: " << num << endl;
}

int main() {
    int x = 10;
    increment(x);
    cout << "Outside function: " << x << endl;
    return 0;
}

输出结果:

Inside function: 11
Outside function: 10

在上面的例子中,变量x的值被复制给函数increment的形参num。在函数内部,num的值被修改,但这并不影响x的值。

按值传递的特点:

实参的值被复制给形参,函数内部对形参的修改不会影响实参。
适用于传递简单的数据类型,如int、double、char等。
对于大型对象或结构体,按值传递可能会导致性能下降,因为需要复制整个对象。

按值传递的优点:

函数内部对形参的修改不会影响实参,提高了代码的安全性。
适用于不需要修改实参的情况。

按值传递的缺点:

对于大型对象或结构体,按值传递会导致性能下降。
如果需要在函数内部修改实参,按值传递无法实现。

在C++中,按值传递是函数参数传递的默认方式。对于需要在函数内部修改实参的情况,可以考虑使用指针传递或引用传递。

2.1.2 按值传递的应用场景

按值传递在以下场景中非常有用:

传递简单的数据类型
当函数参数是int、double、char等简单的数据类型时,按值传递是一种简单而高效的方式。

int square(int num) {
    return num * num;
}

int main() {
    int x = 5;
    int result = square(x);
    cout << "Square of " << x << " is " << result << endl;
    return 0;
}

不需要修改实参的值
如果函数内部不需要修改实参的值,按值传递可以确保实参的安全性。

void printString(string str) {
    cout << "String: " << str << endl;
}

int main() {
    string message = "Hello, world!";
    printString(message);
    return 0;
}

传递小型对象或结构体
对于小型对象或结构体,按值传递通常是一种简单而有效的方式。

struct Point {
    int x;
    int y;
};

void printPoint(Point p) {
    cout << "(" << p.x << ", " << p.y << ")" << endl;
}

int main() {
    Point p1 = {3, 4};
    printPoint(p1);
    return 0;
}

传递常量或字面值
当函数参数是常量或字面值时,按值传递是一种自然的选择。

void printMessage(const char* message) {
    cout << "Message: " << message << endl;
}

int main() {
    printMessage("Hello, world!");
    return 0;
}

函数参数的生命周期与调用函数无关
如果函数参数的生命周期与调用函数无关,按值传递可以避免潜在的悬空指针问题。

void processData(int data) {
    // 处理数据
}

int main() {
    int* data = new int(42);
    processData(*data);
    delete data;
    return 0;
}

然而,在以下情况下,按值传递可能不是最佳选择:

传递大型对象或结构体时,按值传递会导致性能下降。
需要在函数内部修改实参的值时,按值传递无法实现。

在这些情况下,可以考虑使用指针传递或引用传递。

总之,按值传递在传递简单数据类型、不需要修改实参、传递小型对象或常量时非常有用。了解按值传递的应用场景,可以帮助我们编写更加高效、安全的C++代码。

2.2 指针传递

2.2.1 按指针传递的概念

按指针传递(pass-by-pointer)是函数参数传递的一种方式,它将实参的地址传递给函数的形参。在这种方式下,函数内部可以通过指针访问和修改实参的值。

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main() {
    int x = 10;
    int y = 20;
    cout << "Before swap: x = " << x << ", y = " << y << endl;
    swap(&x, &y);
    cout << "After swap: x = " << x << ", y = " << y << endl;
    return 0;
}

输出结果:

Before swap: x = 10, y = 20
After swap: x = 20, y = 10

在上面的例子中,变量x和y的地址被传递给函数swap的形参a和b。在函数内部,通过解引用指针a和b,可以访问和修改x和y的值。

按指针传递的特点:

实参的地址被传递给形参,函数内部可以通过指针访问和修改实参的值。
适用于需要在函数内部修改实参的情况。
传递指针相对于传递整个对象或结构体,可以提高性能。

按指针传递的优点:

可以在函数内部修改实参的值。
传递指针相对于传递整个对象或结构体,可以提高性能。

按指针传递的缺点:

函数内部可以修改实参的值,如果不小心修改了不应该修改的数据,可能会导致难以发现的错误。
指针的使用增加了代码的复杂性,容易出现指针相关的错误,如悬空指针、野指针等。

在C++中,按指针传递通常用于以下情况:

需要在函数内部修改实参的值。
传递大型对象或结构体,避免按值传递带来的性能开销。
实现动态数据结构,如链表、树等。

总之,按指针传递是C++中重要的函数参数传递方式,它允许函数内部修改实参的值,并且可以提高传递大型对象或结构体的性能。

2.2.2 按指针传递的特点

按指针传递具有以下特点:

传递的是实参的地址
按指针传递时,传递给函数的是实参的地址,而不是实参的值。函数内部通过指针访问和操作实参。

void changeValue(int* num) {
    *num = 42;
}

int main() {
    int x = 10;
    changeValue(&x);
    cout << "x = " << x << endl;  // 输出: x = 42
    return 0;
}

函数内部可以修改实参的值
由于传递的是实参的地址,函数内部可以通过解引用指针来修改实参的值。

void incrementByTen(int* num) {
    *num += 10;
}

int main() {
    int x = 10;
    incrementByTen(&x);
    cout << "x = " << x << endl;  // 输出: x = 20
    return 0;
}

可以提高传递大型对象或结构体的性能
当函数参数是大型对象或结构体时,按值传递会导致整个对象或结构体被复制,带来性能开销。按指针传递只传递对象或结构体的地址,可以避免这种开销。

struct LargeStruct {
    int data[1000];
};

void processStruct(LargeStruct* ls) {
    // 处理结构体
}

int main() {
    LargeStruct ls;
    processStruct(&ls);
    return 0;
}

指针可能引入的问题
虽然按指针传递有其优势,但也可能引入一些问题:

如果函数内部修改了不应该修改的数据,可能导致难以发现的错误。
指针的使用增加了代码的复杂性,容易出现指针相关的错误,如悬空指针、野指针等。
如果实参的生命周期短于函数的执行时间,传递实参的地址可能导致悬空指针问题。

int* getAddress() {
    int x = 10;
    return &x;  // 返回局部变量的地址,可能导致悬空指针
}

int main() {
    int* p = getAddress();
    cout << *p << endl;  // 未定义行为
    return 0;
}

指针与数组的关系
数组名在大多数情况下会隐式转换为指向数组首元素的指针。因此,按指针传递数组时,实际上传递的是数组首元素的地址。

void printArray(int* arr, int size) {
    for (int i = 0; i < size; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
}

int main() {
    int numbers[] = {1, 2, 3, 4, 5};
    int size = sizeof(numbers) / sizeof(numbers[0]);
    printArray(numbers, size);  // 传递数组首元素的地址
    return 0;
}

理解按指针传递的特点,可以帮助我们更好地利用指针传递的优势,同时避免潜在的问题。在实际编程中,需要根据具体情况选择合适的参数传递方式,并谨慎使用指针,以确保程序的正确性和安全性。

2.2.3 按指针传递的应用场景

按指针传递在以下场景中非常有用:

修改实参的值
当函数需要修改实参的值时,按指针传递是一种常用的方式。通过传递实参的地址,函数内部可以直接修改实参的值。

void scale(double* factor, int* value) {
    *value *= static_cast<int>(*factor);
}

int main() {
    double factor = 1.5;
    int value = 10;
    scale(&factor, &value);
    cout << "Scaled value: " << value << endl;  // 输出: Scaled value: 15
    return 0;
}

返回多个值
当函数需要返回多个值时,可以通过按指针传递来实现。函数可以接受多个指针作为参数,并通过这些指针修改实参,从而达到返回多个值的目的。

void getMinMax(int* arr, int size, int* min, int* max) {
    *min = *max = arr[0];
    for (int i = 1; i < size; i++) {
        if (arr[i] < *min) {
            *min = arr[i];
        }
        if (arr[i] > *max) {
            *max = arr[i];
        }
    }
}

int main() {
    int numbers[] = {5, 2, 9, 1, 7};
    int size = sizeof(numbers) / sizeof(numbers[0]);
    int min, max;
    getMinMax(numbers, size, &min, &max);
    cout << "Min: " << min << ", Max: " << max << endl;  // 输出: Min: 1, Max: 9
    return 0;
}

传递大型对象或结构体
当函数参数是大型对象或结构体时,按指针传递可以避免按值传递带来的性能开销。传递对象或结构体的指针,可以提高函数调用的效率。

struct LargeStruct {
    int data[1000];
};

void processStruct(LargeStruct* ls) {
    // 处理结构体
}

int main() {
    LargeStruct ls;
    processStruct(&ls);
    return 0;
}

实现动态数据结构
在实现链表、树等动态数据结构时,按指针传递是必不可少的。通过传递节点的指针,可以建立节点之间的关系,并进行插入、删除等操作。

struct ListNode {
    int data;
    ListNode* next;
};

void insertNode(ListNode** head, int value) {
    ListNode* newNode = new ListNode{value, *head};
    *head = newNode;
}

void printList(ListNode* head) {
    while (head != nullptr) {
        cout << head->data << " ";
        head = head->next;
    }
    cout << endl;
}

int main() {
    ListNode* head = nullptr;
    insertNode(&head, 3);
    insertNode(&head, 1);
    insertNode(&head, 4);
    printList(head);  // 输出: 4 1 3
    return 0;
}

实现回调函数
回调函数通常通过指针传递,允许调用者将函数作为参数传递给另一个函数,实现灵活的函数定制和扩展。

void processArray(int* arr, int size, int (*callback)(int)) {
    for (int i = 0; i < size; i++) {
        arr[i] = callback(arr[i]);
    }
}

int square(int num) {
    return num * num;
}

int main() {
    int numbers[] = {1, 2, 3, 4, 5};
    int size = sizeof(numbers) / sizeof(numbers[0]);
    processArray(numbers, size, square);
    for (int i = 0; i < size; i++) {
        cout << numbers[i] << " ";
    }
    cout << endl;  // 输出: 1 4 9 16 25
    return 0;
}

按指针传递在需要修改实参、返回多个值、传递大型对象或结构体、实现动态数据结构和回调函数等场景中非常有用。了解按指针传递的应用场景,可以帮助我们在合适的情况下使用指针传递,提高程序的效率和灵活性。同时,也要注意指针使用中的潜在问题,如悬空指针、野指针等,确保程序的正确性和安全性。

2.3 引用传递

2.3.1 引用的概念

引用(reference)是C++中的一种复合数据类型,它为已有的变量提供了一个别名。引用类型引入了对象的一个同义词,对引用的操作实际上是对引用所绑定对象的操作。

引用的声明语法:

数据类型& 引用名 = 目标变量;

例如:

int value = 42;
int& ref = value;  // ref是value的引用

引用的特点:

引用必须在声明时初始化,并且不能为空。
引用一旦绑定到一个对象,就不能再绑定到另一个对象。
对引用的操作实际上是对引用所绑定对象的操作。
引用的类型必须与所绑定对象的类型相同(或者是可以隐式转换的类型)。

int value = 42;
int& ref = value;

ref = 10;  // 相当于value = 10
cout << "value = " << value << endl;  // 输出: value = 10

int anotherValue = 20;
ref = anotherValue;  // 相当于value = anotherValue,而不是改变ref的绑定
cout << "value = " << value << endl;  // 输出: value = 20

引用的用途:

函数参数传递:通过引用传递参数,可以在函数内部修改实参的值。
函数返回值:通过引用返回值,可以避免不必要的复制操作。
简化代码:使用引用可以简化一些操作,如交换两个变量的值。

void swap(int& a, int& b) {
    int temp = a;
    a = b;
    b = temp;
}

int main() {
    int x = 10, y = 20;
    swap(x, y);
    cout << "x = " << x << ", y = " << y << endl;  // 输出: x = 20, y = 10
    return 0;
}

需要注意的是,引用不是对象,因此不能定义引用的数组或指针。但是,可以定义数组或指针的引用。

int arr[3] = {1, 2, 3};
int(&ref)[3] = arr;  // ref是数组arr的引用

int* ptr = &arr[0];
int*& refPtr = ptr;  // refPtr是指针ptr的引用

引用是C++中非常有用的特性,它提供了一种便捷的方式来操作对象,避免了指针的一些复杂性。理解引用的概念及其特点,对于编写高效、可读的C++代码非常重要。

2.3.2 引用传递的特点

引用传递(pass-by-reference)是C++中函数参数传递的一种方式,它将实参的引用传递给函数形参。引用传递具有以下特点:

传递的是实参的引用
引用传递时,传递给函数的是实参的引用,而不是实参的副本。函数形参成为实参的别名,对形参的操作实际上是对实参的操作。

void changeValue(int& num) {
    num = 42;
}

int main() {
    int value = 10;
    changeValue(value);
    cout << "value = " << value << endl;  // 输出: value = 42
    return 0;
}

可以修改实参的值
由于传递的是实参的引用,函数内部对形参的修改实际上是对实参的修改。这允许函数内部直接修改实参的值。

void swap(int& a, int& b) {
    int temp = a;
    a = b;
    b = temp;
}

int main() {
    int x = 10, y = 20;
    swap(x, y);
    cout << "x = " << x << ", y = " << y << endl;  // 输出: x = 20, y = 10
    return 0;
}

避免了不必要的复制操作
引用传递避免了实参的复制操作,提高了函数调用的效率。特别是当实参是大型对象或结构体时,引用传递可以显著减少复制开销。

struct LargeStruct {
    int data[1000];
};

void processStruct(LargeStruct& ls) {
    // 处理结构体
}

int main() {
    LargeStruct ls;
    processStruct(ls);  // 传递ls的引用,避免复制
    return 0;
}

引用参数必须是可修改的左值
引用传递要求实参必须是可修改的左值,因为引用本身就是对象的别名。不能将常量、字面值或表达式作为引用参数传递。

void changeValue(int& num) {
    num = 42;
}

int main() {
    changeValue(10);  // 错误:字面值不能作为引用参数
    
    const int value = 10;
    changeValue(value);  // 错误:常量不能作为非常引用参数
    
    changeValue(value + 1);  // 错误:表达式不能作为引用参数
    
    return 0;
}

引用参数的生命周期
引用参数的生命周期与实参的生命周期相同。如果实参的生命周期短于函数的执行时间,引用参数可能会变成悬空引用,导致未定义行为。

int& getReference() {
    int value = 10;
    return value;  // 错误:返回局部变量的引用
}

int main() {
    int& ref = getReference();
    cout << ref << endl;  // 未定义行为
    return 0;
}

引用传递是C++中非常有用的参数传递方式,它允许函数内部直接修改实参的值,避免了不必要的复制操作,提高了函数调用的效率。同时,引用传递也要注意一些特点,如实参必须是可修改的左值,引用参数的生命周期等,以确保程序的正确性和安全性。

2.3.3 引用传递的应用场景

引用传递在以下场景中非常有用:

修改实参的值
当函数需要修改实参的值时,引用传递是一种常用的方式。通过将实参作为引用传递给函数,函数内部可以直接修改实参的值。

void increment(int& num) {
    num++;
}

int main() {
    int value = 10;
    increment(value);
    cout << "value = " << value << endl;  // 输出: value = 11
    return 0;
}

避免大型对象的复制
当函数参数是大型对象或结构体时,使用引用传递可以避免参数的复制,提高函数调用的效率。

struct LargeStruct {
    int data[1000];
};

void processStruct(LargeStruct& ls) {
    // 处理结构体
}

int main() {
    LargeStruct ls;
    processStruct(ls);  // 传递ls的引用,避免复制
    return 0;
}

返回多个值
通过将函数参数声明为引用,可以实现在函数内部修改多个实参,相当于返回多个值。

void getMinMax(const int& a, const int& b, int& min, int& max) {
    if (a < b) {
        min = a;
        max = b;
    } else {
        min = b;
        max = a;
    }
}

int main() {
    int x = 10, y = 20;
    int min, max;
    getMinMax(x, y, min, max);
    cout << "min = " << min << ", max = " << max << endl;  // 输出: min = 10, max = 20
    return 0;
}

实现运算符重载
在实现运算符重载时,经常需要将运算符的参数声明为引用,以避免不必要的对象复制。

class Complex {
private:
    double real;
    double imag;

public:
    Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}

    Complex& operator+=(const Complex& other) {
        real += other.real;
        imag += other.imag;
        return *this;
    }
};

int main() {
    Complex c1(1.0, 2.0);
    Complex c2(3.0, 4.0);
    c1 += c2;
    // 相当于 c1.operator+=(c2);
    return 0;
}

实现函数链式调用
通过将函数的返回值声明为引用,可以实现函数的链式调用,使代码更加简洁和可读。

class Person {
private:
    string name;
    int age;

public:
    Person& setName(const string& n) {
        name = n;
        return *this;
    }

    Person& setAge(int a) {
        age = a;
        return *this;
    }
};

int main() {
    Person p;
    p.setName("Alice").setAge(20);
    // 相当于 p.setName("Alice"); p.setAge(20);
    return 0;
}

引用传递在需要修改实参、避免大型对象复制、返回多个值、实现运算符重载和函数链式调用等场景中非常有用。合理使用引用传递可以提高程序的效率,使代码更加简洁和可读。同时,也要注意一些特点,如实参必须是可修改的左值,引用参数的生命周期等,以确保程序的正确性和安全性。

2.3.4 常引用

常引用(const reference)是C++中的一种特殊引用类型,它指向一个不能被修改的对象。常引用保证了引用所绑定的对象不会被修改,提高了程序的安全性和可读性。

常引用的声明语法:

const 数据类型& 引用名 = 目标变量;

例如:

int value = 42;
const int& ref = value;  // ref是value的常引用

常引用的特点:

常引用必须在声明时初始化,并且不能为空。
常引用所绑定的对象不能被修改,任何试图修改常引用所绑定对象的操作都会导致编译错误。
常引用可以绑定到常量、字面值或表达式上,而普通引用不行。

int value = 42;
const int& ref1 = value;  // 正确:常引用可以绑定到普通变量
ref1 = 10;  // 错误:不能通过常引用修改所绑定的对象

const int& ref2 = 42;  // 正确:常引用可以绑定到字面值
const int& ref3 = value + 1;  // 正确:常引用可以绑定到表达式

int& ref4 = 42;  // 错误:普通引用不能绑定到字面值
int& ref5 = value + 1;  // 错误:普通引用不能绑定到表达式

常引用的用途:

函数参数:将函数参数声明为常引用,可以避免函数内部对参数的修改,提高函数的安全性。
函数返回值:将函数返回值声明为常引用,可以避免不必要的对象复制,提高函数的效率。
类的成员函数:将类的成员函数声明为常成员函数,可以保证函数内部不会修改类的数据成员,提高类的封装性。

// 函数参数
void printValue(const int& value) {
    cout << "value = " << value << endl;
}

// 函数返回值
const string& getConstString() {
    static const string str = "Hello, world!";
    return str;
}

// 类的成员函数
class Circle {
private:
    double radius;

public:
    Circle(double r) : radius(r) {}

    double getArea() const {
        return 3.14 * radius * radius;
    }
};

常引用在函数参数、函数返回值和类的成员函数中非常有用,它可以提高程序的安全性、效率和封装性。合理使用常引用可以使代码更加健壮和可维护。

需要注意的是,常引用虽然不能直接修改所绑定的对象,但如果所绑定的对象本身是非常量,那么可以通过其他方式间接修改它。

int value = 42;
const int& ref = value;
ref = 10;  // 错误:不能通过常引用修改所绑定的对象

value = 10;  // 正确:可以直接修改value的值,ref所绑定的对象也会改变

总之,常引用是C++中一种重要的引用类型,它在保证对象不被修改的同时,提供了引用的便捷性和效率。合理使用常引用可以提高程序的质量和可维护性。

2.4 右值引用与移动语义

2.4.1 左值、右值的概念

在C++中,表达式可以分为左值(lvalue)和右值(rvalue)两种类型。左值和右值的主要区别在于是否可以取地址,以及能否出现在赋值运算符的左侧。

左值(lvalue):

左值是指可以取地址,并且可以出现在赋值运算符左侧的表达式。
左值通常是变量、数组元素、引用、解引用指针等。
左值有持久的状态,可以被多次读取和修改。

例如:

int a = 42;  // a是左值
int arr[3] = {1, 2, 3};  // arr[0], arr[1], arr[2]都是左值
int& ref = a;  // ref是左值,引用也是左值
int* ptr = &a;  // *ptr是左值

右值(rvalue):

右值是指不能取地址,并且只能出现在赋值运算符右侧的表达式。
右值通常是字面值、临时对象、表达式等。
右值没有持久的状态,只能被读取一次,不能被修改。

例如:

42  // 字面值是右值
a + b  // 表达式的结果是右值
函数返回值  // 函数返回值是右值

左值可以用于初始化右值,但反过来不行。

int a = 42;  // 正确:左值a可以初始化右值42
int b = a;  // 正确:左值a可以初始化右值b
42 = a;  // 错误:不能将左值a赋值给右值42

C++11引入了右值引用的概念,用于绑定到右值上。右值引用的声明使用两个引用符号(&&)。

int&& rref = 42;  // 正确:右值引用可以绑定到右值上
int&& rref2 = a;  // 错误:右值引用不能绑定到左值上

右值引用的主要用途是实现移动语义和完美转发,可以避免不必要的对象复制,提高程序的性能。

总结:

左值是可以取地址,并且可以出现在赋值运算符左侧的表达式。
右值是不能取地址,并且只能出现在赋值运算符右侧的表达式。
左值可以用于初始化右值,但反过来不行。
C++11引入了右值引用,用于绑定到右值上,实现移动语义和完美转发。

理解左值和右值的概念,对于编写高效、优雅的C++代码非常重要。合理利用右值引用和移动语义,可以避免不必要的对象复制,提高程序的性能。

2.4.2 右值引用的概念

右值引用(rvalue reference)是C++11引入的一种新的引用类型,它专门用于绑定到右值上。右值引用的声明使用两个引用符号(&&)。

右值引用的特点:

右值引用只能绑定到右值上,不能绑定到左值上。
右值引用可以延长临时对象的生命周期,避免不必要的对象复制。
右值引用是实现移动语义和完美转发的基础。

int&& rref = 42;  // 正确:右值引用可以绑定到右值上
int&& rref2 = std::move(rref);  // 正确:std::move将左值转换为右值引用

int a = 42;
int&& rref3 = a;  // 错误:右值引用不能绑定到左值上

右值引用的主要用途:

移动语义(move semantics):通过将对象的资源移动而不是复制,可以避免不必要的对象复制,提高程序的性能。
完美转发(perfect forwarding):通过将函数的参数完美地转发给另一个函数,可以保持参数的值类别(左值或右值)不变。

移动语义的示例:

class String {
private:
    char* data;
    size_t size;

public:
    String(const char* str) {
        size = strlen(str);
        data = new char[size + 1];
        strcpy(data, str);
    }

    String(String&& other) noexcept {
        data = other.data;
        size = other.size;
        other.data = nullptr;
        other.size = 0;
    }

    ~String() {
        delete[] data;
    }
};

String createString(const char* str) {
    return String(str);
}

int main() {
    String str = createString("Hello, world!");
    // 移动构造函数被调用,避免了不必要的对象复制
    return 0;
}

完美转发的示例:

template <typename T>
void forwardValue(T&& value) {
    processValue(std::forward<T>(value));
}

void processValue(int& value) {
    cout << "Processing lvalue: " << value << endl;
}

void processValue(int&& value) {
    cout << "Processing rvalue: " << value << endl;
}

int main() {
    int a = 42;
    forwardValue(a);  // 调用processValue(int&)
    forwardValue(42);  // 调用processValue(int&&)
    return 0;
}

右值引用是C++11中非常重要的特性,它是实现移动语义和完美转发的基础。合理利用右值引用可以避免不必要的对象复制,提高程序的性能。同时,右值引用也为C++的泛型编程提供了更加强大的工具。

需要注意的是,虽然右值引用可以延长临时对象的生命周期,但它并不能将临时对象的生命周期延长到与右值引用本身相同。

int&& rref = 42;
int* ptr = &rref;  // 危险:rref引用的临时对象可能在语句结束后被销毁

总之,右值引用是C++11中一种重要的引用类型,它专门用于绑定到右值上,实现移动语义和完美转发。合理利用右值引用可以提高程序的性能,并为泛型编程提供更加强大的工具。

2.4.3 移动构造函数与移动赋值运算符

移动构造函数(move constructor)和移动赋值运算符(move assignment operator)是C++11引入的特殊成员函数,它们用于实现移动语义,提高程序的性能。

移动构造函数:

移动构造函数是一种特殊的构造函数,它接受一个右值引用作为参数,用于将资源从一个对象移动到另一个对象。
移动构造函数的声明形式:
```
Class(Class&& other);
```
当一个对象被移动时,移动构造函数会被调用,将资源从原对象移动到新对象,而不是复制。

移动赋值运算符:

移动赋值运算符是一种特殊的赋值运算符,它接受一个右值引用作为参数,用于将资源从一个对象移动到另一个对象。
移动赋值运算符的声明形式:
```
Class& operator=(Class&& other);
```
当一个对象被移动赋值时,移动赋值运算符会被调用,将资源从原对象移动到目标对象,而不是复制。

示例:

class String {
private:
    char* data;
    size_t size;

public:
    String(const char* str) {
        size = strlen(str);
        data = new char[size + 1];
        strcpy(data, str);
    }

    String(String&& other) noexcept {
        data = other.data;
        size = other.size;
        other.data = nullptr;
        other.size = 0;
    }

    String& operator=(String&& other) noexcept {
        if (this != &other) {
            delete[] data;
            data = other.data;
            size = other.size;
            other.data = nullptr;
            other.size = 0;
        }
        return *this;
    }

    ~String() {
        delete[] data;
    }
};

String createString(const char* str) {
    return String(str);
}

int main() {
    String str1 = createString("Hello");
    String str2 = std::move(str1);  // 调用移动构造函数

    String str3 = createString("World");
    str1 = std::move(str3);  // 调用移动赋值运算符

    return 0;
}

在上面的示例中,String类定义了移动构造函数和移动赋值运算符。当临时对象被移动到str2时,移动构造函数被调用,将资源从临时对象移动到str2。当str3被移动赋值给str1时,移动赋值运算符被调用,将资源从str3移动到str1。

移动构造函数和移动赋值运算符的注意事项:

移动构造函数和移动赋值运算符应该标记为noexcept,以表明它们不会抛出异常。
在移动构造函数和移动赋值运算符中,应该将原对象的资源置为默认状态(如空指针),以避免双重释放。
在移动赋值运算符中,应该先判断是否为自赋值,以避免自身移动导致的问题。
如果一个类没有定义移动构造函数和移动赋值运算符,编译器可能会自动生成它们,但前提是该类没有定义任何自定义的拷贝构造函数、拷贝赋值运算符、移动构造函数、移动赋值运算符和析构函数。

移动构造函数和移动赋值运算符是实现移动语义的关键,它们可以避免不必要的对象复制,提高程序的性能。在设计类时,如果类的资源可以被移动,那么就应该考虑定义移动构造函数和移动赋值运算符,以充分利用移动语义的优势。

2.4.4 完美转发

完美转发(perfect forwarding)是C++11引入的一种技术,它允许将函数的参数完美地转发给另一个函数,同时保持参数的值类别(左值或右值)不变。完美转发通常与模板和右值引用结合使用,以实现通用的函数封装。

完美转发的核心是使用std::forward函数模板,它可以将参数转发给另一个函数,同时保持参数的值类别。std::forward的定义如下:

template <typename T>
T&& forward(typename std::remove_reference<T>::type& arg) {
    return static_cast<T&&>(arg);
}

完美转发的示例:

template <typename T>
void forwardValue(T&& value) {
    processValue(std::forward<T>(value));
}

void processValue(int& value) {
    cout << "Processing lvalue: " << value << endl;
}

void processValue(int&& value) {
    cout << "Processing rvalue: " << value << endl;
}

int main() {
    int a = 42;
    forwardValue(a);  // 调用processValue(int&)
    forwardValue(42);  // 调用processValue(int&&)
    return 0;
}

在上面的示例中,forwardValue函数接受一个通用的引用参数value,然后使用std::forward将参数转发给processValue函数。当传递左值a给forwardValue时,std::forward会将value转发为左值引用,因此调用processValue(int&)。当传递右值42给forwardValue时,std::forward会将value转发为右值引用,因此调用processValue(int&&)。

完美转发的应用场景:

封装通用的函数,如工厂函数、包装函数等,以减少代码重复。
实现通用的算法或数据结构,如std::make_shared、std::make_unique等。
在模板编程中,将参数完美地转发给其他函数或模板。

完美转发的注意事项:

完美转发需要使用通用的引用(T&&),而不是右值引用(Type&&)。
在转发参数时,必须使用std::forward,而不是直接使用参数。
完美转发可能会导致模板代码膨胀,因为编译器需要为每个不同类型的参数生成单独的函数实例。

总之,完美转发是C++11中一种重要的技术,它允许将函数的参数完美地转发给另一个函数,同时保持参数的值类别不变。完美转发通常与模板和右值引用结合使用,以实现通用的函数封装和模板编程。合理利用完美转发可以减少代码重复,提高代码的复用性和可维护性。
2.5 函数返回值传递

函数返回值传递是指函数通过返回值将计算结果传递给调用方的过程。在C++中,函数可以返回各种类型的值,包括基本类型、枚举类型、指针、引用、对象等。函数返回值传递的方式和效率对程序的性能有重要影响。

2.5.1 返回值传递方式

在C++中,函数返回值传递有以下几种方式:

返回值传递:函数通过返回一个值来传递结果,调用方通过接收返回值获取结果。

int add(int a, int b) {
    return a + b;
}

int main() {
    int result = add(3, 4);
    return 0;
}

返回引用传递:函数通过返回一个引用来传递结果,调用方通过接收返回的引用获取结果。

int& getElement(int* arr, int index) {
    return arr[index];
}

int main() {
    int numbers[] = {1, 2, 3, 4, 5};
    getElement(numbers, 2) = 10;
    return 0;
}

返回指针传递:函数通过返回一个指针来传递结果,调用方通过接收返回的指针获取结果。

int* createArray(int size) {
    return new int[size];
}

int main() {
    int* arr = createArray(5);
    delete[] arr;
    return 0;
}

返回对象传递:函数通过返回一个对象来传递结果,调用方通过接收返回的对象获取结果。

class Point {
public:
    int x;
    int y;
    Point(int x, int y) : x(x), y(y) {}
};

Point createPoint(int x, int y) {
    return Point(x, y);
}

int main() {
    Point p = createPoint(3, 4);
    return 0;
}

2.5.2 返回值优化(RVO)

返回值优化(Return Value Optimization, RVO)是C++编译器对函数返回值进行的一种优化技术。RVO包括两种形式:

命名返回值优化(Named Return Value Optimization, NRVO):当函数返回一个命名的对象时,编译器可以直接在调用方的内存空间构造该对象,避免了额外的拷贝操作。
```
class BigObject {
public:
    BigObject() { cout << "Constructor" << endl; }
    BigObject(const BigObject&) { cout << "Copy Constructor" << endl; }
};

BigObject createObject() {
    BigObject obj;
    return obj;
}

int main() {
    BigObject obj = createObject();
    return 0;
}
```
在上面的代码中,如果编译器支持NRVO,那么createObject函数返回的obj对象将直接在main函数的内存空间构造,避免了额外的拷贝操作。
返回值优化(Return Value Optimization, RVO):当函数返回一个临时对象时,编译器可以直接在调用方的内存空间构造该对象,避免了额外的拷贝操作。
```
class BigObject {
public:
    BigObject() { cout << "Constructor" << endl; }
    BigObject(const BigObject&) { cout << "Copy Constructor" << endl; }
};

BigObject createObject() {
    return BigObject();
}

int main() {
    BigObject obj = createObject();
    return 0;
}
```
在上面的代码中,如果编译器支持RVO,那么createObject函数返回的临时对象将直接在main函数的内存空间构造,避免了额外的拷贝操作。

RVO是编译器的一种优化技术,它可以显著提高程序的性能,特别是在返回大型对象时。但是,RVO的应用有一些限制:

RVO只能应用于返回值为对象类型的函数。
RVO要求返回的对象类型与函数的返回类型完全匹配。
RVO要求返回的对象是一个纯右值,即不能是一个命名对象或左值表达式。
RVO的应用取决于编译器的实现,不同的编译器可能有不同的优化策略。

2.6 参数传递的效率比较

在C++中,函数参数传递的效率与传递方式有关。不同的传递方式在时间和空间上有不同的开销。

值传递:值传递是将实参的值复制给形参,复制的过程会有一定的时间和空间开销。对于基本类型和小型对象,值传递的开销通常很小。但是,对于大型对象或复杂的数据结构,值传递可能会导致大量的复制操作,降低程序的性能。
指针传递:指针传递是将实参的地址传递给形参,传递的过程只需要复制指针的值,时间和空间开销都很小。但是,指针传递可能会导致程序的可读性和安全性降低,需要谨慎使用。
引用传递:引用传递是将实参的引用传递给形参,传递的过程只需要复制引用的值,时间和空间开销都很小。引用传递可以避免不必要的复制操作,提高程序的性能。但是,引用传递也可能导致程序的可读性降低,需要注意引用的生命周期和const属性。
右值引用传递:右值引用传递是C++11引入的一种传递方式,它允许将右值(如临时对象)传递给函数,避免了不必要的复制操作。右值引用传递通常与移动语义结合使用,可以显著提高程序的性能。

在实际编程中,应该根据具体情况选择合适的参数传递方式。对于小型对象或基本类型,值传递通常是一种简单高效的方式。对于大型对象或复杂的数据结构,可以考虑使用引用传递或右值引用传递,以避免不必要的复制操作。对于指针传递,需要谨慎使用,注意避免悬空指针和内存泄漏等问题。

总之,函数返回值传递和参数传递是C++中非常重要的概念,它们对程序的性能和可读性有重要影响。合理选择返回值传递方式和参数传递方式,充分利用编译器的优化技术,可以显著提高程序的性能和质量。

天秀信奥编程培训

关注

3
点赞
踩
9

收藏

觉得还不错? 一键收藏
打赏
0
评论
GESP四级 - 第二章 - 第1节 -指针与函数参数传递

指针是C++中的一种复合数据类型,它用于存储变量的内存地址。指针变量的值是它所指向的变量或对象的内存地址。通过指针,我们可以间接访问内存中的数据。理解指针的概念对于学习C++至关重要,因为指针在内存管理、数据结构和算法设计中扮演着重要的角色。同时,指针也是C++中较为复杂和容易出错的部分,需要谨慎使用。
复制链接

扫一扫