指针

AlphaGuo 收录于类别 C

2023-12-31 2023-12-31 约 12017 字预计阅读 24 分钟

警告

本文最后更新于 2023-12-31，文中内容可能已过时。

指针

1、概念

当谈到C语言时，指针是一个非常重要的概念。指针是一个变量，其值为内存地址，即某个数据存储位置的地址。通过使用指针，你可以直接访问和操作内存中的数据。

以下是关于指针的一些重要概念和语法：

声明指针： 你可以使用*来声明指针变量。例如：
1 2

cCopy code int *ptr; // 声明一个整型指针

取地址操作符（&）： 你可以使用&操作符获取一个变量的地址。例如：

1
2


cCopy codeint num = 42;
int *ptr = &num;  // ptr现在包含变量num的地址

指针的解引用操作符（*）： 通过使用*操作符，你可以访问指针所指向的内存地址处的值。例如：

1
2
3


cCopy codeint num = 42;
int *ptr = &num;
printf("Value at the memory location pointed by ptr: %d\n", *ptr);

指针的算术操作： 指针可以进行算术操作，例如指针加法、减法等。这在数组和动态内存分配时很有用。

1
2
3
4
5


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

printf("Value at the first element: %d\n", *ptr);  // 输出第一个元素的值
printf("Value at the second element: %d\n", *(ptr + 1));  // 输出第二个元素的值

空指针： 指针也可以具有空值，表示它不指向任何有效的内存地址。可以使用NULL宏来给指针赋空值。
1 2

cCopy code int *ptr = NULL; // 空指针

指针和函数： 在函数中，你可以使用指针来传递变量的地址，以便在函数内部修改变量的值。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


cCopy codevoid increment(int *x) {
    (*x)++;  // 通过指针增加变量的值
}

int main() {
    int num = 10;
    increment(&num);  // 传递num的地址
    printf("Incremented value: %d\n", num);
    return 0;
}

2、

2.1.1多级指针

多级指针是指指针的指针，即一个指针变量存储的是另一个指针变量的地址。在C语言中，我们可以使用多级指针来处理更复杂的数据结构，如二维数组、链表等。多级指针的声明和使用可以通过多个星号来表示级数。

以下是一个简单的例子，说明了多级指针的概念：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


cCopy code#include <stdio.h>

int main() {
    int num = 42;
    int *ptr1 = &num;  // 一级指针，指向整数num的地址
    int **ptr2 = &ptr1;  // 二级指针，指向一级指针ptr1的地址

    // 输出变量num的值及通过一级和二级指针访问num的值
    printf("Value of num: %d\n", num);
    printf("Value through ptr1: %d\n", *ptr1);
    printf("Value through ptr2: %d\n", **ptr2);

    return 0;
}

在这个例子中，ptr1是一个一级指针，指向整数变量num的地址。ptr2是一个二级指针，指向一级指针ptr1的地址。通过**ptr2，我们可以访问到num的值。

多级指针在处理多维数组、动态内存分配以及复杂的数据结构时非常有用。例如，如果有一个二维数组，可以使用二级指针来方便地访问数组的元素：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


cCopy code#include <stdio.h>

int main() {
    int rows = 3, cols = 4;

    // 分配二维数组的内存
    int **matrix = (int **)malloc(rows * sizeof(int *));
    for (int i = 0; i < rows; ++i) {
        matrix[i] = (int *)malloc(cols * sizeof(int));
    }

    // 初始化二维数组
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j) {
            matrix[i][j] = i * cols + j;
        }
    }

    // 使用二级指针访问二维数组的元素
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j) {
            printf("%d ", matrix[i][j]);
        }
        printf("\n");
    }

    // 释放内存
    for (int i = 0; i < rows; ++i) {
        free(matrix[i]);
    }
    free(matrix);

    return 0;
}

在这个例子中，matrix是一个二级指针，用于表示二维数组。通过使用二级指针，我们可以方便地进行动态内存分配和数组元素的访问。

2.1.2指针运算

指针运算是指对指针变量进行的一系列数学运算。主要的指针运算包括指针的加法、减法以及递增和递减运算。这些运算允许在内存中移动指针，对数组进行访问，以及在动态内存分配中进行操作。

以下是一些常见的指针运算及其示例：

指针的加法和减法： 可以对指针进行加法和减法运算，其中加法和减法的结果取决于指针指向的数据类型的大小。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


cCopy code#include <stdio.h>

int main() {
    int numbers[] = {1, 2, 3, 4, 5};
    int *ptr = numbers;  // 指向数组的第一个元素

    // 使用指针的加法访问数组元素
    printf("Value at the first element: %d\n", *ptr);
    printf("Value at the second element: %d\n", *(ptr + 1));

    // 使用指针的减法访问数组元素
    printf("Value at the last element: %d\n", *(ptr + 4));

    return 0;
}

指针的递增和递减： 使用++和--运算符对指针进行递增和递减操作。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


cCopy code#include <stdio.h>

