C语言---数组难点梳理

已于 2022-05-19 20:32:43 修改
阅读量1k 收藏 9
点赞数 6
分类专栏： 编程语言学习 C learn 文章标签： c语言
于 2022-05-12 22:45:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_30782215/article/details/124739734
版权

目录

概述：

1. 一维数组代码demo：

2. 二维数组代码demo：

 3. 字符数组代码demo：

4. 数值型数组作为函数实参传递

5. 字符数组/指针作为函数实参传递

6. 数组作为函数返回值

概述：

C语言的语法不能靠死记硬背，而是需要理解，真正理解了背后的原理，C数组的难点也就不攻自破了。特别需要重点深入理解甚至死记的知识点如下：

  1. 计算机内存被分成一个个的内存单元，每个单元大小为一个字节，给每个单元一个编号就是这个单元的地址，地址也被称为指针。所以是否可以重新赋值就涉及到地址是否可以重新赋值，还有就是地址指向的值是否可以重新赋值。
  2. 数组占有连续的内存单元，所以非常适合指针操作(copy等操作效率更高)，所以数组名会被编译器自动隐式的转换成常量指针(有两个例外：对数组名取地址时；sizeof求数组内存大小时)，所以数组名只能加一指向下一个元素，但是不能把下一个元素的地址赋值给数组名，所以数组名永远指向第一个元素的地址。
  3. 字符串在C语言中是常量，所以C语言是没有字符串类型的，而是使用字符数组或字符指针来描述字符串常量。
  4. 字符数组里保存的是字符串常量，所以值不能重新赋，但是数组元素是单个字符变量，所以可以重新赋值，即可以针对单个元素重新赋值。
  5. 字符指针保存的是字符串常量的地址，字符串常量本身被保存在常量区。所以，指针是可以重新赋值指向新的地址的。但是，指针指向的值是字符串常量，所以指向的值不可以重新赋成其他字符串。但是如果指针指向的是字符数组，则可以通过strcpy来重新赋值。
  6. sizeof(变量名)：返回的是类型占用内存的大小，所以sizeof的参数可以是各种类型比如int，所以该值得大小在编译时就已经确定了。
  7. strlen(字符指针名/字符数组名)：返回字符串中真正字符的个数。不包括结尾字符。所以该值得大小必须到运行时才能确定。

 

 

1. 一维数组代码demo：

/*
 * author: tianqiang
 * date : 2022/05/12
 * description: 1）+1”就是偏移量问题：一个类型为T的指针的移动，是以sizeof(T)为移动单位。所以首先要明确指针类型。
 *              2) 数组名表示数组首元素的地址， 数组名 + 1 表示第2个元素的地址；
 *              3）对数组名取地址表示整个数组的地址，数组名取地址后再 + 1，表示尾指针，即紧跟数组最后一个元素的地址；
 *              4）形象对比：中国政府在北京市，北京市的政府也在北京市，但是两者显然是不同的；
 *              5）也可以认为，数组名表示的是一维数组，对数组名取地址可以认为是二维数组；
 *              6) 数组名，&数组名[0], &数组名 三者值相同，但是第三个与前两个含义不同
 *              7）数组名 + 1， &数组名[0] +1，值和意义都相同：第二个元素的地址
 */

#include <stdio.h>

