C语言指针 & 格式字符串

Ptchenlee

已于 2023-11-07 20:33:08 修改

阅读量80

点赞数

文章标签： c语言数据结构开发语言

于 2023-11-07 20:29:57 首次发布

本文链接：https://blog.csdn.net/Darling_Zzzzzzz/article/details/134275479

版权

指针

关于指针学习

学习指针是理解C语言的重要部分。以下是一些学习指针的建议：

理解指针的基本概念：指针是一种变量，用于存储内存地址。理解指针的基本概念有助于你更好地理解如何使用指针。
掌握指针的声明和初始化：指针的声明和初始化是使用指针的先决条件。你需要了解如何声明一个指针变量，以及如何将一个变量的地址赋值给指针。
理解指针的类型：指针的类型取决于它所指向的变量的类型。理解指针的类型对于正确使用指针非常重要。
掌握指针的运算：指针可以进行一些运算，如指针的加法、减法等。这些运算可以用于操作数组、字符串等。
理解指针在函数参数传递中的应用：在C语言中，函数参数是通过值传递的。如果你需要修改函数外部的变量，你可以使用指针作为函数参数。
掌握指针在数组中的应用：数组在C语言中实际上是一个指针，指向数组的第一个元素。掌握如何使用指针来访问数组的元素是非常重要的。
理解指针在字符串中的应用：字符串在C语言中通常表示为字符数组。由于数组名是一个指向其第一个元素的指针，因此我们可以使用指针来访问和修改字符串中的字符。
掌握指针在数据结构中的应用：指针在构建复杂数据结构（如链表、树等）时非常有用。通过使用指针，我们可以轻松地跟踪和修改数据结构中的元素。
实践项目：尝试编写一些使用指针的项目，例如创建一个链表或一个二叉树。这将帮助你更好地理解和应用指针。
查阅文档和教程：如果你对某个特定概念或问题有疑问，可以查阅C语言的文档或教程，以获取更详细的信息。

总之，学习指针需要时间和实践。通过掌握基本概念、声明和初始化、类型、运算、应用等方面，你将能够更好地理解和使用指针。

指针的概念

指针是C语言中的一个重要概念，它允许我们通过引用或间接访问变量的内存地址来操作变量。

首先，我们需要了解如何声明和使用指针变量。以下是一个示例：

int num = 10;
int *ptr; // 声明一个整型指针
ptr = &num; // 将指针指向num变量的内存地址

在这个例子中，我们声明了一个名为ptr的整型指针，并将其初始化为指向变量num的内存地址。现在，我们可以通过使用*运算符来访问ptr所指向的变量的值。例如，我们可以使用以下代码来打印num的值：

printf("num的值为：%d\n", *ptr);

指针也可以用于数组中。一个数组的名称实际上是一个指向数组第一个元素的指针。我们可以使用指针来遍历数组并访问其元素。以下是一个示例：

int arr[] = {1, 2, 3, 4, 5};
int *ptr = arr; // 将指针初始化为数组的第一个元素的地址

for (int i = 0; i < 5; i++) {
    printf("%d ", *ptr); // 打印指针所指向的元素
    ptr++; // 将指针指向下一个元素
}

指针的用途

这个例子中，我们声明了一个整型数组arr，并将一个指针ptr初始化为数组的第一个元素的地址。然后，我们使用循环遍历数组，并通过指针访问每个元素。在每次迭代中，我们将指针递增以访问下一个元素。

除了整数类型，指针还可以用于其他数据类型，如字符、浮点数等。同样，我们也可以使用不同类型的指针来访问不同的数据类型。

在C语言中，指针是一种特殊的变量类型，它可以存储内存地址。以下是C语言中指针的一些主要用途：