int main() {
    int numbers[] = {1, 2, 3, 4, 5};
    int *ptr = numbers;  // 指向数组的第一个元素

    // 使用指针的递增访问数组元素
    printf("Value at the first element: %d\n", *ptr);
    ptr++;
    printf("Value after increment: %d\n", *ptr);

    // 使用指针的递减访问数组元素
    ptr--;
    printf("Value after decrement: %d\n", *ptr);

    return 0;
}

指针运算和数组： 指针运算与数组密切相关，因为数组名本身就是一个指向数组第一个元素的指针。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


cCopy code#include <stdio.h>

int main() {
    int numbers[] = {1, 2, 3, 4, 5};
    int *ptr = numbers;  // 数组名是指向数组第一个元素的指针

    // 使用数组名和指针进行访问数组元素
    printf("Value at the first element: %d\n", numbers[0]);
    printf("Value at the second element using array name: %d\n", *(numbers + 1));
    printf("Value at the third element using pointer: %d\n", *(ptr + 2));

    return 0;
}

2.1.3指针数组

指针数组是一个数组，其元素都是指针。每个元素指向一个特定类型的数据。指针数组在C语言中常用于存储字符串，也可以用于存储其他类型的指针。

以下是关于指针数组的解释和一个简单的例子：

指针数组的声明： 可以使用以下语法声明指针数组：
1 2

cCopy code int *ptrArray[5]; // 声明一个包含5个指向整数的指针的数组
这表示 ptrArray 是一个包含5个元素的数组，每个元素都是指向整数的指针。
指针数组的初始化： 指针数组的元素可以初始化为指向相应类型的变量或动态分配的内存。
1 2

cCopy codeint num1 = 10, num2 = 20, num3 = 30; int *ptrArray[3] = {&num1, &num2, &num3};
这里，ptrArray 包含三个元素，每个元素都是指向整数的指针，分别指向 num1、num2 和 num3。

指针数组和字符串： 指针数组经常用于存储字符串。每个数组元素是一个指向字符串的指针。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


cCopy code#include <stdio.h>

int main() {
    char *names[] = {"Alice", "Bob", "Charlie", "David"};

    for (int i = 0; i < 4; ++i) {
        printf("Name %d: %s\n", i + 1, names[i]);
    }

    return 0;
}

在这个例子中，names 是一个指针数组，每个元素是一个指向字符串的指针。通过循环，我们可以遍历数组并打印每个字符串。

指针数组的主要优势在于能够灵活地存储不同类型的数据或不同长度的字符串。通过使用指针数组，可以更有效地管理和访问数据。

2.1.4指针作为函数的形参

你可以将指针作为函数的形参传递，以便在函数内部访问和修改调用者提供的数据。通过传递指针，你可以实现对函数外部数据的直接操作，而不是传递数据的副本。这种方式可以更有效地处理大型数据结构，避免不必要的内存开销。

以下是指针作为函数参数的一些基本概念和一个简单的例子：

指针作为函数形参的声明： 在函数声明和定义中，你可以将指针作为形参：
1 2

cCopy code void modifyValue(int *ptr);

使用指针修改函数外的变量： 通过传递指针，函数可以修改调用者提供的变量：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


cCopy code#include <stdio.h>

void modifyValue(int *ptr) {
    (*ptr)++;  // 通过指针递增变量的值
}

int main() {
    int num = 10;

    printf("Before: %d\n", num);
    modifyValue(&num);  // 传递num的地址
    printf("After: %d\n", num);

    return 0;
}

在这个例子中，modifyValue 函数通过指针修改了 num 的值，因为它接受一个指向整数的指针作为形参。

使用指针操作数组： 指针作为函数参数也特别适用于处理数组，因为数组名本身就是指向数组第一个元素的指针：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


cCopy code#include <stdio.h>

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

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

    printf("Original array: ");
    for (int i = 0; i < 5; ++i) {
        printf("%d ", numbers[i]);
    }
    printf("\n");

    squareElements(numbers, 5);

    printf("Squared array: ");
    for (int i = 0; i < 5; ++i) {
        printf("%d ", numbers[i]);
    }
    printf("\n");

    return 0;
}

在这个例子中，squareElements 函数接受一个整数指针和数组的大小，然后通过指针修改了数组中的元素，将每个元素的平方存储回数组。

通过使用指针作为函数参数，你可以更灵活地操作函数外的数据，避免不必要的数据复制。这在处理大量数据或需要在函数之间共享数据时非常有用。

2.1.5数组作为函数的形参

你可以将数组作为函数的形参传递，以便在函数内部对数组进行操作。当你传递一个数组给函数时，实际上传递的是数组的地址（第一个元素的地址）。这样，函数就能够直接访问数组的元素，而不需要传递整个数组的副本。

以下是关于数组作为函数形参的一些基本概念和一个简单的例子：

数组作为函数形参的声明： 在函数声明和定义中，可以将数组作为形参：
1 2

cCopy code void processArray(int arr[], int size);
注意，数组形参中不需要指定数组的大小。数组名传递的是数组的地址，而不是数组本身。

使用数组作为函数参数： 通过传递数组，函数可以对数组进行操作：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