int main () {
    int scoreArray[10] = {99, 89, 78, 90};
    printf("scoreArray size = %d \n", sizeof(scoreArray)); //数组占用的内存单元字节数：40
    printf("scoreArray element = %d \n", sizeof(scoreArray)/sizeof(int)); //数组分配的元素个数：10
    printf("scoreArray = %p, *scoreArray = %d \n", scoreArray, *scoreArray); //数组名是数组首元素的地址
    printf("scoreArray + 1 = %p, *(scoreArray + 1) = %d \n", scoreArray + 1, *(scoreArray + 1)); //数组名+1为第二个元素的地址
    printf("&scoreArray = %p, *(&scoreArray) = %p \n", &scoreArray, *(&scoreArray)); //数组名取地址，是整个数组的地址
    printf("&scoreArray + 1 = %p, *(&scoreArray + 1) = %d \n", &scoreArray + 1, *(&scoreArray + 1)); //数组名取地址后再+1是尾指针
    printf("&scoreArray[0] = %p \n", &scoreArray[0]);
    printf("&scoreArray[0] + 1 = %p, *(&scoreArray[0] + 1) = %d \n", &scoreArray[0] + 1, *(&scoreArray[0] + 1)); //完全等同于数组名

    return 0;
}
/* out put:
 * scoreArray size = 40 //编译器分配内存的总字节数。
 * scoreArray element = 10 //编译器分配总元素的个数，并不是实际元素的个数
 * scoreArray = 0x7fff030bb710, *scoreArray = 99 //数组名表示首元素的地址 类型：int *
 * scoreArray + 1 = 0x7fff030bb714, *(scoreArray + 1) = 89 //数组名 + 1：指向第二个元素
 * &scoreArray = 0x7fff030bb710, *(&scoreArray) = 0x7fff030bb710 //&数组名：数组的地址，类型：int (*)[10]
 * &scoreArray + 1 = 0x7fff030bb738, *(&scoreArray + 1) = -51099448 //&数组名+1：最后一个元素后面的地址
 * &scoreArray[0] = 0x7fff030bb710
 * &scoreArray[0] + 1 = 0x7fff030bb714, *(&scoreArray[0] + 1) = 89 //首元素地址+1：表示第二个元素的地址
 */

2. 二维数组代码demo：

/*
 * author: tianqiang
 * date : 2022/0512
 * description: 1) 二维数组可以看成一个一维数组，其元素又是一个一维数组；
 *              2）二维数组名表示第0行元素(一维数组)的地址，arr + i表示第i行元素(一维数组)的地址；
 *              2）所以后面的内容就可以过渡到一维数组知识里
 *              3）数组名就是指向数组第一个元素的指针,而其类型就是第一个元素的类型.
 *              4）T类型的指针移动，以sizeof(T)为移动单位
 *              5) 二维数组名aa, aa[0]，*aa，&aa值相等，但是意义不同。
 */

#include <stdio.h>

int main () {
    int array2[2][3] = {{1,2,3}, {44, 55, 66}};
    printf("array2 = %p, *array2 = %p, **array2 = %d \n", array2, *array2, **array2);
    printf("arrary2 + 1 = %p, *(array2 +1) = %p, **(array2 + 1) = %d \n", array2 + 1, *(array2 + 1), **(array2 + 1));

    printf("array2[0] = %p, *array2[0] = %d, array2[0][0] = %d \n", array2[0], *array2[0], array2[0][0]);

    return 0;
}
/*
 * out put:
 * array2 = 0x7ffe260e2b90, *array2 = 0x7ffe260e2b90, **array2 = 1 //二维数组名：第0行元素(一维数组)的地址
 * arrary2 + 1 = 0x7ffe260e2b9c, *(array2 +1) = 0x7ffe260e2b9c, **(array2 + 1) = 44 //二维数组名 + 1：第1行元素(一维数组)的地址
 * array2[0] = 0x7ffe260e2b90, *array2[0] = 1, array2[0][0] = 1
 *
 */

 3. 字符数组代码demo：

/*
 * author: tianqiang
 * date:   2022/05/13
 * description: 1) 字符数组名是指针常量指向数组首元素，可以+1，但是不能重新赋值
 *              2）字符指针名指向首字符，可以+1，也可以赋值，所以，字符指针名具体指向要根据上下文来定
 *              3）sizeof返回编译器针对该类型分配的内存大小
 *              4）strlen返回字符的实际个数，不包括'\0
 *              5）%s输出字符串，需要提供地址，而不是值
 *              6）%c输出字符，需要的是指，而不是地址
 *              7）字符数组：字符串直接保存在字符数组的内存单元里；
 *              8）字符指针：字符串被保存在常量区，字符指针保存了字符串的地址
 */

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

