首页手记 C++指针入门教程：基础概念与应用解析

C++指针入门教程：基础概念与应用解析

标签：

C++

概述

本文详细介绍了C++指针的基本概念、声明、初始化以及指针的算术和比较操作。通过指针，程序员可以灵活地操作内存和实现动态内存分配。文章还探讨了C++指针在数组、字符串处理和函数参数中的应用，并指出了指针使用中常见的陷阱和问题。

C++指针的基本概念

什么是指针

在C++中，指针是一种特殊的变量类型，用于存储内存地址，指向程序中的某个特定位置。访问该地址中的数据，可以通过指针来实现。指针变量的类型定义了它指向的数据类型。指针是C++语言中最强大的特性之一，它提供了对内存的直接操作功能，但同时也是一个容易出错的特性。

指针变量具有两个主要组成部分：

地址：指针变量存储的是一个内存地址，该地址指向了另一个变量的实际位置。
数据类型：指针变量的类型决定了它所指向的数据类型。例如，int*表示一个指针，它指向的是一个整型变量。

指针的声明与初始化

指针的声明遵循以下语法：

类型* 变量名;

例如，声明一个指向整型的指针变量：

int* pInt;

指针的初始化可以有多种方式：

未初始化：声明指针但未初始化，它将指向一个不确定的内存地址。
```
int* pInt;
pInt = nullptr; // 建议将未初始化的指针设为 nullptr
```

直接赋值：将指针直接赋值给一个变量的地址。

int num = 10;
int* pInt = &num; // pInt现在指向num的地址

使用new关键字：动态分配内存给指针。

int* pInt = new int;
*pInt = 10; // 通过指针访问并赋值

指针与变量的关系

指针变量通常用来存储其他变量的地址。通过指针可以访问或修改该变量的值。指针变量与实际变量之间的关系如下：

存储地址：指针变量存储的是其他变量的地址，而不是变量本身的值。
访问值：通过指针可以访问和修改所指向变量的值。这通常通过解引用操作符*来完成。
传递控制：指针可以传递控制权给其他函数或代码段，使它们能够直接操作同一块内存。

下面通过一个简单的例子来说明如何通过指针变量来修改一个整型变量的值：

int num = 10;
int* pInt = &num; // pInt指向num的地址

// 通过指针修改num的值
*pInt = 20;

// 输出结果
std::cout << "num的值是：" << num << std::endl;

上述代码中，pInt存储了num的地址，通过*pInt可以访问num的值，将其修改为20，输出结果为20。

指针的使用场景

动态内存分配

动态内存分配是指在程序运行时，根据需要向系统申请内存空间并分配给程序使用的机制。C++中主要使用new和delete关键字来实现动态内存分配和释放。

使用new关键字动态分配内存时，可以为指针分配特定类型的内存空间。例如，分配存储一个整型值的内存：

int* pInt = new int;
*pInt = 10; // 通过指针访问，赋值10

释放内存时，使用delete关键字：

delete pInt; // 释放pInt指向的内存
pInt = nullptr; // 释放指针，以防野指针

数组与指针

C++中的数组本质上是连续的一段内存空间，数组名可以视为指向数组第一个元素的指针。因此，数组与指针在很多操作上具有相似性。

声明与初始化

int arr[5] = {1, 2, 3, 4, 5};
int* pArr = arr; // pArr指向数组的第一个元素

访问数组元素

// 通过指针访问数组元素
std::cout << "第一个元素：" << *pArr << std::endl;
std::cout << "第二个元素：" << *(pArr + 1) << std::endl;

遍历数组

for (int i = 0; i < 5; ++i) {
   std::cout << "数组元素：" << *(pArr + i) << std::endl;
}

函数参数传递

函数参数传递是C++程序设计中的常见操作之一，使用指针可以传递较大的数据结构或进行函数间的持久数据共享。

传递基本类型

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

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

传递结构体或类对象

struct Person {
   std::string name;
   int age;
};

void printPerson(Person* person) {
   std::cout << "Name: " << person->name << ", Age: " << person->age << std::endl;
}

int main() {
   Person p = {"Alice", 25};
   printPerson(&p);
   return 0;
}

返回指针

int* createNewInt() {
   int* num = new int;
   *num = 10;
   return num;
}

int main() {
   int* pInt = createNewInt();
   std::cout << "值为：" << *pInt << std::endl; // 输出 10
   delete pInt; // 释放内存
   return 0;
}

使用函数指针