cCopy code#include <stdio.h>

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

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

    printf("Original array: ");
    for (int i = 0; i < 5; ++i) {
        printf("%d ", numbers[i]);
    }
    printf("\n");

    processArray(numbers, 5);

    printf("Processed array: ");
    for (int i = 0; i < 5; ++i) {
        printf("%d ", numbers[i]);
    }
    printf("\n");

    return 0;
}

在这个例子中，processArray 函数接受一个整数数组和数组的大小，然后通过循环遍历数组，将每个元素的平方存储回数组。

指定数组大小的形参： 尽管在数组形参中不需要指定数组的大小，但你也可以明确指定数组大小：
1 2

cCopy code void processArray(int arr[5]);
这样做不会改变实际传递给函数的数组的大小，但可以在函数内部使用这个信息。

通过使用数组作为函数参数，你可以更灵活地操作数组数据，而不需要传递整个数组的副本。这对于处理大量数据或需要在函数之间共享数组时非常有用。

2.1.6指针作为函数的返回值

这种方式允许函数返回指向某种类型的数据的指针，而不是返回整个数据本身。通过这种方式，你可以有效地返回动态分配的内存、数组的首地址等。

以下是一些关于指针作为函数返回值的基本概念和一个简单的例子：

指针作为函数返回值的声明： 在函数声明和定义中，可以使用指针类型作为返回值：
1 2

cCopy code int* createArray(int size);
这表示 createArray 函数将返回一个指向整数的指针。

使用指针作为函数返回值： 函数可以通过动态分配内存来创建数组，并返回指向该数组的指针：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


cCopy code#include <stdio.h>
#include <stdlib.h>

int* createArray(int size) {
    int *arr = (int *)malloc(size * sizeof(int));
    for (int i = 0; i < size; ++i) {
        arr[i] = i + 1;
    }
    return arr;
}

int main() {
    int size = 5;
    int *resultArray = createArray(size);

    printf("Created array: ");
    for (int i = 0; i < size; ++i) {
        printf("%d ", resultArray[i]);
    }
    printf("\n");

    // Remember to free the dynamically allocated memory
    free(resultArray);

    return 0;
}

在这个例子中，createArray 函数动态分配了一个包含 size 个整数的数组，并返回指向这个数组的指针。在 main 函数中，我们使用返回的指针来访问和打印数组的元素，然后记得使用 free 函数释放动态分配的内存。

指针作为函数返回值的注意事项： 当函数返回指针时，需要确保在调用函数后释放相应的内存，以防止内存泄漏。此外，应该小心返回指向局部变量的指针，因为在函数返回后，局部变量将被销毁，留下一个悬挂指针。

通过使用指针作为函数的返回值，你可以有效地返回动态分配的内存、数组或其他动态生成的数据结构，使得函数更加灵活和通用。

2.1.7指针与字符数组

字符数组和指针之间有着密切的关系。字符串通常以字符数组的形式存储，而指针则经常用于处理字符串。下面是一些关于指针与字符数组的基本概念和一个简单的例子：

字符数组的声明： 字符数组是一组字符的集合，以null字符(’\0’)结尾。可以通过以下方式声明：
1 2

cCopy code char myString[10]; // 声明一个包含10个字符的字符数组
这里 myString 是一个字符数组，可以存储9个字符和一个null字符。
指针与字符数组： 字符数组的名称本身就是指向数组首元素的指针。
1 2

cCopy codechar myString[10]; char *ptr = myString; // 将数组名赋值给指针
ptr 现在指向 myString 数组的第一个字符。

使用指针处理字符数组： 可以使用指针遍历字符数组的元素。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


cCopy code#include <stdio.h>

int main() {
    char myString[] = "Hello";
    char *ptr = myString;

    // 使用指针遍历字符数组
    while (*ptr != '\0') {
        printf("%c ", *ptr);
        ptr++;
    }

    return 0;
}

在这个例子中，ptr 指向 myString 字符数组的第一个字符。通过使用 while 循环，我们遍历整个字符串，打印每个字符。

字符数组作为函数参数： 字符数组经常用作函数的参数，因为它们可以方便地表示字符串。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


cCopy code#include <stdio.h>

void printString(char *str) {
    while (*str != '\0') {
        printf("%c", *str);
        str++;
    }
    printf("\n");
}

int main() {
    char myString[] = "World";
    printString(myString);

    return 0;
}

在这个例子中，printString 函数接受一个字符数组的指针作为参数，然后打印字符串。

指针与字符数组的结合使用是C语言中处理字符串的基础。需要注意的是，字符串必须以null字符(’\0’)结尾，以便正确地被处理和打印。此外，使用指针来处理字符数组时，要确保不会越界访问字符数组。

2.1.8指针与字符串

字符串通常被表示为字符数组，而指针则经常用于处理字符串。C中的字符串是以null字符(’\0’)结尾的字符数组，而指针则用于指向字符串的首字符。以下是关于指针与字符串的一些基本概念和一个简单的例子：

字符串的表示： 字符串在C中是以字符数组的形式存在的，以null字符(’\0’)结尾，表示字符串的结束。
1 2