int main () {
    char cArray[] = "tianQiang";
    char cArrayError[35] = "qqqqq";
    char *cPointer = cArray;
    char *cPointerP = "tianQiang";

    printf("cArray = %s, sizeof(cArray) = %d, strlen(cArray) = %d \n", cArray, sizeof(cArray), strlen(cArray));
    printf("cArrayError = %s, strlen(cArrayError) = %d, sizeof(cArrayError) =%d  \n", cArrayError, strlen(cArrayError), sizeof(cArrayError));

    strcpy(cArrayError, cArray);
    printf("cArray = %s, cArrayError = %s \n", cArray, cArrayError);
    printf("strlen(cPointer) = %d, cPointer = %s, *cPointer = %c \n", strlen(cPointer), cPointer, *cPointer);
    printf("strlen(cPointerP) = %d, cPointerP = %s, *cPointerP = %c \n", strlen(cPointerP), cPointerP, *cPointerP);

    printf("cPointerP = ");
    while(*cPointerP) {
        printf(" %c", *(cPointerP++)); //字符指针可以重新赋值
    }
    printf("\n");
   // cArray++; //编译报错：eror: lvalue required as increment operand

    return 0;
}
/*
 * out put
 * cArray = tianQiang, sizeof(cArray) = 10, strlen(cArray) = 9            //sizeof返回编译器针对该类型分配的内存大小
 * cArrayError = qqqqq, strlen(cArrayError) = 5, sizeof(cArrayError) =35  //strlen返回字符的实际个数，不包括'\0'
 * cArray = tianQiang, cArrayError = tianQiang
 * strlen(cPointer) = 9, cPointer = tianQiang, *cPointer = t              //%s输出字符串，需要提供地址，而不是值
 * strlen(cPointerP) = 9, cPointerP = tianQiang, *cPointerP = t           //%c输出字符，需要的是指，而不是地址
 * cPointerP =  t i a n Q i a n g
 */

4. 数值型数组作为函数实参传递

 * author: tianqiang
 * date  : 2022/0515
 * description: 数值型数组名作为参数传递给函数
 *             1)  数组名被自动转换成首元素的地址；
 *             2） 遵守值传递，所以首元素的地址不会被改变；
 *             3） 但是由于实行参共用同一块内存地址，所以值会同时改变。
 */

#include <stdio.h>
const int PASS_SCORE = 60;
void printMathScore(const float *p, int n); //参数为指针类型，需要提供第二个参数提供数组的大小。
void changeScore(float *p, int n);
//void changeScore(float score[], int n); //最终还是会转换成指针

int main () {
    float mathScore[6] = {98, 37, 56, 61, 50, 49};
    printMathScore(mathScore, sizeof(mathScore)/sizeof(float)); //调用时，数组大小一般是计算得到。

    changeScore(mathScore, sizeof(mathScore)/sizeof(float));
    printMathScore(mathScore, sizeof(mathScore)/sizeof(float));

    return 0;
}

void changeScore(float *p, int n) {
    for(int i = 0; i < n; i++) {
        if ((*(p + i) < PASS_SCORE) && (PASS_SCORE - *(p + i) <= 10)) {
            *(p + i) = PASS_SCORE;
        }
    }
}

void printMathScore(const float *p, int n) { //如果不允许数组值被改变，就需要使用const关键字。
    printf("mathScore = ");
    for (int i = 0; i < n; i++) {
        printf("%f \t", *(p + i));
    }
    printf("\n");
}
/*
 * out put: 可以看到实参和形参的值都被改变了，但是一定要理解，首元素的地址没有改变，所以还是值传递的。
 * mathScore = 98.000000   37.000000       56.000000       61.000000       50.000000       49.000000
 * mathScore = 98.000000   37.000000       60.000000       61.000000       60.000000       49.000000
 */

5. 字符数组/指针作为函数实参传递

