C语言中的指针（上）

最新推荐文章于 2024-07-24 22:47:03 发布
最新推荐文章于 2024-07-24 22:47:03 发布
阅读量320 收藏
点赞数 2
分类专栏： C语言 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52309640/article/details/132484642
版权

目录

一、基本概念

1.变量的存储空间

2.定义指针

3.引用与解引用

二、指针的算术运算、类型以及通用指针

1.指针的算数运算

2.指针类型以及通用型指针

三、指向指针的指针（pointers to pointers）

四、函数传值以及传引用

1.局部变量

2.从存储地址出修改局部变量

五、指针和数组以及数组作为函数参数

1.指针与数组

2.数组作为函数参数

六、指针和字符数组

1.创建一个字符数组

2.字符数组作为函数参数

3.字符数组的存储方式

一、基本概念

1.变量的存储空间

       通常我们所说的内存是计算机的随机内存即RAM，并且不同的数据类型分配到的存储空间的大小也各不相同；整数类型数据 int 分配到的存储空间大小为 4bytes，字符类型的数据 char 分配到的存储空间为 1bytes，浮点数 float 分配到的存储空间为 4bytes。

2.定义指针

      指针的本质就是一个整数类型的变量，用来存放被指向数据的地址，即 int *p = &a; 代表的是创建一个指针 p 用来存储变量 a 的地址，其中 & 代表的是取得数据 a 的地址。

#include<stdio.h>

int main()
{
    int a = 3; 
    int *p = &a;
    printf("%d\n", p); 

    return 0;

}

运行上面的代码得到的结果为：

即数据 a 的存储地址为 e21ff898。

3.引用与解引用

       在定义指针时使用到的 * 表示的是引用，即得到被指向数据的地址，而在指针的前面使用 * 表示的是解引用，用来表示被指向数据的值。

#include<stdio.h>

int main()
{
    int a = 3; 
    int *p = &a;
    printf("%d\n", p);
    printf("%d\n", *p);  //输出p代表的地址的值，即a的值，为3

    return 0;
}

运行上面的代码，前一行打印语句的输出为 a 的地址，由于第二行打印是对指针 p 进行反引用，所以第二行打印语句的输出为 a 的值 3。

二、指针的算术运算、类型以及通用指针

1.指针的算数运算

       指针代表的是被指向数据的地址，因此指针的值加一或者减一，并不会使得被指向数据的值产生相应的加一或者减一的效果，而且指针加一或者减一，则指向的地址进行反引用得到的数据将会是乱码，而不是一个确切的值。

#include<stdio.h>

int main()
{
    int a = 3; 
    int *p = &a;
    
    printf("Address of a is : %d.\n", p);
    printf("size of integer is: %d bytes.\n", sizeof(int));
    printf("value of (p + 1) is : %d.\n", p + 1); //如果p = 2004，则 p+1 = 2008；这是因为整型的地址占用为4个字节
    printf("value at address of p is : %d.\n", *p);
    printf("value at address of (p + 1) is : %d.\n", *(p + 1)); //得到的是一个垃圾值

    return 0;
}

运行上面的代码，得到的结果如下：

从上面的结果中可以看出，由于整型数据的存储大小为4个字节，因此对指针 p 进行加一的操作得到的数据是在原来的 p 的值上加了4，而不是单纯的加一操作。并且对 p+1 进行解引用得到的数值将会是一个垃圾值。

2.指针类型以及通用型指针

       指针是强类型的（这是因为指针不止用来存储地址，也可以用它来解引用那些地址所对应的内容），也就是说不同的数据类型需要相对应类型的指针来进行指向；比如一个整型变量，指针指向的是第一个字节的位置，则计算机读取时向后再数三个字节得到该变量的值，若是使用其它类型的指针，则无法正确完成指向；虽然 float 类型的数据也分配有四个字节，但它和整型的数据并不相同，因此利用整型的指针并没有办法正确存储 float 类型的数据。

#include<stdio.h>

int main()
{
    int a = 3; 
    int *p = &a;
    
    float *p0 = &a;
    printf("While int pointer is used, address of a is : %d, value of a is ; %d;\n", p, *p);//172 = 1010 1100
    printf("While float pointer is used, address of a is : %d, value of a is ; %d;\n\n", p0, *p0); //可以看出两种类型的指针对应的地址是一样的，但值不一样

    return 0;
}