cCopy code char myString[] = "Hello";
在这个例子中，myString 是一个字符数组，存储了字符串 “Hello”，并以null字符结尾。
指针与字符串： 字符串名本身就是指向字符串首字符的指针。
1 2

cCopy codechar myString[] = "Hello"; char *ptr = myString; // 将数组名赋值给指针
ptr 现在指向 myString 字符数组的第一个字符。

使用指针处理字符串： 可以使用指针遍历字符串的元素。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


cCopy code#include <stdio.h>

int main() {
    char myString[] = "Hello";
    char *ptr = myString;

    // 使用指针遍历字符串
    while (*ptr != '\0') {
        printf("%c ", *ptr);
        ptr++;
    }

    return 0;
}

在这个例子中，ptr 指向 myString 字符数组的第一个字符。通过使用 while 循环，我们遍历整个字符串，打印每个字符。

指针与字符串的函数参数： 字符数组经常作为指针传递给函数，以便在函数内部处理字符串。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


cCopy code#include <stdio.h>

void printString(char *str) {
    while (*str != '\0') {
        printf("%c", *str);
        str++;
    }
    printf("\n");
}

int main() {
    char myString[] = "World";
    printString(myString);

    return 0;
}

在这个例子中，printString 函数接受一个字符数组的指针作为参数，然后打印字符串。

指针与字符串的结合使用是C语言中处理字符串的常见方式。需要注意的是，字符串必须以null字符(’\0’)结尾，以便正确地被处理和打印。在使用指针来处理字符串时，要确保不会越界访问字符数组。

2.1.9字符指针作为形参,指针拼接字符串

字符指针作为函数形参时，通常用于传递字符串。字符指针可以指向字符串的首字符，从而使得函数能够直接访问并处理字符串。在拼接字符串时，字符指针可以用于在已有字符串的末尾追加另一个字符串。

以下是关于字符指针作为形参以及指针拼接字符串的基本概念和一个简单的例子：

字符指针作为函数形参： 可以使用字符指针作为函数的形参，以便处理字符串。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


cCopy code#include <stdio.h>

void printString(char *str) {
    printf("%s\n", str);
}

int main() {
    char myString[] = "Hello, ";
    char greeting[] = "World!";

    // 将两个字符串拼接并传递给函数
    char result[20];  // 预留足够的空间存储拼接后的字符串
    sprintf(result, "%s%s", myString, greeting);
    printString(result);

    return 0;
}

在这个例子中，printString 函数接受一个字符指针作为形参，然后直接通过 %s 格式化符打印字符串。

指针拼接字符串： 使用 sprintf 函数可以将两个字符串拼接起来。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


cCopy code#include <stdio.h>

int main() {
    char myString[] = "Hello, ";
    char greeting[] = "World!";

    char result[20];  // 预留足够的空间存储拼接后的字符串
    sprintf(result, "%s%s", myString, greeting);

    printf("Concatenated string: %s\n", result);

    return 0;
}

在这个例子中，sprintf 函数将 myString 和 greeting 两个字符串拼接起来，并将结果存储在 result 字符数组中。请确保 result 有足够的空间来存储拼接后的字符串。

字符指针拼接字符串： 也可以使用字符指针来拼接字符串。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


cCopy code#include <stdio.h>

int main() {
    char myString[] = "Hello, ";
    char greeting[] = "World!";

    // 指向拼接后的字符串的指针
    char *result = malloc(strlen(myString) + strlen(greeting) + 1);
    strcpy(result, myString);
    strcat(result, greeting);

    printf("Concatenated string: %s\n", result);

    // 记得释放动态分配的内存
    free(result);

    return 0;
}

在这个例子中，使用 malloc 分配足够的内存来存储拼接后的字符串，然后使用 strcpy 和 strcat 函数将两个字符串拼接起来。最后，使用 free 释放动态分配的内存。

这些例子展示了如何使用字符指针作为函数形参，并使用指针拼接字符串。在实际应用中，确保处理字符串时不会发生越界访问，以及在动态分配内存时正确释放内存是非常重要的。

2.2.1const修饰

const 是一个关键字，用于声明常量或修饰变量，表示该变量的值不能被修改。const 修饰的变量在程序运行过程中是只读的，一旦被初始化，其值就不能再被改变。const 可以用于不同的上下文，包括修饰指针、函数参数、函数返回值等。

以下是一些关于 const 的基本概念以及一些例子：

const修饰变量： 使用 const 修饰变量声明一个常量。
1 2

cCopy code const int max_count = 100;
这里 max_count 被声明为一个常量，其值不能在程序的执行过程中被修改。
const修饰指针： 使用 const 修饰指针表示指针所指向的内容是只读的。
1 2

cCopy code const int* ptr; // 指向常量整数的指针
这里 ptr 是一个指向常量整数的指针，通过 ptr 可以读取整数的值，但不能通过 ptr 修改整数的值。
const修饰函数参数： 在函数参数中使用 const 表示函数不会修改传递给它的参数。
1 2 3

cCopy codevoid printMessage(const char* message) { printf("%s\n", message); }
这里 message 是一个指向常量字符的指针，表示在函数中不能通过 message 修改字符串内容。
const修饰函数返回值： 在函数返回值中使用 const 表示返回的值是只读的。
1 2 3

