C++的指针,引用和STL详解

指针

指针是C++语言中非常重要的一个概念，它是一个变量，其值为另一个变量的地址。指针的用途很广泛，它经常被用于动态的内存分配和数据结构中。

指针的定义和使用

指针的定义使用符号*，例如：

int *p;

这个语句定义了一个名为p的指向int类型的指针。指针变量必须初始化才能使用，一般有两种方式：

1. 直接初始化赋值，例如：

int a = 10;
int *p = &a; //指向a的地址

1. 动态分配内存，例如：

int *p = new int; //动态分配int类型的内存
*p = 10;  //给*p所指向的内存空间赋值为10

需要注意的是，动态分配的内存必须及时释放，否则会出现内存泄漏的情况，例如：

delete p;  //释放p所指向的内存空间
p = nullptr; //指针p的值设置为nullptr，防止出现野指针

指针的运算符

C++中有几个指针运算符需要掌握：

1. *：取指针所指向的值，例如：

int a = 10;
int *p = &a;
cout << *p << endl; //输出a的值，即10

1. &：取变量的地址，例如：

int a = 10;
int *p = &a;
cout << p << endl; //输出a的地址

1. ++、--：指针的前缀和后缀自增自减，例如：

int a[] = {1, 2, 3};
int *p = &a[0];
p++; //指向a[1]
cout << *p << endl; //输出2

引用

引用是C++中的另一个重要概念，它可以看作是变量的别名，引用的值会随着原变量的变化而变化。

引用和指针的区别

引用和指针具有相似的功能，但是也有区别：

1. 引用不能为nullptr，指针可以为nullptr；
2. 引用在创建后不能指向其他变量，而指针可以指向其他变量；
3. 引用必须在定义的时候就初始化，而指针可以后面再赋值。

引用的定义和使用

引用的定义使用符号&，例如：

int a = 10;
int &b = a;

b就是a的引用，b可以对a进行读写操作，例如：

b = 20; //修改b的值，a的值也会被修改
cout << a << endl; //输出20

引用的作用更多的是简化代码和提高效率，例如：

void swap(int &a, int &b) {
    int temp = a;
    a = b;
    b = temp;
}
//使用引用交换两个数的值
int x = 1, y = 2;
swap(x, y);
cout << x << " " << y << endl; //输出2 1

STL

STL（Standard Template Library）是C++的一个标准库，它实现了很多常用的数据结构和算法，包括向量、列表、队列、堆栈、映射、算法等等。下面以向量为例子，介绍STL的使用。

向量的定义和使用

向量是一种动态数组，它可以随意添加或删除其中的元素。向量的定义和使用需要包含头文件vector，例如：

#include <vector>
using namespace std;

vector<int> vec; //定义了一个空向量

向向量中添加元素使用push_back()方法，例如：

vec.push_back(1); //向向量中添加1

读取向量中的元素使用下标操作符[]，例如：

cout << vec[0] << endl; //输出1

删除向量中的元素使用erase()方法，例如：

vec.erase(vec.begin()); //删除第一个元素

这只是向量的基础用法，STL中的其他数据结构和算法也如此，需要详细的学习和了解。

示例说明

示例1：使用指针和引用交换两个数字的值

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

int main() {
    int x = 1, y = 2;
    int *p = &x;
    swap(x, y);
    cout << x << " " << y << endl; //输出2 1
    swap(*p, y);
    cout << x << " " << y << endl; //输出2 1
    return 0;
}

在这个示例中，我们定义了一个指针p和两个引用a和b。通过指针可以修改变量的真实值，通过引用可以方便地进行数据交换。

示例2：使用STL实现快速排序算法

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int partition(vector<int> &arr, int begin, int end) {
    int pivot = arr[end]; //以最后一个元素为基准
    int left = begin - 1;
    for (int i = begin; i < end; i++) {
        if (arr[i] <= pivot) {
            left++;
            swap(arr[left], arr[i]);
        }
    }
    swap(arr[left+1], arr[end]);
    return left+1;
}

void quickSort(vector<int> &arr, int begin, int end) {
    if (begin < end) {
        int pivotIndex = partition(arr, begin, end);
        quickSort(arr, begin, pivotIndex - 1);
        quickSort(arr, pivotIndex + 1, end);
    }
}

int main() {
    vector<int> arr = {3, 6, 1, 7, 2, 8, 4, 5};
    quickSort(arr, 0, arr.size() - 1);
    for (int i = 0; i < arr.size(); i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
    return 0;
}

在这个示例中，我们使用了STL中的向量和sort()算法来实现快速排序。由于向量可以随意添加或删除其中的元素，最终可以将算法的复杂度降低到$O(nlogn)$。