void print(int* num) {
   std::cout << "值为：" << *num << std::endl;
}

int main() {
   int value = 10;
   void (*fp)(int*) = print;
   fp(&value); // 输出 10
   return 0;
}

指针操作详解

指针的算术运算

指针可以进行简单的算术运算，例如加法和减法。这些运算用于在内存地址之间进行移动和计算。

指针加法

int arr[5] = {1, 2, 3, 4, 5};
int* p = arr;
p = p + 1; // p指向数组的第二个元素
std::cout << "第二个元素：" << *p << std::endl; // 输出 2

指针减法

int arr[5] = {1, 2, 3, 4, 5};
int* p = arr + 4; // p指向数组的最后一个元素
p = p - 1;        // p现在指向数组的倒数第二个元素
std::cout << "倒数第二个元素：" << *p << std::endl; // 输出 4

指针与整数运算

int arr[] = {1, 2, 3, 4, 5};
int* p = arr;
p += 2; // p移动到第三个元素
std::cout << "第三个元素：" << *p << std::endl; // 输出 3

指针的比较运算

指针变量可以进行比较运算，例如相等、不相等、大于、小于等。这些操作通常用于检查指针是否指向相同的内存位置或比较它们指向的地址。

相等

int arr[5] = {1, 2, 3, 4, 5};
int* p1 = arr;
int* p2 = arr + 4;
if (p1 == p2) {
   std::cout << "p1和p2指向相同的地址" << std::endl;
} else {
   std::cout << "p1和p2指向不同的地址" << std::endl;
}

不相等

int arr[5] = {1, 2, 3, 4, 5};
int* p1 = arr;
int* p2 = arr + 1;
if (p1 != p2) {
   std::cout << "p1和p2指向不同的地址" << std::endl;
}

大于与小于

int arr[5] = {1, 2, 3, 4, 5};
int* p1 = arr;
int* p2 = arr + 2;
if (p1 < p2) {
   std::cout << "p1的地址小于p2的地址" << std::endl;
}

指针的解引用操作

解引用操作符*用于访问指针所指向的内存中的实际数据。

解引用一个指针

int value = 10;
int* p = &value;
std::cout << "值为：" << *p << std::endl; // 输出 10

通过解引用赋值

int value = 10;
int* p = &value;
*p = 20; // 通过指针修改值
std::cout << "值为：" << value << std::endl; // 输出 20

指针与数组

一维数组与指针

一维数组和指针之间有着密切的关系。数组名本质上就是一个指针，指向数组的第一个元素。因此，可以通过指针来遍历数组。

声明与初始化

int arr[5] = {1, 2, 3, 4, 5};
int* pArr = arr; // pArr指向数组的第一个元素

遍历数组

int arr[5] = {1, 2, 3, 4, 5};
for (int i = 0; i < 5; ++i) {
   std::cout << "元素：" << *(pArr + i) << std::endl;
}

改变数组元素

int arr[5] = {1, 2, 3, 4, 5};
*pArr = 10; // 改变第一个元素的值
std::cout << "数组元素：" << arr[0] << std::endl; // 输出 10

多维数组与指针

多维数组也可以用指针表示。多维数组本质上是多个一维数组的嵌套，可以通过指针来表示。

声明与初始化

int arr[2][3] = {
   {1, 2, 3},
   {4, 5, 6}
};
int (*p)[3] = arr; // p指向二维数组的第一行

遍历多维数组

for (int i = 0; i < 2; ++i) {
   for (int j = 0; j < 3; ++j) {
       std::cout << "元素：" << (*p)[j] << std::endl;
   }
   p++; // 移动到下一行
}

改变多维数组元素

(*p)[1] = 10; // 改变第一行的第二个元素
std::cout << "数组元素：" << arr[0][1] << std::endl; // 输出 10

字符串处理与指针

字符串处理通常是C++编程中的重要部分，字符串在内存中通常表示为连续的字符数组。指针提供了灵活的方式来操作字符串。

声明与初始化

char str[] = "Hello";
char* pStr = str; // pStr指向字符串的第一个字符

遍历字符串

while (*pStr != '\0') {
   std::cout << *pStr; // 输出单个字符
   pStr++;
}
std::cout << std::endl;

改变字符串中的字符

*pStr = 'J'; // 修改第一个字符
std::cout << "修改后的字符串：" << str << std::endl; // 输出 "Jello"

指针与函数

函数参数中的指针

在函数参数中传递指针，可以用于传递较大的数据结构或进行函数间的持久数据共享。