运行上面的代码，得到的结果如下：

可以从结果中看出，对于整数类型的数据，使用浮点数类型的指针会得到错误的指向结果。

       void 类型的指针，也被称为通用型指针，由于通用指针没有使用到任何类型的定义，因此不能对其进行反解。

#include<stdio.h>

int main()
{
    int a = 3; 
    int *p = &a;
    
    void *p0 = p; //通用指针没有使用到任何类型的定义，因此不能对其进行反解
    printf("While int pointer is used, address of a is : %d, value of a is ; %d;\n", p, *p);//172 = 1010 1100
    printf("While void pointer is used, address of a is : %d, value of a is ; %d;\n\n", p0, *p0); //可以看出两种类型的指针对应的地址是一样的，但值不一样

    return 0;
}

运行上面的代码，则会发现程序报错：

通用型指针，不会指向任何类型的地址，故无法进行解引用。

三、指向指针的指针（pointers to pointers）

       指针是用来表示被指向数据的地址的，故指针的本质是一个整型的变量，所以指向指针的指针的数据类型也是整型。

        当定义了一个指针 int *p，则可以用 int **q 来存储指针 p 的地址，也可以使用 int ***r来存储指针 q 的地址，以此类推即可。

#include<stdio.h>

int main()
{

    int a = 3;
    int *p = &a;

    printf("Address of data a is : %d.\n", p);
    int **P = &p;
    int ***q = &P;
    printf("Address of pointer p is : %d.\n", P);
    printf("Value of p(Address of a) is : %d.\n", *P);
    printf("Value of a is : %d.\n", *(*P));
    printf("Address of P is : %d.\n", q);
    printf("Value of P(address of p) is : %d.\n", *q);
    printf("Value of p(address of a) is : %d.\n", *(*q));
    printf("Value of data a is : %d.\n", ***q);
    ***q = 10;
    printf("a = %d\n", a);
    **q = *p +2;
    printf("%d\n", **q);
    
    return 0;
}

运行上述代码得到的结果为：

在上面的代码中使用 p 来作为指针指向数据 a 的地址，P 作为指针来指向指针 p 的地址，q 作为指针来指向指针 P 的地址；通过解引用可以利用指针来改变被指向数据的值。

四、函数传值以及传引用

1.局部变量

       当我在一个函数中声明一个变量，那么该变量称为局部变量，也就是说只能在该函数中对该变量进行修改以及处理。

#include<stdio.h>

int Increment(int a)
{
    a = a + 1;  
}

int main()
{
    int a = 3;

    Increment(a);
    printf("a = %d.\n", a);
    return 0;
}

运行上面的代码，若不考虑自定义函数 Increment() 中的局部变量的影响，则可以推测输出的 a 的值应该为 4。但通过运行代码得到的结果如下：

这说明在自定义函数中 a 是一个局部变量，和主函数中的 a 并不是同一个变量，也就是说在自定义函数中的变量存储的地址和主函数中的变量存储的地址是不一样的，所以我们需要从指针的层面对它们进行修改。

2.从存储地址出修改局部变量

由于局部变量和主函数中的变量的存储地址不相同，因此可以使用指针从变量的地址处进行处理。

#include<stdio.h>

void Increment(int *p)
    {
        *p = (*p) + 1;
    }


int main()
{
    int a = 3;
    int *p = &a;

    Increment(&a);
    printf("a = %d.\n", a);
    return 0;
}

运行上面的代码，可以实现利用自定义函数对主函数中的变量进行修改。

        在自定义函数中的参数被称为形参，主函数中的参数称为实参，自定义函数的调用过程中实现了将实参转化到形参中进行处理的目的，这就是函数的调用。利用指针以及解引用进行处理的时候能够实现从参数的存储地址处修改参数而不是从参数的值处修改参数，从而达到处理数据的目的，这种方法被称为传引用。

五、指针和数组以及数组作为函数参数

1.指针与数组

       定义一个数组后，使用指针指向该数组时，指针存储的是数组中的第一个元素的地址。数组名本身也可以用来代表一个地址，在使用指针时甚至可以不用取地址符，即可以写为 int *p = &A[i]或者 int *p = A + i。

#include<stdio.h>

