到现在为止你应该知道C是一种低级语言，没有什么能比指针更好。指针是通过“指向”内存位置而不是存储变量本身的值来获取变量值的变量。这允许一些方便的技巧，并且还使我们能够访问数组和文件处理等。

type *var-name;

制作和使用指针

#include <stdio.h>

 int main(void){
    double my_double_variable = 10.1;
    double * my_pointer;

    my_pointer = &my_double_variable;

    printf("value of my_double_variable: %f\n", my_double_variable);

    ++my_double_variable;

    printf("value of my_pointer: %f\n", * my_pointer);

    return 0;
 }

输出：

value of my_double_variable: 10.100000
value of my_pointer: 11.100000

在此代码中，有两个声明。第一个是典型的变量初始化，它创建一个double并将其设置为10.1。我们的声明中的新内容是*的用法。星号（ * ）通常用于乘法，但是当我们通过将它放在变量前面来使用它时，它会告诉C这是一个指针变量。

下一行告诉编译器实际上在哪里。通过使用&以这种方式，它成为'解除引用运算符'，并返回它正在查看的变量的内存位置。

考虑到这一点，让我们再看一下这段代码：

double *my_pointer;
 // my_pointer now stored the address of my_double_variable
 my_pointer = &my_double_variable;

my_pointer已被声明，并且已被声明为指针。 C编译器现在知道my_pointer将指向一个内存位置。下一行使用&为my_pointer分配一个内存位置值。

现在让我们来看看代码的内存位置意味着什么：

printf("value of my_double_variable: %f\n", my_double_variable);

// Same as my_double_variable = my_double_variable + 1
// In human language, adding one to my_double_variable
++my_double_variable;

printf("value of my_pointer: %f\n", *my_pointer);

请注意，为了在*my_pointer获取数据的值，您需要告诉C您想要获取变量指向的值。尝试在没有该星号的情况下运行此代码，您将能够打印内存位置，因为这是my_variable变量实际保存的内容。

您可以像使用标准变量一样在单个语句中声明多个指针，如下所示：

int *x, *y;

请注意， *在每个变量之前都是必需的。这是因为将指针视为变量的一部分而不是数据类型的一部分。

指针的实际用途

数组

指针的最常见应用是在数组中。您将在稍后阅读的数组允许一组变量。你实际上不必处理*和&来使用数组，但这就是他们在幕后所做的事情。

功能

有时您想要调整函数内部变量的值，但如果您只是传递变量值，则该函数将使用变量的副本而不是变量本身。相反，如果传入指向变量内存位置的指针，则可以从其正常范围之外访问和修改它。这是因为您正在触摸原始内存位置本身，允许您调整函数中的某些内容并在其他位置进行更改。与“按值调用”相反，这称为“按引用调用”。

以下程序在专用swap函数内swap两个变量的值。为此，变量通过引用传入。

/* C Program to swap two numbers using pointers and function. */
 #include <stdio.h>
 void swap(int *n1, int *n2);

 int main()
 {
    int num1 = 5, num2 = 10;

    // address of num1 and num2 is passed to the swap function
    swap( &num1, &num2);
    printf("Number1 = %d\n", num1);
    printf("Number2 = %d", num2);
    return 0;
 }

 void swap(int * n1, int * n2)
 {
    // pointer n1 and n2 points to the address of num1 and num2 respectively
    int temp;
    temp = * n1;
    * n1 = * n2;
    * n2 = temp;
 }

输出

Number1 = 10
Number2 = 5

num1和num2的地址或存储单元被传递给函数swap ，并由函数内部的指针*n1和*n2表示。因此，现在指针n1和n2指向num1和num2的地址。

所以，现在指针n1和n2分别指向num1和num2的地址。

当指针的值改变时，指向的存储器位置中的值也相应地改变。

因此，对* n1和* n2的更改反映在main函数中的num1和num2中。

指针作为功能的参数

当我们将任何参数传递给函数时，我们正在制作参数的副本。让我们看看这个例子

#include <stdio.h>

 void func(int);

 int main(void) {
    int a = 11;
    func(a);
    printf("%d",a);// print 11


    return 0;
 }
 void func(int a){
 a=5
 printf("%d",a);//print 5
 }

在上面的例子中，我们正在函数func中更改整数a的值，但我们仍然在main函数中使用11。这是因为在整数a的函数副本中已经作为参数传递，所以在这个函数中我们无法访问main函数中的'a'。

那你怎么能用另一个函数改变main中定义的整数的值呢？ POINTERS在这里扮演角色。当我们提供指针作为参数时，我们可以访问该参数的地址，我们可以使用此参数进行任何操作，结果将随处显示。下面是一个我们想要完全相同的例子......