动态内存分配：使用指针，我们可以在运行时动态地分配和释放内存。例如，我们可以使用malloc函数分配内存，然后使用一个指针来存储这个内存地址。当我们完成使用后，可以使用free函数释放这块内存。
函数参数传递：在C语言中，参数是通过值传递的，这意味着函数接收到的是参数值的副本。但是，如果我们希望在函数内部修改参数的值，并且让这种改变在函数外部也生效，那么我们可以使用指针。通过传递指针，函数可以直接修改原始数据。
数组操作：在C语言中，数组名实际上是一个指向数组第一个元素的指针。因此，我们可以通过使用指针来遍历数组、访问数组元素等。
字符串处理：字符串在C语言中通常表示为字符数组。由于数组名是一个指向其第一个元素的指针，因此我们也可以使用指针来访问和修改字符串中的字符。
数据结构：指针在构建复杂数据结构（如链表、树等）时非常有用。通过使用指针，我们可以轻松地跟踪和修改数据结构中的元素。
回调函数：在某些情况下，我们可能需要将一个函数作为参数传递给另一个函数。由于函数名本质上就是一个指向函数的指针，我们可以将函数作为参数传递，并在需要的时候调用它。
节省内存：在一些情况下，使用指针可以节省内存。例如，如果我们有一个大型数据结构，但我们只需要访问其中的一部分，我们可以使用指针来引用我们需要的部分，而不是复制整个数据结构。

以上就是C语言中指针的一些主要用途。指针是C语言的一个重要特性，也是理解和使用C语言的重要部分。

指针的类型

C语言中的指针类型主要取决于它所指向的变量的类型。以下是一些常见的指针类型：

整型指针：可以指向整型数据。例如，int *ptr可以指向一个int类型的变量。
浮点型指针：可以指向浮点型数据。例如，float *ptr可以指向一个float类型的变量。
字符型指针：可以指向字符型数据。例如，char *ptr可以指向一个char类型的变量。
数组型指针：数组名其实是指向数组首元素的指针，它的类型取决于数组中元素的类型。例如，如果数组是int类型，那么这个指针的类型就是int *。
函数型指针：函数名和数组名一样，是起始地址，而且是一个地址常量。这种指针的类型取决于它所指向的函数的返回类型和参数类型。

指针的运算

指针的运算包括指针的加法、指针的减法、指针的取模等。

指针的加法

指针的加法运算是指将两个指针相加，得到一个新的指针，这个新的指针指向两个原指针所指向数据之后的一个位置。具体来说，如果两个指针 p 和 q 指向同一数组中的元素，那么 p+q 指向 p 和 q 之间相差的元素个数乘上元素大小的内存位置。

假设有两个 int 类型的指针 p 和 q，它们的值分别为 10 和 20，那么 p+q 的结果是一个指向位置 30 的 int 类型指针。这个新的指针可以用来访问和修改它所指向的数据。需要注意的是，指针的加法运算必须保证两个指针的类型和它们所指向的数组类型一致，否则会导致编译错误。

此外，指针的加法运算结果也需要进行适当的类型转换才能使用。例如，如果将两个 char 类型的指针相加，那么得到的结果是一个指向距离较远的元素的 char 类型指针，如果直接使用该指针可能会访问到错误的内存位置。因此，在使用指针的加法运算结果时，需要将其转换为合适的类型。

指针的减法

指针的减法运算是指将两个指针相减，得到一个整型数，表示两个指针所指向数据之间的距离。具体来说，如果两个指针 p 和 q 指向同一数组中的元素，那么 p-q 的结果为 q-p，即两个指针之间相差的元素个数乘上元素大小的内存距离。

假设有两个 int 类型的指针 p 和 q，它们的值分别为 10 和 20，那么 p-q 的结果为 -10，表示 p 指向的位置距离 q 指向的位置有 10 个 int 的距离。需要注意的是，指针的减法运算必须保证两个指针的类型和它们所指向的数组类型一致，否则会导致编译错误。

此外，指针的减法运算结果也需要进行适当的类型转换才能使用。例如，如果将两个 char 类型的指针相减，那么得到的结果是一个表示两个指针之间相差的字节数的整型数。如果需要获取两个指针之间相差的元素个数，需要将结果转换为适当的类型。

指针的取模

指针的取模运算是指将一个指针与另一个指针相减，然后对结果取模，得到一个整型数，表示两个指针之间相差的元素个数。具体来说，如果两个指针 p 和 q 指向同一数组中的元素，那么 (p-q) % (q-p) 的结果为 0，表示 p 和 q 指向的是相邻的元素。