int main()
{
    int b[] = {0, 1, 2, 3, 4};

    int *P = &b;       //得到的是数组中的第一个元素的地址，在此处甚至可以不用对数组b取地址
    int *P0 = &b[0];   //得到第一个元素的地址，此处也可以写成: int *P0 = b + 1;后面的写法类推
    int *P1 = &b[1];   //得到第二个元素的地址，与第一个元素的地址相差4个字节
    int *P2 = &b[2];   //与前一个元素的地址相差4个字节
    int *P3 = &b[3];   //与前一个元素的地址相差4个字节
    int *P4 = &b[4];   //与前一个元素的地址相差4个字节

    printf("Address of P is : %d.\n", P);
    printf("Address of P0 is : %d.\n", P0);
    printf("Address of P1 is : %d.\n", P1);
    printf("Address of P2 is : %d.\n", P2);
    printf("Address of P3 is : %d.\n", P3);
    printf("Address of P4 is : %d.\n", P4);


    //利用该循环使用两种不同的方法输出数组及地址
    for(int j = 0; j < 5; j++)
    {
        printf("%d:\n", j + 1);
        printf("Address  = %d\n", &b[j]);  //直接取数组元素地址即可
        printf("Value = %d\n", b[j]);      //打印数组元素
        printf("Address = %d\n", b + j);   //数组名可以直接代表元素地址
        printf("Value = %d\n", *(b + j));  //对数组名解引用得到数组元素的值
    }

    P0 = P0 + 1;
    printf("%d\n", *P0);  //输出的值为b[1]的值，即输出1
 
    return 0;
}

运行上面的代码得到的输出为：

       从运行结果中可以看出，数组名可以直接作为地址进行指针指向，且 *p = A + i 和 *p = A[i] 的运行效果是一样的。

2.数组作为函数参数

       当数组作为一个参数时，编译器不会分配整个数组长度的空间用来进行存储，而是只分配出一个同名的指针的存储空间，即将 A 转化成为了 *A，并没有拷贝变量的值，而是直接拷贝了变量的地址，也就是说函数在传递变量的过程就是一个引用的过程。并且不同的操作系统中指针分配到的存储空间是不一样的，64位操作系统中占用了8个字节，32位操作系统中占用了4个字节。

尝试编写函数来计算数组的大小：

int SumofElements(int A[]) 
{
    int i, sum = 0;
    int size = sizeof(A)/sizeof(A[0]); //数组整体字节数目比上一个元素的字节数目
    printf("SOE - Size of A = %d, size of A[0] = %d.\n",sizeof(A), sizeof(A[0]));
    for(i = 0; i < size; i++)
    {
        sum += A[i];
    }
    return sum;
}

       上面这个函数尝试以数组作为函数形参，并在函数中使用 for 循环来计算数组中的各个元素之和，但运行该自定义函数后发现计算结果是错误的。

#include<stdio.h>

int SumofElements(int A[]) 
{
    int i, sum = 0;
    int size = sizeof(A)/sizeof(A[0]); //数组整体字节数目比上一个元素的字节数目
    printf("SOE - Size of A = %d, size of A[0] = %d.\n",sizeof(A), sizeof(A[0]));
    for(i = 0; i < size; i++)
    {
        sum += A[i];
    }
    return sum;
}

int main()
{
     //数组作为函数参数
    int A[] = {1, 2, 3, 4, 5};
    int size = sizeof(A)/sizeof(A[0]); //数组整体字节数目比上一个元素的字节数目
    int total = SumofElements(A);
    printf("Main - Size of A = %d, size of A[0] = %d.\n",sizeof(A), sizeof(A[0]));
    printf("Sum of elements = %d.\n", total);
    return 0;
}

       从运行的结果中可以看出，该函数在计算数组中的元素之和时发生了错误，这是因为在作为函数参数时数组名被默认为是一个指针，而不是整个数组。

对自定义函数进行改写：

#include<stdio.h>

int SumofElements(int A[], int size) 
{
    int i, sum = 0;
    for(i = 0; i < size; i++)
    {
        sum += A[i];
    }
    return sum;
}

int main()
{
    int A[] = {1, 2, 3, 4, 5};
    int size = sizeof(A)/sizeof(A[0]); //数组整体字节数目比上一个元素的字节数目
    int total = SumofElements(A, size);
    printf("Main - Size of A = %d, size of A[0] = %d.\n",sizeof(A), sizeof(A[0]));
    printf("Sum of elements = %d.\n", total);

    return 0;
}

运行得到的结果为：