cCopy codeconst int getNumber() { return 42; }
这里 getNumber 函数返回一个常量整数，表示调用该函数的地方不能修改返回的整数。
const修饰结构体成员： 在结构体定义中使用 const 修饰成员表示结构体的成员是只读的。
1 2 3 4

cCopy codestruct Point { const int x; const int y; };
这里 x 和 y 是结构体 Point 的成员，它们被声明为常量，表示在结构体实例创建后，它们的值不能被修改。

通过使用 const 关键字，可以在程序中创建更加安全和可维护的代码，尤其是在声明常量、函数参数和指针等方面。在编写代码时，考虑使用 const 可以提高代码的可读性和可靠性。

2.2.2字符指针数组

字符指针数组是一个数组，其中的每个元素都是一个指向字符的指针。在C语言中，字符指针数组常用于存储字符串的集合，其中每个字符串是一个字符数组（字符串）的首地址。以下是一些关于字符指针数组的解释和一个简单的例子：

字符指针数组的声明： 可以通过以下语法声明字符指针数组：
1 2

cCopy code char *names[5]; // 声明一个包含5个指向字符的指针的数组
这表示 names 是一个包含5个元素的数组，每个元素都是指向字符的指针。
字符指针数组的初始化： 可以将每个元素初始化为指向相应字符串的指针。
1 2

cCopy code char *names[] = {"Alice", "Bob", "Charlie", "David"};
在这个例子中，names 是一个字符指针数组，每个元素是指向一个字符串的指针。

使用字符指针数组： 可以通过索引访问字符指针数组中的每个字符串。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


cCopy code#include <stdio.h>

int main() {
    char *names[] = {"Alice", "Bob", "Charlie", "David"};

    for (int i = 0; i < 4; ++i) {
        printf("Name %d: %s\n", i + 1, names[i]);
    }

    return 0;
}

在这个例子中，names 是一个字符指针数组，通过循环遍历数组并打印每个字符串。

字符指针数组和动态内存分配： 可以使用字符指针数组来存储动态分配的字符串。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


cCopy code#include <stdio.h>
#include <stdlib.h>

int main() {
    char *colors[3];

    // 动态分配内存并存储字符串
    colors[0] = (char *)malloc(10);
    colors[1] = (char *)malloc(10);
    colors[2] = (char *)malloc(10);

    // 初始化字符串
    strcpy(colors[0], "Red");
    strcpy(colors[1], "Green");
    strcpy(colors[2], "Blue");

    // 打印存储的字符串
    for (int i = 0; i < 3; ++i) {
        printf("Color %d: %s\n", i + 1, colors[i]);
    }

    // 释放动态分配的内存
    for (int i = 0; i < 3; ++i) {
        free(colors[i]);
    }

    return 0;
}

在这个例子中，colors 是一个字符指针数组，每个元素存储一个动态分配的字符串。

字符指针数组是在C语言中用于存储和处理字符串集合的常见数据结构。通过使用字符指针数组，可以有效地管理多个字符串，每个字符串的长度可以动态变化。需要注意的是，在使用字符指针数组时，确保指针指向的内存是有效的，以防止野指针和未定义行为。

2.2.3字符串指针数组作为main函数参数

main 函数可以接受命令行参数，其中可以使用字符串指针数组来表示这些参数。这样的字符串指针数组允许你在程序启动时从命令行传递参数，并通过 argc 和 argv 参数获取这些参数的数量和内容。

以下是关于字符串指针数组作为 main 函数参数的解释和一个简单的例子：

main 函数参数： main 函数可以接受两个参数，argc 表示命令行参数的数量，argv 是一个指向字符串指针数组的指针，其中存储了实际的参数值。
1 2 3 4