/*
 * author: tianqiang
 * date  :2022/05/15
 * description: 字符数组/字符指针作为函数实参传递
 *           1）字符指针由于有结尾标志，所以不需要传递size参数
 *           2）温故知新：字符数组仅仅可以针对字符元素重新赋值;数组名对应的指针可以+1，
 *                        但是不能重新赋值，所以数组名永远指向首元素
 *           3）温故知新：字符指针指向的是字符串常量，所以不能重新赋值。
 *                        但是字符指针本身可以重新赋值，指向其他地址的。
 *           4）温故知新：字符指针指向字符数组后，就可以通过strcpy函数进行整体赋值
 */

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

void changeName(char *name);
void changeCharArrayName(char *name);
int main () {
    char ch[] = "tianqiang"; //字符数组仅仅可以针对字符元素重新赋值
    ch[0] = 'd';
    //char *nameP = "tianqiang"; //字符指针是常量，不能重新赋值；
    char *nameP = ch; //字符指针指向字符数组后，就可以通过strcpy函数进行整体赋值。

    printf("nameP = %s \n", nameP);
    changeName(nameP);
    printf("after, nameP = %s \n", nameP);

    ch[0] = 'd';
    ch[1] = 'd';
    ch[2] = 'd';
    printf("ch = %s \n", ch);
    changeCharArrayName(ch);
    printf("after, ch = %s \n", ch);
}

void changeName(char *name) { //指向字符数组的指针可以用strcpy函数来重新赋值
    strcpy(name, "jian");
}

void changeCharArrayName(char *name) { //char数组本身只能单个元素重新赋值
    for (int i =0; i < strlen(name); i++) {
        name[i] = 'm';
    }
}
/*
 * out put:
 * nameP = dianqiang
 * after, nameP = jian
 * ch = dddn
 * after, ch = mmmm
 */

6. 数组作为函数返回值

 /*
  2  * author: qianqiang
  3  * date:   2022/0517
  4  * description: 数组作为函数返回值
  5  *              1）明确不能直接返回数组，而是返回该类型的指针
  6  *              2）字符指针常量不能重新赋值，所以先指向字符数组，才可以重新赋值
  7  */
  8
  9 #include <stdio.h>
 10 #include <string.h>
 11
 12 int * returnScore(int *array, int size);
 13 void printScore(int *p, int size);
 14 char * returnName(char *p);
 15
 16 int main () {
 17     int score[] = {88, 99, 56};
 18     int *pScore = score;
 19     char name[] = "tianqiangqi";
 20     char *pName = name;
 21     pScore = returnScore(score, sizeof(score)/sizeof(int));
 22     printf("score = %p, pScore = %p \n", score, pScore);
 23
 24     printf("pScore = ");
 25     printScore(pScore, sizeof(score)/sizeof(int));
 26     printf("score = ");
 27     printScore(score, sizeof(score)/sizeof(int));
 28     printf("22222 score = %p, pScore = %p \n", score, pScore);
 29
 30     printf("pName = %s, pName addr = %p \n", pName, pName);
 31     pName = returnName(name);
 32     printf("pName = %s, pName addr = %p \n", pName, pName);
 33
 34 }
 35
 36 int * returnScore(int *p, int size) {
 37     for(int i = 0; i < size; i++) {
 38         *(p + i) = *(p+i) - 50;
 39     }
 40     return p;
 41 }
 42
 43 char * returnName(char *p) {
 44     strcpy(p, "jianmeiLiu");
 45     return p;
 46 }
 47
 48 void printScore(int *p, int size) {
 49     for(int i = 0; i < size; i++) {
 50         printf("%d \t", *(p + i));
 51     }
 52     printf("\n");
 53 }
 54 /*
 55  * out put:
 56  * score = 0x7ffeedc736a0, pScore = 0x7ffeedc736a0
 57  * pScore = 38     49      6
 58  * score = 38      49      6
 59  * 22222 score = 0x7ffeedc736a0, pScore = 0x7ffeedc736a0
 60  * pName = tianqiangqi, pName addr = 0x7ffeedc736ac
 61  * pName = jianmeiLiu, pName addr = 0x7ffeedc736ac
 62  *
 63  */