可以看出该计算结果是正确的。

六、指针和字符数组

1.创建一个字符数组

       在 C 语言中，创建一个字符数组需要的长度一般要比存储在该数组中的元素的个数多一，比如创建一个字符数组其中包含 john 这个字符串，那么可以将该字符数组的长度设置为5或者大于5即可，这是因为在字符数组中存储字符串之后，计算机并不知道字符串中的最后一个字母在哪一位上，故需要在最后一个元素的后面加上一个 NULL（'\0'）元素，用来指明字符串的结束，也就是说字符数组是以 '\0' 结尾的。

#include<stdio.h>

int main()
{
      char C[4];
      C[0] = 'j';
      C[1] = 'o';
      C[2] = 'h';
      C[3] = 'n';
      
      printf("%s", C);
      return 0;
}

运行上面的代码得到的结果为：

       可以看出，由于没有将字符数组的长度设置为大于字符串长度的值，打印出来的字符串没有一个合适的结尾。因此对代码进行修改：

#include<stdio.h>

int main()
{
      char C[4];
      C[0] = 'j';
      C[1] = 'o';
      C[2] = ‘h';
      C[3] = 'n';
      C[4] = '\0';
      
      printf("%s", C);
      return 0;
}

得到正确的结果为：

       但是无论字符数组的长度设置为多大， 函数 sizeof() 都不会考虑字符串末尾添加的 NULL 元素，也就是说使用该函数得到的数组的长度均为其中的字符串的长度。

       如果不想在定义字符数组的时候添加末尾的 NULL 元素，可以在定义字符数组的时候直接编写好其中需要增加的字符串，这样得到的字符数组进行打印不会出现错误的值。

#include<stdio.h>

int main()
{
    char C[] = "john";
    printf("%s", C);
    return 0; 
}

2.字符数组作为函数参数

       当字符数组作为函数参数时，效果和一般的数组是一样的，也就是说字符数组在函数中也是被传引用，函数中传递的只是该数组的基地址（首个元素的地址），并不会将所有元素的地址在函数中进行传递。

#include<stdio.h>

int print(char *C)
{
    int i = 0;
    while(C[i] != '\0')    //此处注意是单引号
        {
             printf("%c", C[i]); 
             i++;
        }
    printf("\n");
}

int main()
{   
    char C[20] = "HELLO"
    char* A;
    A = C;
    print(A); 
    return 0;
}

 运行上面的代码得到的结果为：

 也可以将上面代码中的自定义函数进行修改，将其中的打印方式修改如下：

printf("%c", *(C + i));

效果和前面的是一样的，因为上面的修改是对数组指针进行了解引用。

还可以对自定义函数进行如下的修改：

int print(char *C)
{
    while(*C != '\0')
        { 
            printf("%c", *C);
            C++;
        }
    printf("\n");
}

得到的结果和前面仍然是一样的。

3.字符数组的存储方式

#include<stdio.h>

int print(char *C)
{
    while(*C != '\0')
        {
            printf("%c", *C);
            C++;
        }
    printf("\n");
}


int main()
{
    char C[20] = "HELLO";

    print(C);
    return 0;
}

上面的这部分代码和之前的一样，运行的时候得到的结果如下：
 而且这部分代码可以在自定义函数中对字符串进行修改：

#include<stdio.h>

int print(char *C)
{
    C[0] = 'A';
    while(*C != '\0')
        {
            printf("%c", *C);
            C++;
        }
    printf("\n");
}


int main()
{
    char C[20] = "HELLO";

    //char *C = "HELLO";
    print(C);
    return 0;
}

 得到的运行结果为：

从结果中可以看出，在自定义函数中实现了对字符串的修改。

主函数中的字符串也可以使用其他的定义方式：

#include<stdio.h>

int print(char *C)
{
    while(*C != '\0')
        {
            printf("%c", *C);
            C++;
        }
    printf("\n");
}


int main()
{

    char *C = "HELLO";
    print(C);
    return 0;
}

运行得到的结果为：

 尝试在自定义函数中对字符串进行修改：

#include<stdio.h>

int print(char *C)
{
    C[0] = 'A';
    while(*C != '\0')
        {
            printf("%c", *C);
            C++;
        }
    printf("\n");
}


int main()
{

    char *C = "HELLO";
    print(C);
    return 0;
}

运行上述代码会发现程序无法输出：