假设有两个 int 类型的指针 p 和 q，它们的值分别为 10 和 20，那么 (p-q) % (q-p) 的结果为 0，当两个指针 p 和 q 指向同一数组中相邻的元素时，即 p 和 q 之间的距离为1时，(p+q) % (q-p) 的结果为 0。

另外，如果两个指针 p 和 q 指向同一数组中的元素，且 p 和 q 的值相等时，即 p == q 时，(p+q) % (q-p) 的结果也为 0。这是因为 p 和 q 指向同一位置，它们之间的距离为0。表示 p 和 q 指向的是相邻的元素。需要注意的是，指针的取模运算必须保证两个指针的类型和它们所指向的数组类型一致，否则会导致编译错误。

此外，指针的取模运算结果也需要进行适当的类型转换才能使用。例如，如果将两个 char 类型的指针相减，那么得到的结果是一个表示两个指针之间相差的字节数的整型数。如果需要获取两个指针之间相差的元素个数，需要将结果转换为适当的类型。

需要注意的是，指针的运算必须遵循一定的规则，例如两个指针的类型必须相同，指针所指向的数据类型也必须相同。此外，指针的运算结果也需要进行适当的类型转换才能使用。

指针在函数参数传递中的应用

在C语言中，函数参数传递通常是通过值传递实现的，这意味着函数接收到的是参数值的副本。然而，有时我们可能希望在函数内部修改函数外部的变量，而通过值传递无法实现这一点。这时，我们可以使用指针作为函数参数。

当我们将指针作为函数参数时，函数接收到的是指针变量的副本，而不是指针所指向的数据的副本。这意味着我们可以修改指针所指向的数据，而这种修改在函数外部也是有效的。

下面是一个示例代码，演示了如何使用指针作为函数参数：

#include <stdio.h>
void increment(int *ptr) {
    *ptr = *ptr + 1;
}
int main() {
    int num = 5;
    printf("num before increment: %d\n", num);
    increment(&num);
    printf("num after increment: %d\n", num);
    return 0;
}

在这个示例中，我们定义了一个名为increment的函数，它接收一个指向整型变量的指针作为参数。在increment函数内部，我们通过解引用指针来访问并修改指针所指向的数据。在main函数中，我们定义了一个整型变量num，并将其值初始化为5。然后，我们调用increment函数，并将num的地址作为参数传递给increment函数。在increment函数被调用后，num的值被增加了1，并在main函数中输出。

总之，指针在函数参数传递中的应用可以让我们直接修改函数外部的变量，而不是修改它们的副本。这使得在函数之间共享数据变得更加灵活和高效。

指针在函数参数传递中需要注意以下几点：

空指针：在使用指针作为函数参数时，需要确保指针不为NULL或空指针。否则，在函数内部解引用空指针会导致程序崩溃。
指针的类型：指针的类型必须与所指向的数据类型一致。否则，会导致解引用错误或程序崩溃。
指针的越界访问：在使用指针时，需要注意指针的越界访问问题。如果指针指向了不应该访问的内存位置，会导致程序崩溃或不可预期的行为。
返回局部变量的地址：在函数内部定义的局部变量是分配在栈上的，当函数执行结束时，局部变量的内存会被释放。因此，返回局部变量的地址是不安全的，会导致程序崩溃或不可预期的行为。
传递指针的地址：如果需要修改函数外部的指针，需要传递指针的地址给函数，而不是直接传递指针本身。否则，函数接收到的是指针的副本，无法修改原始指针。

总之，在使用指针作为函数参数时，需要注意空指针、类型一致性、越界访问、返回局部变量地址和传递指针地址等问题，以确保程序的正确性和稳定性。

指针在数组中的应用

指针在数组中的应用非常广泛，它们可以用来访问数组元素、修改数组元素、遍历数组等。

通过指针访问数组元素

我们可以使用指针来访问数组中的元素。例如，如果我们有一个整型数组arr和一个指向arr的指针p，我们可以使用p来访问arr中的元素。可以通过将p指向数组的首地址，然后通过解引用p来访问数组中的元素。