enjoife
关注
  • 6
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【C语言学习笔记】：8道经典的数组、指针相关面试题
Jiangziyadizi的博客
01-30 581
复制完后，实参的地址和形参的地址没有任何联系，对形参地址的修改不会影响到实参，但是对形参地址所指向对象的修改却能直接反映在实参中，这是因为形参所指向的对象就是实参的对象。前面我们说过，指针传递本质上也是值传递，要想在子函数修改str的值，必须要传递指向str的指针，因此子函数要传递的是str的地址，这样通过指针方式修改str的值，将malloc的内存首地址赋值给str。"进行了拷贝，该局部变量是存放在栈中的，当函数退出时，栈被清空，p会被释放，因此返回的是一个已经被释放的内存地址，这样做是错误的。
C语言一/二维数组经典例题及解析
xiaobai729的博客
09-27 1万+
C语言关于数组的的经典例题,思想比较基础且重要,基础不好的同学可以认真领悟一下。
C语言题解 | 消失的数字&轮转数组
北 海的博客
10-24 1705
在 数据结构 | 时间复杂度与空间复杂度 一文中，分享了两个和复杂度相关的例题，现在就来给大家分享下这两个题的多种解法
【C语言】数组详解，初学者一看就懂
热门推荐
我的主页
11-08 2万+
本期讲解：什么是C语言数组？数组的创建与初始化、数组在内存中的存储、越界数组、为什么数组下标是从0开始的？数组作为函数参数，冒泡排序函数的错误设计、数组名到底是什么？冒泡排序函数的正确设计。
生怕你看不懂的C语言“数组”详解（万字讲解）
2302_77069214的博客
08-19 278
生怕你看不懂的C语言数组万字详解
c语言学习-第七章-数组完整.pptx
11-14
c语言学习-第七章-数组完整.pptx
C语言数组-C语言实现使用动态数组来构建栈结构.zip
最新发布
03-02
c语言数组 C语言数组_C语言实现使用动态数组来构建栈结构
C语言数组-C语言实现使用静态数组实现循环队列.zip
03-02
c语言数组 C语言数组_C语言实现使用静态数组实现循环队列
C语言数组-C语言实现使用动态数组来构建循环链表.zip
03-02
c语言数组
华软C语言答案-实验8-数组 (2).doc
04-29
1、(基础题)输入一个字符串，请编程统计其中的字母、数字、空格(含制表符)、标点符号的个数...解题思路：①用一维字符数组可以存放一个字符串，这里可定义一个二维字符数组来存放10个字符串；②排序可以用“冒泡”算法
c语言数组有什么错误,C语言学到数组了，感觉有点难，你能举例子说说数组怎么用吗？使用数组要注意什么吗？...
weixin_36368715的博客
05-18 328
C语言已经是非常简洁的编程语言了，数组肯定不是多余的语法了。可以说，数组基本上是所有现代高级编程语言不可或缺的语法了。但是C语言中的数组并不难，题主也不用太担心自己学不会。我的上一个回答，讨论了C语言中的结构体，它是一种复合数据类型，有了结构体，C语言可以应对各种复杂的数据模型，比如上一节的平行四边形问题。但是有些问题，就算是结构体，也很难解决。请看下面这个问题：小明班级有 60 个人，期末考试出...
c语言数组难点简述,C语言难点专题——数组和指针
weixin_39653442的博客
05-22 293
数组和指针是C中常见的数据结构，和基本类型不同，这两个数据结构可以表示多个数据的集合。在理解和区分这两个概念前，先了解一下内存模型。内存就相当于街道两边的房子，内存地址，就是房子的门牌号。内存和房子一样，可以存放需要的数据。现在问题就来了， 怎么描述一排排的房子【内存数据】呢?这里有两个方案，第一种，就是数组，第二种，就是指针。 这两个东东用来描述“连续且有相同结构的内存数据”。这两种数据的共有特...
c语言数组的难点,c语言中的数组——重点、难点.ppt
weixin_42518035的博客
05-22 428
c语言中的数组——重点、难点第七章 数组 7.1 一维数组的定义和引用(掌握) 7.2 二维数组的定义和引用(理解,掌握) 7.3 字符数组(掌握) 变量与数组的实质 变量的实质是，就指的是存储单元，变量的类型就是该存储单元的类型它指明了该存储单元占几个字节，如何存入数据及存入数据的类型。变量名是为了引用变量而设置的，它的实质是该存储单元地址的别称。 数组定义为：同一类型数据的有序集合。其...
C语言数组的一些常见问题
Zz22333的博客
01-26 3099
1.实参与形参的区别 函数的参数分为形参和实参两种。形参出现在函数定义中，在整个函数体内都可以使用，离开该函数则不能使用。实参出现在主调函数中，进入被调函数后，实参变量也不能使用。形参和实参的功能是作数据传送。发生函数调用时，主调函数把实参的值传送给被调函数的形参从而实现主调函数向被调函数的数据传送。 函数的形参和实参具有以下特点： a. 形参变量只有在被调用时才分配内存单元，在调用结束
C语言中关于数组问题思考
Black_Cat_33的博客
02-19 683
学习过程中对数组一些问题的思考
c语言刷题 数组——困难
qq_62083722的博客
04-20 2064
题目：满足特异条件的数列。输入m和n（20≥m≥n≥0），求出满足以下方程式的正整数数列i1,i2,…,in，使得i1+i2+…+in=m，且i1≥i2≥…≥in。例如： 当n=4，m=8时，将得到如下5个数列： 5 1 1 1 4 2 1 1 3 3 1 1 3 2 2 1 2 2 2 2 **输入格式要求：“%d” 提示信息：“Please enter requried terms (<=10):” " their sum:" **输
C语言重难点
dmm128073411的博客
04-29 575
其中，type是数组中元素的数据类型，arrayName是数组的名称，arraySize是数组元素的数量。1 };定义指针变量时需要使用"*"（星号）符号来标识该变量是一个指针类型。int * p;定义好指针变量后，我们就可以使用“&”符号来获得变量的地址并将其分配给这个指针变量。int x = 10;p = & x;指针是C语言中最基本也是最难以理解的概念之一。掌握指针的基础知识和操作方法是非常重要的。在使用指针时，应该注意处理指针的边界情况，并避免出现错误和漏洞。
c语言数组常犯的错误大汇总,浅谈初学C语言常犯的几点错误
weixin_39705193的博客
05-17 2799
【摘要】《C语言程序设计》课程是计算机专业的重要基础课程之一，C语言具有数据结构复杂，知识点繁多，较难掌握这一特点，它的理论性和实践性都很强，对于没有编程语言基础的学生来说学习起来非常困难。本文对初学者在学习C语言中常遇到的错误作以归纳总结，供初学者及教学者分析参考。【关键字】C语言，初学，错误1、分号的使用错误1)忘记加分号。最初上机编写C程序，这几乎是每个人必犯的错误，分号是C语句的组成部分，...
工程师编程，C语言学习，关于数组的一些问题
qq_42615643的博客
11-25 412
硕士阶段开始了专业课学习，也就是工程师编程，涉及到的编程语言有C、C++和嵌入式编程语言。 当然，再从基础开始打起，那就是从C开始了。 这次的问题就是谈到数组(Array)了。 在谈及这个问题时，我会从三个方面来思考： 1、数组的定义是什么，也就是何为数组？ 2、如何在数组中填充元素(数据)？ 3、如何用数组来解决实际问题，缩短和简化程序？ 抱着这三个疑问我去查找了相关知识。 首先针对第一个问题：数组的定义是什么，何为数组？ 这其实很简单，数组就是用来存储一个固定大小的相同类型元素的.
C语言吧1-10转换成char数组
05-25
可以使用sprintf函数将数字转换为字符数组。 下面是一个示例代码： ```c #include <stdio.h> int main() { int i; char str[10]; for (i = 1; i <= 10; i++) { sprintf(str, "%d", i); printf("%s\n", str); } return 0; } ``` 输出： ``` 1 2 3 4 5 6 7 8 9 10 ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值