传递基本类型

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

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

传递结构体或类对象

struct Person {
   std::string name;
   int age;
};

void printPerson(Person* person) {
   std::cout << "Name: " << person->name << ", Age: " << person->age << std::endl;
}

int main() {
   Person p = {"Alice", 25};
   printPerson(&p);
   return 0;
}

函数返回值中的指针

函数可以返回指向动态分配内存的指针，这使得可以在函数之间传递和操作动态分配的数据。

返回指向动态分配的指针

int* createNewInt() {
   int* num = new int;
   *num = 10;
   return num;
}

int main() {
   int* pInt = createNewInt();
   std::cout << "值为：" << *pInt << std::endl; // 输出 10
   delete pInt;
   return 0;
}

指针作为函数指针

函数指针是指向函数的指针，可以用来传递函数的地址。这允许动态地调用函数。

声明与使用函数指针

void print(int* num) {
   std::cout << "值为：" << *num << std::endl;
}

int main() {
   int value = 10;
   void (*fp)(int*) = print;
   fp(&value); // 输出 10
   return 0;
}

传递函数指针给另一个函数

void execute(int* num, void (*func)(int*)) {
   func(num);
}

int main() {
   int value = 10;
   execute(&value, print); // 输出 10
   return 0;
}

指针的常见问题与陷阱

指针越界访问

指针越界访问是C++编程中最常见的错误之一，它发生在尝试访问超出分配给指针的内存范围时。

越界访问示例

int arr[5] = {1, 2, 3, 4, 5};
int* p = arr;
p += 5; // 越界
std::cout << "越界的值：" << *p << std::endl; // 可能导致程序崩溃或未定义行为

避免越界访问

使用循环边界检查：

int arr[5] = {1, 2, 3, 4, 5};
int* p = arr;
for (int i = 0; i < 5; ++i) {
 std::cout << "元素：" << *(p + i) << std::endl;
}

使用索引限制：

int arr[5] = {1, 2, 3, 4, 5};
int* p = arr;
if (p >= arr && p < arr + 5) {
 std::cout << "元素：" << *p << std::endl;
} else {
 std::cout << "越界访问" << std::endl;
}

野指针问题

野指针是指还没有被正确初始化，指向了未知地址的指针。它的存在可能导致程序崩溃或未定义行为。

野指针示例

int* p;
std::cout << "未初始化指针的值：" << *p << std::endl; // 可能导致程序崩溃或未定义行为

避免野指针

初始化指针：

int* p = nullptr; // 初始化指针为 nullptr

释放内存时设置指针为 nullptr：

int* p = new int;
*p = 10;
delete p;
p = nullptr; // 设置指针为 nullptr

指针与内存泄漏

内存泄漏是指程序分配的内存没有被释放，导致内存逐渐耗尽。指针的不当使用是内存泄漏的常见原因。

内存泄漏示例

void func() {
   int* pInt = new int;
   *pInt = 10;
   // 忘记释放内存
}

int main() {
   func();
   return 0;
}

避免内存泄漏

释放分配的内存：

void func() {
 int* pInt = new int;
 *pInt = 10;
 delete pInt; // 释放内存
}

int main() {
 func();
 return 0;
}

使用智能指针（如 std::unique_ptr）：

void func() {
 std::unique_ptr<int> pInt(new int);
 *pInt = 10;
 // 自动释放内存
}

int main() {
 func();
 return 0;
}

总结，指针是C++中非常强大的工具，但同时也带来了许多陷阱和问题。通过正确地初始化、释放内存以及进行边界检查，可以避免许多常见错误，确保程序的健壮性和安全性。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

炎炎设计

手记
篇

粉丝

74

获赞与收藏

371

关注作者，订阅最新文章

阅读免费教程

Android Studio 编辑器教程

40个小节 11846 244

后端通用面试教程

41个小节 30583 343

网络编程入门教程

20个小节 12561 237

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空

C++指针入门教程：基础概念与应用解析

C++指针的基本概念

什么是指针

指针的声明与初始化

指针与变量的关系

指针的使用场景

动态内存分配

数组与指针

函数参数传递

指针操作详解

指针的算术运算

指针的比较运算

指针的解引用操作

指针与数组

一维数组与指针

多维数组与指针

字符串处理与指针

指针与函数

函数参数中的指针

函数返回值中的指针

指针作为函数指针

指针的常见问题与陷阱

指针越界访问

野指针问题

指针与内存泄漏

阅读免费教程