cCopy codeint main(int argc, char *argv[]) { // Your code here return 0; }

字符串指针数组的使用： argv 是一个指向字符串指针数组的指针，其中每个元素都是一个指向命令行参数的字符串指针。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


cCopy code#include <stdio.h>

int main(int argc, char *argv[]) {
    // 打印命令行参数的数量
    printf("Number of arguments: %d\n", argc);

    // 打印每个命令行参数
    for (int i = 0; i < argc; ++i) {
        printf("Argument %d: %s\n", i, argv[i]);
    }

    return 0;
}

在这个例子中，argc 表示命令行参数的数量，argv 是一个指向字符串指针数组的指针，循环遍历打印每个命令行参数。

运行程序并传递命令行参数： 编译程序后，在命令行中运行程序并传递一些参数。

1
2


bashCopy code
./my_program arg1 arg2 arg3

输出可能会类似于：

1
2
3
4
5


yamlCopy codeNumber of arguments: 4
Argument 0: ./my_program
Argument 1: arg1
Argument 2: arg2
Argument 3: arg3

通过使用字符串指针数组作为 main 函数的参数，你可以轻松地处理和获取命令行传递的参数。这对于需要在程序启动时接收一些配置或输入的情况非常有用。需要注意的是，第一个参数 argv[0] 通常是程序的名称，而实际的命令行参数从 argv[1] 开始。

2.2.4字符串处理拷贝连接

字符串处理在C语言中是一个常见而重要的任务。字符串的拷贝和连接是两个基本的字符串处理操作。在C语言中，可以使用一些标准库函数来执行这些操作，例如strcpy和strcat。

字符串拷贝（strcpy）： strcpy 函数用于将一个字符串拷贝到另一个字符串中。它的原型如下：

1
2


cCopy code
char *strcpy(char *destination, const char *source);

这个函数会把 source 字符串的内容复制到 destination 字符串中，直到遇到null字符(’\0’)。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


cCopy code#include <stdio.h>
#include <string.h>

int main() {
    char source[] = "Hello, World!";
    char destination[20];

    // 拷贝字符串
    strcpy(destination, source);

    printf("Source: %s\n", source);
    printf("Destination: %s\n", destination);

    return 0;
}

在这个例子中，strcpy 函数将 source 字符串的内容拷贝到 destination 字符数组中，然后打印两个字符串。

字符串连接（strcat）： strcat 函数用于将一个字符串连接到另一个字符串的末尾。它的原型如下：

1
2


cCopy code
char *strcat(char *destination, const char *source);

这个函数会把 source 字符串的内容连接到 destination 字符串的末尾，直到遇到null字符(’\0’)。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


cCopy code#include <stdio.h>
#include <string.h>

int main() {
    char destination[20] = "Hello, ";
    char source[] = "World!";

    // 连接字符串
    strcat(destination, source);

    printf("Source: %s\n", source);
    printf("Destination: %s\n", destination);

    return 0;
}

在这个例子中，strcat 函数将 source 字符串的内容连接到 destination 字符数组的末尾，然后打印两个字符串。

需要注意的是，在进行字符串拷贝和连接时，确保目标字符串的大小足够大，以防止发生缓冲区溢出。使用 strncpy 和 strncat 可以限制拷贝的字符数，从而提高安全性。此外，C标准库中还有其他一些字符串处理函数，可以根据需要选择使用。

2.2.5字符串处理比较函数

字符串处理比较函数用于比较两个字符串的内容。其中，strcmp 是最常用的比较函数之一。此函数返回一个整数，表示两个字符串的大小关系。

以下是关于字符串处理比较函数的解释和一个简单的例子：

字符串比较（strcmp）： strcmp 函数用于比较两个字符串。它的原型如下：

1
2


cCopy code
int strcmp(const char *str1, const char *str2);

返回值为：

如果 str1 小于 str2，则返回负数。
如果 str1 等于 str2，则返回零。
如果 str1 大于 str2，则返回正数。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


cCopy code#include <stdio.h>
#include <string.h>

int main() {
    char str1[] = "apple";
    char str2[] = "banana";

    int result = strcmp(str1, str2);

    if (result < 0) {
        printf("%s is less than %s\n", str1, str2);
    } else if (result == 0) {
        printf("%s is equal to %s\n", str1, str2);
    } else {
        printf("%s is greater than %s\n", str1, str2);
    }

    return 0;
}

在这个例子中，strcmp 函数比较两个字符串 str1 和 str2，并根据比较结果输出相应的信息。

忽略大小写的字符串比较： 如果希望忽略字符串大小写进行比较，可以使用 strcasecmp 函数（在一些系统上也可能被称为 stricmp）。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


cCopy code#include <stdio.h>
#include <strings.h>

int main() {
    char str1[] = "Apple";
    char str2[] = "apple";

    int result = strcasecmp(str1, str2);

    if (result == 0) {
        printf("%s is equal to %s (case-insensitive)\n", str1, str2);
    } else {
        printf("%s is not equal to %s (case-insensitive)\n", str1, str2);
    }

    return 0;
}

在这个例子中，strcasecmp 函数比较两个字符串，忽略大小写。

需要注意的是，这些比较函数是按字典顺序进行比较的，对应于字符串的ASCII码值。当比较字符串时，确保字符串中的字符是按照预期的顺序排列的，以获得正确的比较结果。

2.3.1sprintf组包函数

在C语言中，sprintf 函数是一个用于格式化输出到字符串的函数。它允许将格式化的数据写入字符串中，而不是输出到标准输出流。sprintf 的格式和用法类似于 printf，但它将结果写入字符数组中而不是输出到屏幕。

以下是关于 sprintf 的解释和一个简单的例子：

sprintf 函数原型： sprintf 函数的原型如下：
1 2

cCopy code int sprintf(char *str, const char *format, ...);
- str 是一个指向字符数组的指针，表示数据将被写入的目标字符串。
- format 是一个格式控制字符串，规定了如何格式化输出的。
- ... 表示可变参数，用于提供格式化字符串中指定的数据。

sprintf 的使用： 下面是一个简单的例子，演示如何使用 sprintf 格式化字符串：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


cCopy code#include <stdio.h>

int main() {
    char buffer[50];
    int num = 42;
    float pi = 3.14159;

    // 使用 sprintf 将格式化的数据写入字符串
    sprintf(buffer, "The number is %d and the value of pi is %.2f", num, pi);

    // 打印包含格式化数据的字符串
    printf("%s\n", buffer);

    return 0;
}

在这个例子中，sprintf 函数将整数 num 和浮点数 pi 格式化并写入字符数组 buffer。然后，使用 printf 打印包含格式化数据的字符串。

注意，sprintf 可能会导致缓冲区溢出，因此在使用时确保目标缓冲区足够大，以容纳格式化后的字符串。如果要控制缓冲区的大小，可以使用 snprintf 函数，该函数允许指定最大写入的字符数。

2.3.2sscanf拆包函数

sscanf 函数是一个用于从字符串中解析数据的函数。它允许从一个格式化的字符串中读取数据，并将其存储到变量中。sscanf 的格式和用法与 scanf 相似，但它从字符串中读取数据而不是从标准输入流中。

以下是关于 sscanf 的解释和一个简单的例子：

sscanf 函数原型： sscanf 函数的原型如下：
1 2

cCopy code int sscanf(const char *str, const char *format, ...);
- str 是一个指向包含要解析的数据的字符串的指针。
- format 是一个格式控制字符串，规定了如何解析输入的数据。
- ... 表示可变参数，用于提供变量的地址，这些变量将用于存储解析后的数据。

sscanf 的使用： 下面是一个简单的例子，演示如何使用 sscanf 从字符串中解析数据：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


cCopy code#include <stdio.h>

int main() {
    char input[] = "The number is 42 and the value of pi is 3.14";
    int num;
    float pi;

    // 使用 sscanf 从字符串中解析数据
    sscanf(input, "The number is %d and the value of pi is %f", &num, &pi);

    // 打印解析后的数据
    printf("Parsed number: %d\n", num);
    printf("Parsed value of pi: %.2f\n", pi);

    return 0;
}

在这个例子中，sscanf 函数从字符串 input 中解析整数 num 和浮点数 pi，然后使用 printf 打印解析后的数据。

与 sprintf 一样，使用 sscanf 时需要确保字符串中的数据和格式化字符串的格式相匹配，以防止解析错误。此外，确保提供给 sscanf 的变量地址是有效的，以便数据正确地存储在这些变量中。

2.3.3strchr

strchr 函数用于在字符串中查找特定字符的第一次出现，并返回该字符的指针。如果未找到指定的字符，strchr 返回一个空指针（NULL）。该函数的原型如下：

1
2


cCopy code
char *strchr(const char *str, int c);

str 是要搜索的字符串。
c 是要查找的字符的ASCII值。

以下是一个使用 strchr 函数的简单示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


cCopy code#include <stdio.h>
#include <string.h>

int main() {
    const char *str = "Hello, World!";
    char target = 'W';

    // 使用 strchr 查找字符 'W' 在字符串中的位置
    char *result = strchr(str, target);

    if (result != NULL) {
        printf("Character '%c' found at position: %ld\n", target, result - str);
    } else {
        printf("Character '%c' not found in the string.\n", target);
    }

    return 0;
}

在这个例子中，strchr 函数被用来查找字符 ‘W’ 在字符串中的位置。如果找到了字符 ‘W’，则打印其在字符串中的位置；否则，打印未找到的消息。

需要注意的是，strchr 返回的是字符在字符串中的地址（指针），因此要获取字符在字符串中的位置，可以通过计算地址差来得到。在实际使用中，需要确保目标字符在字符串中存在，以避免访问空指针。

2.3.4strstr

strstr 函数用于在字符串中查找子字符串的第一次出现，并返回子字符串的指针。如果未找到子字符串，strstr 返回一个空指针（NULL）。该函数的原型如下：

1
2


cCopy code
char *strstr(const char *haystack, const char *needle);

haystack 是要搜索的字符串。
needle 是要查找的子字符串。

以下是一个使用 strstr 函数的简单示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


cCopy code#include <stdio.h>
#include <string.h>

int main() {
    const char *haystack = "Hello, World!";
    const char *needle = "World";

    // 使用 strstr 查找子字符串 "World" 在字符串中的位置
    char *result = strstr(haystack, needle);

    if (result != NULL) {
        printf("Substring \"%s\" found at position: %ld\n", needle, result - haystack);
    } else {
        printf("Substring \"%s\" not found in the string.\n", needle);
    }

    return 0;
}

在这个例子中，strstr 函数被用来查找子字符串 “World” 在字符串中的位置。如果找到了子字符串，打印其在字符串中的位置；否则，打印未找到的消息。

需要注意的是，strstr 返回的是子字符串在字符串中的地址（指针），因此要获取子字符串在字符串中的位置，可以通过计算地址差来得到。在实际使用中，需要确保子字符串在字符串中存在，以避免访问空指针。

2.3.5strtok

它用于将字符串拆分为一系列标记（token）。strtok 函数的原型如下：

1
2


cCopy code
char *strtok(char *str, const char *delimiters);

str 是要拆分的字符串，第一次调用时传入字符串，后续调用传入 NULL 继续拆分。
delimiters 是一个包含分隔符的字符串，指定在哪些字符处进行拆分。

下面是一个使用 strtok 函数的简单示例，演示如何将一个字符串拆分为多个标记：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


cCopy code#include <stdio.h>
#include <string.h>

int main() {
    char str[] = "This,is,a,sample,string";
    const char delimiters[] = ",";

    // 第一次调用 strtok，传入要拆分的字符串
    char *token = strtok(str, delimiters);

    // 继续调用 strtok，传入 NULL 表示继续拆分
    while (token != NULL) {
        printf("Token: %s\n", token);

        // 继续调用 strtok，传入 NULL 表示继续拆分
        token = strtok(NULL, delimiters);
    }

    return 0;
}

在这个例子中，strtok 函数被用来将字符串 “This,is,a,sample,string” 按逗号 , 拆分为多个标记。循环遍历每个标记，并打印出来。

需要注意的是，strtok 在每次调用时会修改传入的字符串，用 null 字符 \0 替换分隔符。此外，该函数不会在每次调用时返回新分隔符之间的字符串，而是维护一个静态指针来记录当前位置。因此，多次调用 strtok 时应小心，确保不会在不同的位置上操作同一个字符串。

2.3.6atoi

atoi 是C语言标准库中的一个函数，用于将字符串转换为整数（ASCII to Integer）。它的原型如下：

1
2


cCopy code
int atoi(const char *str);

str 是要进行转换的字符串。

atoi 函数会从字符串中读取整数，直到遇到非数字字符为止。以下是一个简单的示例，演示如何使用 atoi 函数将字符串转换为整数：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


cCopy code#include <stdio.h>
#include <stdlib.h>

int main() {
    const char *str = "12345";

    // 使用 atoi 将字符串转换为整数
    int result = atoi(str);

    printf("Converted integer: %d\n", result);

    return 0;
}

在这个例子中，atoi 函数被用来将字符串 “12345” 转换为整数。转换后的整数存储在变量 result 中，并通过 printf 打印出来。

需要注意的是，atoi 在遇到第一个非数字字符时会停止转换。如果字符串以非数字字符开头，或者包含浮点数表示（如 “123.45”），atoi 将只返回起始部分的整数。此外，atoi 不提供错误检测机制，因此在使用时应确保字符串可以正确转换为整数。在更严格的情况下，可以考虑使用 strtol 函数，它提供更多的控制和错误检测。

2.4.1字符反转

字符反转是指将字符串中的字符顺序颠倒过来。在C语言中，可以通过交换字符串中的字符来实现反转。以下是一个简单的例子，演示如何实现字符串反转：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


cCopy code#include <stdio.h>
#include <string.h>

void reverseString(char *str) {
    int length = strlen(str);
    int start = 0;
    int end = length - 1;

    while (start < end) {
        // 交换首尾字符
        char temp = str[start];
        str[start] = str[end];
        str[end] = temp;

        // 移动指针
        start++;
        end--;
    }
}

int main() {
    char myString[] = "Hello, World!";

    // 反转字符串
    reverseString(myString);

    // 打印反转后的字符串
    printf("Reversed String: %s\n", myString);

    return 0;
}

在这个例子中，reverseString 函数接受一个字符数组作为参数，并通过迭代遍历字符串，交换首尾字符的位置，从而实现字符串的反转。在 main 函数中，我们将字符串 “Hello, World!” 传递给 reverseString 函数，然后打印反转后的字符串。

需要注意的是，这种方法是针对字符数组的反转。如果你想反转一个动态分配的字符串（使用 malloc 或 calloc 分配的字符串），确保不会超出字符串的边界，并处理空字符串的情况。在实际应用中，可以使用更复杂的数据结构或库函数来更灵活地进行字符串反转。

目录

指针

指针

1、概念

2、

2.1.1多级指针

2.1.2指针运算

2.1.3指针数组

2.1.4指针作为函数的形参

2.1.5数组作为函数的形参

2.1.6指针作为函数的返回值

2.1.7指针与字符数组

2.1.8指针与字符串

2.1.9字符指针作为形参,指针拼接字符串

2.2.1const修饰

2.2.2字符指针数组

2.2.3字符串指针数组作为main函数参数

2.2.4字符串处理拷贝连接

2.2.5字符串处理比较函数

2.3.1sprintf组包函数

2.3.2sscanf拆包函数

2.3.3strchr

2.3.4strstr

2.3.5strtok

2.3.6atoi

2.4.1字符反转

相关内容

目录

指针

指针

1、概念

2、

2.1.1多级指针

2.1.2指针运算

2.1.3指针数组

2.1.4指针作为函数的形参

2.1.5数组作为函数的形参

2.1.6指针作为函数的返回值

2.1.7指针与字符数组

2.1.8指针与字符串

2.1.9字符指针作为形参,指针拼接字符串

2.2.1const修饰

2.2.2字符指针数组

2.2.3字符串指针数组作为main函数参数

2.2.4字符串处理拷贝连接

2.2.5字符串处理比较函数

2.3.1sprintf组包函数

2.3.2sscanf拆包函数

2.3.3strchr

2.3.4strstr

2.3.5strtok

2.3.6atoi

2.4.1字符反转

相关内容

文件操作pro

结构体强化

多维数组

内存分区

指针强化