示例代码：

int arr[] = {1, 2, 3, 4, 5};
int *p = arr;  // p指向数组首地址
printf("%d\n", *p);  // 输出1，解引用p得到arr[0]的值
printf("%d\n", *(p+2));  // 输出3，解引用(p+2)得到arr[2]的值

通过指针修改数组元素

我们还可以使用指针来修改数组中的元素。例如，如果我们有一个整型数组arr和一个指向arr的指针p，我们可以使用p来修改arr中的元素。可以通过将p指向数组中的某个元素，然后通过解引用p来修改该元素的值。

示例代码：

int arr[] = {1, 2, 3, 4, 5};
int *p = &arr[1];  // p指向arr[1]的地址
*p = 10;  // 修改arr[1]的值为10
printf("%d\n", arr[1]);  // 输出10

通过指针遍历数组

我们还可以使用指针来遍历数组。例如，如果我们有一个整型数组arr和一个指向arr的指针p，我们可以使用p来遍历arr中的所有元素。可以通过将p指向数组的首地址，然后使用循环来遍历整个数组。在循环中，可以使用解引用p来访问数组中的元素。

示例代码：

int arr[] = {1, 2, 3, 4, 5};
int *p = arr;  // p指向数组首地址
for(int i=0; i<5; i++) {
    printf("%d ", *p);  // 输出当前元素的值
    p++;  // p指向下一个元素
}

指针在字符串中的应用

在C和C++编程语言中，指针在字符串处理中扮演着重要的角色。字符串通常被表示为字符数组或字符指针，而指针则可以用来访问、修改和操作这些字符串。

以下是一些在字符串中使用指针的例子：

通过指针访问字符串中的字符：

char str[] = "Hello, World!";
char *ptr = str; // ptr指向str的第一个字符
printf("%c\n", *ptr); // 输出'H'

使用指针遍历字符串：

char str[] = "Hello, World!";
char *ptr = str; // ptr指向str的第一个字符
while (*ptr != '\0') { // 循环直到遇到字符串结束符'\0'
    printf("%c", *ptr); // 输出当前字符
    ptr++; // ptr指向下一个字符
}

使用指针修改字符串中的字符：

char str[] = "Hello, World!";
char *ptr = str; // ptr指向str的第一个字符
*ptr = 'h'; // 修改第一个字符为'h'
printf("%s\n", str); // 输出"hello, World!"

使用指针比较字符串：

char str1[] = "Hello";
char str2[] = "Hello";
char *ptr1 = str1; // ptr1指向str1的第一个字符
char *ptr2 = str2; // ptr2指向str2的第一个字符
while (*ptr1 && *ptr2) { // 循环直到遇到不同的字符或到达字符串结束符'\0'
    if (*ptr1 != *ptr2) { // 如果当前字符不同，则字符串不同
        printf("Strings are different\n");
        return;
    }
    ptr1++; // ptr1指向下一个字符
    ptr2++; // ptr2指向下一个字符
}

使用指针进行字符串连接：

char str1[] = "Hello";
char str2[] = ", World!";
char *ptr1 = str1; // ptr1指向str1的第一个字符
char *ptr2 = str2; // ptr2指向str2的第一个字符
while (*ptr2) { // 循环直到遇到字符串结束符'\0'
    *ptr1 = *ptr2; // 将ptr2的字符复制到ptr1所指向的位置
    ptr1++; // ptr1指向下一个位置
    ptr2++; // ptr2指向下一个字符
}
*ptr1 = '\0'; // 在连接后的字符串末尾添加结束符'\0'
printf("%s\n", str1); // 输出"Hello, World!"

使用指针查找字符串中的子字符串：

char str[] = "Hello, World!";
char *substr = "World"; // 子字符串为"World"
char *ptr = str; // ptr指向str的第一个字符
while (strncmp(ptr, substr, strlen(substr)) == 0) { // 循环直到找到子字符串或到达字符串结束符'\0'
    printf("Substring found!\n");
    return;
}
printf("Substring not found!\n");