也就是说使用下面的定义字符串的方式时，无法在自定义函数中对字符串进行修改。

这是因为，当使用上面的方式定义字符串时，是直接将整个数组存储在一起，因此可以对其中的一两个元素进行修改；但当使用下面的方式定义字符串时，时将字符串的地址作为变量进行传输，没办法在自定义函数中对其中的某个元素进行修改。

到这里算是总结完指针中的部分内容了，还有一大堆需要学习的东西，真的是非常的棘手。

一马归一码
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
c语言指针c语言指针c语言指针c语言指针c语言指针
08-30
c语言指针c语言指针c语言指针c语言指针c语言指针c语言指针c语言指针c语言指针c语言指针c语言指针c语言指针c语言指针c语言指针c语言指针c语言指针c语言指针c语言指针c语言指针c语言指针c语言指针c语言指针c语言指针...
C语言初阶指针.zip
01-14
以上只是C语言指针基础的简单介绍，实际应用中还有更多高级用法，如指针数组、指针作为函数返回值等。深入理解和熟练运用指针是掌握C语言的关键，也是许多系统编程和底层开发的基础。通过学习"《C语言初阶指针》"，...
C语言——指针
热门推荐
weixin_59796310的博客
01-26 11万+
C语言——指针
C语言中的指针详解
越陌度阡
11-04 5万+
1. 指针的定义 C语言中指针是一种数据类型，指针是存放数据的内存单元地址。 计算机系统的内存拥有大量的存储单元，每个存储单元的大小为1字节，为了便于管理，必须为每个存储单元编号，该编号就是存储单元的“地址”，每个存储单元拥有一个唯一的地址。 指针变量除了可以存放变量的地址外，还可以存放其他数据的地址，例如可以存放数组和函数的地址。 2. 指针的定义和初始化 格式：数据类型符 *指针变量名[=初始地址值]。 功能：定义指向“数据类型符”的变量或数组的指针变量，同时为其赋初值。
C语言中指针传参
weixin_47138646的博客
11-27 8947
目录C语言中指针传参一、如何改变参数的值1、常见的错误写法：2、解决办法使用指针二、与return进行比较1、使用return返回值：2、使用指针改变多个参数的值三、传入的参数是指针如何处理？使用指针的指针 C语言中指针传参 一、如何改变参数的值 1、常见的错误写法： 由于变量会随着栈的退出而销毁，所以下面的函数无法改变a的值。 #include<stdio.h> void f(int b){ //参数b初始化为1 b=3;//改变b的值为3 }//随着函数的结束，变量b被销毁，a
c语言—指针详解
Welcome to my blog.
08-04 2万+
文章目录一、指针是什么二、指针和指针变量1.左值与右值2.两者的区别1.指针2.指针变量3.如何使用三、指针和指针类型 一、指针是什么 指针，是C语言中的一个重要概念及其特点，也是掌握C语言比较困难的部分。指针也就是内存地址，指针变量是用来存放内存地址的变量，不同类型的指针变量所占用的存储单元长度是相同的，而存放数据的变量因数据的类型不同，所占用的存储空间长度也不同。有了指针以后，不仅可以对数据本身，也可以对存储数据的变量地址进行操作。 指针就是地址，地址就是指针。 使用指针的目的是提高使用效率 二、指
C语言——指针详解（必收藏）
weixin_59174190的博客
04-04 7万+
1.什么是指针？ 1.1概念 简单的来说，指针就是地址。我们口头上说的指针其实指的是指针变量。指针变量就是一个存放地址的变量。 1.2指针的大小 指针在32位机器下是4个字节，在64位机器下是8个字节。注：（指针的大小与类型无关） 1.3指针类型的作用 上面涉及到指针的大小与指针类型无关，那么指针类型的作用是什么呢？ 指针解引用访问，使用的访问权限是多少 话不多说，上图！ 当一个int* 的指针+1，跳过4个字节；当一个char* 的指针+1，跳过1...
C语言的指针
把酒送清风的博客
10-24 2492
指针（pointer）是C语言最重要的（有时也是最复杂的）概念之一，是一个值为内存地址的变量，用于存储变量的地址。指针的第一个基本用法就是在函数间传递信息。概括地的说，如果主调函数不使用return返回的值，则必须通过地址才能改变主调函数（Main函数）中的变量值。
C语言-指针函数与函数指针
让你爱上电路设计
05-11 1万+
C语言-指针函数与函数指针
c语言中指针的作用是什么
weixin_42596214的博客
02-13 3724
C 语言中，指针是一个变量，其值为另一个变量的内存地址。指针可以用来存储内存地址，从而实现对内存中的数据进行操作。 指针的主要作用包括： 动态内存分配：指针可以用来在运行时动态分配内存。 传递数组：指针可以用来传递数组，从而使函数能够操作数组中的元素。 实现链表、树等数据结构：指针可以用来实现链表、树等数据结构。 指向函数：指针可以指向函数，从而实现回调函数等功能。 总的来说，指针是 ...
C语言中指针传递问题
weixin_42894555的博客
08-08 1万+
C语言中指针传递问题 要求：用C语言通过调用函数实现两个值的交换 例如：输入5,9 —– 输出9,5 不能到达预期的结果的代码 #include&amp;amp;amp;amp;lt;stdio.h&amp;amp;amp;amp;gt; void main() { void swap(int *p1, int *p2); int a,b; int *pointer_1,*pointer_2; scan...
C语言：指针偏移
MQ0522的博客
12-20 2274
指针的地址偏移量和保存这个地址的指针类型有关。 指针的类型占有的内存空间，就是 指针加1 的地址偏移量。
C语言中指针的用法C语言中指针的用法-综合文档
05-14
C语言中指针的用法C语言中指针的用法 intmain(void) {inta =10; } 指针存放地址,那么在计算机中是如何存放上面定义的a呢? 首先,a占4个字节,因为其是int类型,然后,int类型10的..
C语言中的指针
01-24
在C语言中，数组名实际上是一个指向数组首元素的指针。因此，我们可以使用指针来遍历数组。例如： ```c int arr[5] = {1, 2, 3, 4, 5}; int *ptr = arr; // ptr现在指向arr的第一个元素 for (int i = 0; i ; i++) { ...
笔记——C语言
最新发布
2301_80191662的博客
07-24 321
int 就是等价于signed int, short也是等价于signed short， long也是等价于signed long， long long也是等价于signed long long。char ---- char 到底是有符号还是无符号呢？编程是为了解决生活中的问题，计算机语言来写代码——得有能力描述生活中的问题，那么生活中有那么多数据，因此C语言中有许多的数据类型。运算符的返回值，C 语⾔只规定是⽆符号整数，并没有规定具体的类型，⽽是留给。这个转义字符，光标回退一个字符，到底会不会删除字符？
【C语言】函数
2402_85428625的博客
07-23 1236
1. 函数的概念 2. 库函数 2.1 标准库和头⽂件 2.2 库函数的使⽤⽅法 2.2.1 功能 2.2.2 头⽂件包含 2.2.3 实践 2.2.4 库函数⽂档的⼀般格式 3. ⾃定义函数 3.1 函数的语法形式 3.2 函数的举例 4. 形参和实参 4.1 实参 4.2 形参 4.3 实参和形参的关系 5. return语句 6. 数组做函数参数 7. 嵌套调⽤和链式访问 7.1嵌套调用 7.2 链式访问 8. 函数的声明和定义 8.1 单个⽂件 8.2 多个⽂件 8.3static 和 extern
【C语言】数组名的不同情况
学习笔记，与你共享的宝藏，记录学习过程的点滴，分享学习的心得体会
07-24 834
在C语言中，数组名在绝大多数情况下表现为指向数组第一个元素的指针。具体而言，当数组名出现在表达式中（除了作为函数参数时的特殊情况），它会被视为指向数组首元素的常量指针。这意味着你可以使用下标运算符来访问数组中的元素，也可以进行指针算术来遍历数组。然而，当数组名作为函数参数被传递时，它会退化为一个普通指针，失去了与原始数组大小和边界的相关信息。在函数内部，这个指针仅仅指向了传入数组的第一个元素，而不携带任何有关整个数组的信息，除非另外传递数组的大小。
30.【C语言】函数系列下
2401_85828611的博客
07-23 381
打印123，返回3作为参数给printf，打印3返回1作为参数给printf，打印1。*定义：将一个函数的返回值作为另外一个函数的参数，像链条一样将函数串起来就是函数。strlen函数的返回值作为printf的参数。查阅printf的返回值：字符的个数。3个printf，由里向外执行。*定义：函数之间的互相调用。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一马归一码

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值