通过解除引用n1和n2 ，我们现在可以修改n1和n2指向的内存。这允许我们更改main函数中在其正常范围之外声明的两个变量num1和num2的值。函数完成后，两个变量现在交换了它们的值，如输出中所示。

内存位置技巧

只要可以避免，最好保持代码易于阅读和理解。在最好的情况下，您的代码将讲述一个故事 - 如果您大声朗读它将具有易于阅读的变量名称，并且您将使用偶尔的注释来阐明代码行的作用。

因此，使用指针时应该小心。很容易让你混淆调试或让别人阅读。但是，可以用它们做一些非常巧妙的事情。

看看这段代码，它将大小写变为小写：

#include <stdio.h>
#include <ctype.h>

 char *lowerCase (char *string) {
    char *p = string;
    while (*p) {
        if (isupper(*p)) *p = tolower(*p);
        p++;
    }
    return string;
 }

这首先是一个字符串（当你进入数组时你会学到的东西）并遍历每个位置。请注意p ++。这会增加指针，这意味着它正在查看下一个内存位置。每个字母都是一个内存位置，因此指针会以这种方式查看每个字母并决定每个字母要做什么。

Const Qualifer

限定符const可以应用于任何变量的声明，以指定其值不会被更改（这取决于存储const变量的位置，我们可以通过使用指针来更改const变量的值）。

指向变量的指针

我们可以改变ptr的值，我们也可以改变指向的对象ptr的值。下面的代码片段解释了变量的指针

#include <stdio.h>
 int main(void)
 {
    int i = 10;
    int j = 20;
    int *ptr = &i;        /* pointer to integer */
    printf("*ptr: %d\n", *ptr);

    /* pointer is pointing to another variable */
    ptr = &j;
    printf("*ptr: %d\n", *ptr);

    /* we can change value stored by pointer */
    *ptr = 100;
    printf("*ptr: %d\n", *ptr);

    return 0;
 }

指向常数的指针

我们可以将指针更改为指向任何其他整数变量，但不能使用指针ptr更改指向的对象（实体）的值。

#include <stdio.h>
 int main(void)
 {
    int i = 10;
    int j = 20;
    const int *ptr = &i;    /* ptr is pointer to constant */

    printf("ptr: %d\n", *ptr);
    *ptr = 100;        /* error: object pointed cannot be modified
                     using the pointer ptr */

    ptr = &j;          /* valid */
    printf("ptr: %d\n", *ptr);

    return 0;
 }

常量指向变量的指针

在这里我们可以改变指针所指向的变量的值。但我们无法改变指向的指针另一个变量。

#include <stdio.h>
 int main(void)
 {
   int i = 10;
   int j = 20;
   int *const ptr = &i;    /* constant pointer to integer */

   printf("ptr: %d\n", *ptr);

   *ptr = 100;    /* valid */
   printf("ptr: %d\n", *ptr);

   ptr = &j;        /* error */
   return 0;
 }

常量指针指向常量

上面的声明是指向常量变量的常量指针，这意味着我们不能改变指针指向的值，也不能将指针指向其他变量。

#include <stdio.h>

 int main(void)
 {
    int i = 10;
    int j = 20;
    const int *const ptr = &i; /* constant pointer to constant integer */

    printf("ptr: %d\n", *ptr);

    ptr = &j;            /* error */
    *ptr = 100;        /* error */

    return 0;
 }

回顾

指针是变量，但它们不存储值，而是存储内存位置。
*和&分别用于访问存储器位置的值和访问存储器位置。
指针对C的一些基本特征很有用。

C中的指针与数组

大多数情况下，指针和数组访问可以被视为相同的行为，主要的例外是：

1）sizeof运算符

sizeof(array)返回数组中所有元素使用的内存量
sizeof(pointer)仅返回指针变量本身使用的内存量

2）＆运营商

＆array是＆array [0]的别名，并返回数组中第一个元素的地址
＆pointer返回指针的地址

3）字符数组的字符串文字初始化

char array[] = “abc”将数组中的前四个元素设置为'a'，'b'，'c'和'\ 0'
char *pointer = “abc”设置指向“abc”字符串地址的指针（可以存储在只读存储器中，因此不可更改）

4）指针变量可以赋值，而数组变量不能。

int a[10];
    int *p;
    p = a; /*legal*/
    a = p; /*illegal*/

5）允许对指针变量进行算术运算。

p++; /*Legal*/
    a++; /*illegal*/