7.使用指针进行字符串的复制：

可以使用指针来复制一个字符串。可以将源字符串的指针和目标字符串的指针同时指向第一个字符，然后通过移动这两个指针来逐个复制字符。最后将目标字符串的结尾设置为 null 终止符。

char source[] = "Hello, World!";
char destination[20];
char *src = source;
char *dest = destination;
while ((*dest++ = *src++) != '\0');
printf("%s\n", destination); // 输出"Hello, World!"

指针在数据结构中的应用

指针在数据结构中的应用主要表现在以下几个方面：

创建和操作复杂的数据结构：通过使用指针，可以创建复杂的数据结构，如链表、树、图等。这些数据结构在内存中可能分散存储，通过指针可以方便地访问和操作这些数据结构中的元素。
动态内存分配：使用指针可以进行动态内存分配，即在程序运行时根据需要动态地为数据结构分配内存空间。这使得数据结构的创建和大小可以根据实际需求进行调整，提高了程序的灵活性和效率。
修改和更新数据：通过指针可以直接修改数据结构中的元素值。在遍历数据结构时，可以使用指针来更新数据，而无需复制整个数据结构。
优化内存使用：使用指针可以避免不必要的内存复制，从而减少内存消耗。例如，当需要在函数中修改传入的数据时，可以使用指针来直接修改数据，而无需创建数据的副本。
提高程序效率：使用指针可以避免在数据结构中进行昂贵的复制操作。在处理大型数据结构时，使用指针可以提高程序的效率。
实现复杂的数据操作：通过使用指针，可以方便地实现复杂的数据操作，如反转链表、查找二叉树中的最大值等。这些操作在具有指针支持的数据结构中可以更简单、高效地实现。
辅助排序和搜索算法：在排序和搜索算法中，指针可以用来指向待比较的元素，从而辅助算法的执行。例如，在快速排序算法中，指针可以用来指向子数组的起始位置，以便递归地进行排序。

总之，指针在数据结构中的应用使得数据结构的创建、操作和管理更加灵活、高效和方便。然而，需要注意的是，不当的使用指针也可能会导致程序错误、内存泄漏等问题，因此在使用指针时要谨慎并遵循良好的编程实践。

关于格式字符串

%d：这是用于输出有符号十进制整数的格式化输出符号。例如，如果你有一个变量 int num = -10;，那么 printf(“%d”, num); 将会打印出 “-10”。
%u：这是用于输出无符号十进制整数的格式化输出符号。例如，如果你有一个变量 unsigned int num = 10;，那么 printf(“%u”, num); 将会打印出 “10”。
%lu：这是用于输出无符号长整型（long unsigned int）的格式化输出符号。例如，你可以用它来打印出更大的整数。比如，unsigned long int num = 123456789012345;，那么 printf(“%lu”, num); 将会打印出 “123456789012345”。
%f：这是用于输出浮点数的格式化输出符号。例如，你可以用它来打印出小数。比如，float num = 3.14;，那么 printf(“%f”, num); 将会打印出 “3.140000”。
%s：这是用于输出字符串的格式化输出符号。例如，如果你有一个字符串 char* str = “Hello, world!”;，那么 printf(“%s”, str); 将会打印出 “Hello, world!”。
%c：这是用于输出字符的格式化输出符号。例如，如果你有一个字符 char ch = ‘a’;，那么 printf(“%c”, ch); 将会打印出 “a”。
%p：这是用于输出指针的值的格式化输出符号。例如，如果你有一个整数指针 int* ptr = #，那么 printf(“%p”, ptr); 将会打印出指针的十六进制表示。
%x：这是用于以十六进制输出一个整数的格式化输出符号。例如，如果你有一个整数 int num = 255;，那么 printf(“%x”, num); 将会打印出 “ff”。
%o：这是用于以八进制输出一个整数的格式化输出符号。例如，如果你有一个整数 int num = 255;，那么 printf(“%o”, num); 将会打印出 “377”。
%%：这是一个特殊的格式化符号，它表示打印一个百分号（%）。例如，如果你想打印出 “50%”，你可以使用 printf(“%d%%”, 50);