【C语言】数组使用注意点

已于 2022-03-22 20:53:48 修改
阅读量1.5k 收藏 4
点赞数
分类专栏： C语言 文章标签： c语言
于 2022-03-21 17:17:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45607873/article/details/123622692
版权

数组的初始化

  1. 一维数组
  • 初始化部分元素
	int buff[5] = {10, 8, 1};
    for(int i = 0; i < 5; i++)
        printf("%3d", buff[i]);
//输出结果为： 10  8  1  0  0

表示只给buff[0] ~ buff[2]3个元素赋值，而后面2个元素自动初始化为 0。

当赋值的元素少于数组总体元素的时候，不同类型剩余的元素自动初始化值说明如下：

对于 short、int、long，就是整数 0；
对于 char，就是字符 ‘\0’；
对于 float、double，就是小数0.0；
对于指针类型，就是NULL。

  • 全部初始化为0
	int buff[5] = {0};
    for(int i = 0; i < 5; i++)
        printf("%3d", buff[i]);
//输出结果为：  0  0  0  0  0
  • 逐个赋值，不能给数组整体赋值
  	int buff[5] = {5, 8, 6, 1, 74};
    for(int i = 0; i < 5; i++)
        printf("%3d", buff[i]);
//输出结果为：  5  8  6  1 74
  1. 二维数组
    定义二维数组时，必须给出第二维，第一维可省略。
  • 初始化部分元素
    int buff[3][4] = {
    {1, 2},
    {5, },
    {9, 10, 11, 12}
    };
    for(int i = 0; i < 3; i++)
    {
        for(int j = 0; j < 4; j++)
        {
            printf("%3d", buff[i][j]);
        }
        printf("\n");
    }
/*输出结果为：
  1  2  0  0
  5  0  0  0
  9 10 11 12
*/
  • 全部初始化为0
    int buff[3][4] = {0};
    for(int i = 0; i < 3; i++)
    {
        for(int j = 0; j < 4; j++)
        {
            printf("%3d", buff[i][j]);
        }
        printf("\n");
    }
/*输出结果为：
  0  0  0  0
  0  0  0  0
  0  0  0  0
*/
  • 逐个赋值
    int buff[3][4] = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}
    };
    for(int i = 0; i < 3; i++)
    {
        for(int j = 0; j < 4; j++)
        {
            printf("%3d", buff[i][j]);
        }
        printf("\n");
    }
/*输出结果为：
  1  2  3  4
  5  6  7  8
  9 10 11 12
*/

求取数组的元素个数

  1. 一维数组
#include <stdio.h>


int main(void)
{
    int buff[5] = {0};
    printf("数组元素个数：%u\n", sizeof(buff) / sizeof(buff[0]));
    //printf("数组元素个数：%u\n", sizeof(buff) / sizeof(*buff));
}
  1. 二维数组
#include <stdio.h>


int main(void)
{
    int buff[4][5] = {0};
    printf("数组行数：%u\n", sizeof(buff) / sizeof(buff[0]));
    //printf("数组行数：%u\n", sizeof(buff) / sizeof(*buff));
    printf("数组列数：%u\n", sizeof(buff[0]) / sizeof(buff[0][0]));
    //printf("数组列数：%u\n", sizeof(*buff) / sizeof(**buff));
}

传递数组给函数

  1. 一维数组

方式一

#include <stdio.h>


int getSum(int buff[], int count)
{
    int sum = 0;
    while(count--)
    {
        sum += buff[count];
    }
    return sum;
}


int main(void)
{
    int buff[] = {1,2,3,4,5};
    int sum = getSum(buff, 5);
    printf("%d\n", sum);
}

方式二

#include <stdio.h>


int getSum(int *buff, int count)
{
    int sum = 0;
    while(count--)
    {
        sum += *buff++;
    }
    return sum;
}


int main(void)
{
    int buff[] = {1,2,3,4,5};
    int sum = getSum(buff, 5);
    printf("%d\n", sum);
}

函数的参数中，数组类型参数 int buff[]本质是指针 可以直接换成 int *buff;

  1. 二维数组

方式一
第一维的长度可以不指定，但必须指定第二维的长度

#include <stdio.h>


int getSum(int buff[][4], int m, int n)
{
    int sum = 0;
    int temp = n;
    while(m--)
    {
        while(n--)
        {
            sum += buff[m][n];
        }
        n = temp;
    }
    return sum;
}


int main(void)
{
    int buff[3][4] = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}
    };
    int sum = getSum(buff, 3, 4);
    printf("%d\n", sum);
}

方式二
指向一个有5个int类型的元素一维数组的指针

#include <stdio.h>


int getSum(int (*buff)[4], int m, int n)
{
    int sum = 0;
    int temp = n;
    while(m--)
    {
        while(n--)
        {
            sum += *(*(buff + m) + n);
        }
        n = temp;
    }
    return sum;
}


int main(void)
{
    int buff[3][4] = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}
    };
    int sum = getSum(buff, 3, 4);
    printf("%d\n", sum);

}

方式三
利用数组是顺序存储的特性,通过降维来访问原数组！

#include <stdio.h>


int getSum(int *buff, int m, int n)
{
    int sum = 0;
    int temp = n;
    while(m--)
    {
        while(n--)
        {
            sum += *(buff + m * temp + n);
        }
        n = temp;
    }
    return sum;
}


int main(void)
{
    int buff[3][4] = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}
    };
    int sum = getSum(*buff, 3, 4);
    printf("%d\n", sum);
}

将二维数组当作参数的时候，必须指明所有维数大小或者省略第一维的，但是不能省略第二维或者更高维的大小，这是由编译器原理限制的。
事实上，编译器是这样处理数组的：设有二维数组 int buff[m][n]，如果要访问 buff[i][j]的值，编译器的寻址方式为：
&buff[i][j] = &buff[0][0] + i * n + j;

从函数返回数组

C 语言不允许返回一个完整的数组作为函数的参数。但是，您可以通过指定不带索引的数组名来返回一个指向数组的指针。
如果您想要从函数返回一个一维数组，您必须声明一个返回指针的函数。

  1. 一维数组
#include <stdio.h>


int* func(int num)
{
    static int buff[10] = {0};

    for(int i = 0; i < 10; i++)
    {
        buff[i] += num;
    }
    return buff;
}


int main(void)
{
    int *p = NULL;
    p = func(10);
    for(int i = 0; i < 10; i++)
    {
        printf("%5d", p[i]);
    }
}
/*
输出结果
   10   10   10   10   10   10   10   10   10   10
*/
  1. 二维数组

方式1
将buff作为函数参数

#include <stdio.h>


void func(int (*buff)[4], int m, int num)
{
    for(int i = 0, j = 0; i < m; i++)
        for(j = 0; j < 4; j++)
            *(*(buff + i) + j) += num;
}


int main(void)
{
    int buff[3][4] = {0};
    func(buff, 3, 11);
    for(int i = 0, j = 0; i < 3; i++)
    {
        for(j = 0; j < 4; j++)
        {
            printf("%4d", buff[i][j]);
        }
        printf("\n");
    }
}
/*
输出结果
  11  11  11  11
  11  11  11  11
  11  11  11  11
*/

方式2
返回二维数组

 int (*func(int num))[4]
{
    static int buff[3][4] = {0};
    for(int i = 0, j = 0; i < 3; i++)
        for(j = 0; j < 4; j++)
            *(*(buff + i) + j) += num;
    return buff;
}

一般用typedef来定义一种新类型，这样便于理解。

typedef int (*arr)[4];

arr func(int num)
{
    static int buff[3][4] = {0};
    for(int i = 0, j = 0; i < 3; i++)
        for(j = 0; j < 4; j++)
            *(*(buff + i) + j) += num;
    return buff;
}

指向数组的指针

记住这句话：数组名是一个指向数组中第一个元素的常量指针。

  1. 一维数组

实例

#include <stdio.h>


int main(void)
{
    int buff[] = {1, 2, 3, 4, 5, 6};
    int *p = buff;

    printf("buff:%p\n", buff);
    printf("p:%p\n", p);
    printf("&buff:%p\n", &buff);
    printf("&buff[0][0]:%p\n", &buff[0]);
}
/*
输出结果
buff:000000000061FE00
p:000000000061FE00
&buff:000000000061FE00
&buff[0][0]:000000000061FE00
*/

虽然输出结果的数值是一样的，但是这四个还是有区别的。

buffbuff是数组名，所以buff是一个指向第一个元素的常量指针，即&buff[0]；buff是一个指向int类型的常量指针，即int * const buff;
pp是指向int类型的指针，与buff的区别是：p是变量，而buff是常量。实例中p指向了数组第一个元素。
&buff对数组名进行取地址操作，得到的应该是整个数组的地址。数组的元素个数为6，(&buff + 1)得到的是增大整个数组内存大小的地址：增大4 x 6 = 24。另外(*(&buff + 1)) - buff = 6; &buff是指向6个int类型数据的指针。
&buff[0]对数组第一个元素取地址，得到就是第一个元素的地址值。

下面的代码有助于理解&buff

#include <stdio.h>


int main(void)
{
    int buff[] = {1, 2, 3, 4, 5, 6};
    int *p = buff;

    printf("buff:%p\n", buff);
    printf("p:%p\n", p);
    printf("&buff:%p\n", &buff);
    printf("&buff[0][0]:%p\n", &buff[0]);

    printf("(*(&buff + 1)):%p\n", (*(&buff + 1)));
    printf("(*(&buff + 1)) - buff:%u个元素\n", (*(&buff + 1)) - buff);
    printf("(*(&buff + 1)) - buff:%u个字节\n", ((*(&buff + 1)) - buff) * sizeof(int));
}
/*
输出结果
buff:000000000061FE00
p:000000000061FE00
&buff:000000000061FE00
&buff[0][0]:000000000061FE00
(*(&buff + 1)):000000000061FE18
(*(&buff + 1)) - buff:6个元素
(*(&buff + 1)) - buff:24个字节
*/
  1. 二维数组

实例

#include <stdio.h>


int main(void)
{
    int buff[3][4] = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12},
    };
    int (*p)[4] = buff;

    printf("buff:%p\n", buff);
    printf("p:%p\n", p);
    printf("*buff:%p\n", *buff);
    printf("**buff:%d\n", **buff);
    printf("buff[0]:%p\n", buff[0]);
    printf("*buff[0]:%d\n", *buff[0]);
    printf("&buff[0]:%p\n", &buff[0]);
    printf("&buff[0][0]:%p\n", &buff[0][0]);

    printf("\n每行有4个int类型数据\n");
    printf("buff + 1:%p\n", buff + 1);
    printf("**(buff + 1):%d\n", **(buff + 1));
    printf("p + 1:%p\n", p + 1);
    printf("buff[1]:%p\n", buff[1]);
    printf("*buff[1]:%d\n", *buff[1]);
    printf("&buff[1]:%p\n", &buff[1]);
    printf("&buff[1][0]:%p\n", &buff[1][0]);

}
/*
输出结果
buff:000000000061FDE0
p:000000000061FDE0
*buff:000000000061FDE0
**buff:1
buff[0]:000000000061FDE0
*buff[0]:1
&buff[0]:000000000061FDE0
&buff[0][0]:000000000061FDE0

每行有4个int类型数据
buff + 1:000000000061FDF0
**(buff + 1):5
p + 1:000000000061FDF0
buff[1]:000000000061FDF0
*buff[1]:5
&buff[1]:000000000061FDF0
&buff[1][0]:000000000061FDF0
*/
buffbuff是数组名，数组的第一个元素是一个一维数组；&buff[0]，即buff是指向4个int类型数据的常量指针，即 int (* const buff)[4];
pp是一个指向4个int类型数据的指针
*buff对buff进行取值操作，得到一个指向int类型数据的指针；等价于buff[0]
**buff对buff进行两次取值操作，得到一个第一个元素的值；等价于buff[0][0], *buff[0]
buff[0]指向int类型数据的指针
*buff[0]等价于buff[0][0], **buff
&buff[0]等价于buff
&buff[0][0]得到第一个元素的地址

问题
在仅知道数组名和维度情况下，怎么获得数组最后一个元素的值？

  1. 一维数组
#include <stdio.h>


int main(void)
{
    int buff[] = {1, 2, 3, 4, 5, 6};
    printf("数组最后一个元素的值为：%d\n", *(*(&buff + 1) - 1)) ;
}
/*
输出结果
数组最后一个元素的值为：6
*/
  1. 二维数组
#include <stdio.h>


int main(void)
{
    int buff[3][4] = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12},
    };
    printf("数组最后一个元素的值为：%d\n", *(**(&buff + 1) - 1));
}
/*
输出结果
数组最后一个元素的值为：12
*/
  1. 三维数组
#include <stdio.h>


int main(void)
{
    int buff[2][2][2] = {
    {{1, 2}, {3, 4}},
    {{5, 6}, {7, 8}}
    };
    printf("数组最后一个元素的值为：%d\n", *(***(&buff + 1) - 1)) ;
}
/*
输出结果
数组最后一个元素的值为：8
*/
熠熠L
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言中数组作为函数的参数以及返回值的使用简单入门
09-03
主要介绍了C语言中数组作为函数的参数以及返回值的使用简单入门,这里以一维数组作为基本条件进行例子讲解,需要的朋友可以参考下
二进制流：C++中使用 (char *)& 传递int型值
尤小白的博客
09-13 3781
文章目录前言一、利用二进制流传递整形数组值1.1 整形数组1.2 二进制流1.2.1 那如何将整形数值依次按一个字节存放入二进制流中呢？1.2.2 如何重构回整形数值?二、结构体数组赋值 前言 此前参与罗技G29方向盘远程遥控autolabor小车的小项目，树莓派操控小车为服务端，采集方向盘数据部分为客户端，二者间进行P2P通信，要将方向盘转向、油门、挡位数据发送给树莓派，需要使用到二进制流传递法，本文介绍通过二进制流传递整形数组的原理。 一、利用二进制流传递整形数组值 1.1 整形数组 如int nu
C++ 实现Buffer 动态分配管理代码实现
|~~~热爱生活、努力学习的小伙汁~~~|
10-10 2060
C++ 实现Buffer 动态分配管理代码实现一、 Class Memory_Manager 头文件代码实现二、 Class Memory_Manager 代码实现三、Class Memory_Manager 使用方法 应公司需求，花半天时间写了一个内存buffer 动态管理的代码。 实现功能如下： 初始化时，常驻两块 buff 用于数据传输。（兼顾 性能） 在数据高峰期时，当已分配的两块 b...
C语言进阶 之 指针详解(3)
qq_38620559的博客
08-12 356
函数指针、函数指针数组、指向函数指针数组的指针、回调函数
4.3 C语言的高级用法以及易错点
oDuanYanGuHong的博客
07-08 2295
1、 函数指针和指针函数的区别 指针函数: 指针函数是指带指针的函数，即本质是一个函数。函数返回类型是某一类型的指针。 类型说明符 * 函数名(参数) #include "stdio.h" #include "stdlib.h" int sum =0; int *getAdd(int a, int b) { sum = a+b; return &sum ; } int getDiff(int a, int b) { return a>b?(a-b):(b-a); }
C语言.字符数组和整型赋值注意事项：关于scanf()、gets()
myscratch的博客
05-23 744
字符数组： char a[5] = {0}; gets(a); 用gets(a)接收字符串：它会把空格也接收作为字符，而scanf碰到空格会停止。 但要注意：a大小为5，你只能传4个字符，传入5，如下图会报错 当用scanf接收字符数组时： 输入一行之间别加空格， 因为scanf会把\n和空格也作为字符，可以单独加入：getchar();算是丢弃掉。 不加空格，只输入一行时，要几个字符，char a[] 就开辟几个空间，不会报错 ...
C语言-数组
热门推荐
weixin_74346443的博客
11-11 1万+
一维数组 二维数组
C语言 一组数据中只有一个数字出现了一次，其他所有数字都是成对出现的，请找出这个数字
yangke369的博客
11-11 187
分析：数组中只有一个数字出现了一次，其他成对出现，由异或运算的特性我们知道，两个相同的数异或结果为0；所以可以让这组数据连续异或，相同的异或后为0，最终的结果就是只出现一次的那个数字了； 代码如下： #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <stdlib.h> #include <stri...
黑马程序员-C语言数组的使用注意事项
FlyWithDe的博客
07-31 3271
数组定义时使用的数据类型是指数组中存储的数值的类型，并不是数组的类型定义数组时，数组的长度可以是常量、常量表达式和宏定义不能是变量，但是在xcode下被优化可以使用变量，但是如下形式定义的数组在xcode下的初始化是不行的：                        int len = 3, a[len] = {1,2,3};//xcode会报错 数组名不能和其他变量名同名若数
C语言 数组介绍 及 注意问题
m0_73219367的博客
10-12 237
字符串字面量 本质是一个数组，是一个无名数组 “abc”[0] ==> a , “ abc”本身是一个地址, *(“abc+1”)==> b;char a =*(””) a==>0 因为”” ==> “\0”int arr[5]={1,2,3,4,5} arr的类型是==>int[5] 计算数组元素个数 sizeof(arr)/sizeof(arr[0]);a[n] == > *(a+n)==> *(n+a)==> n[a] 例子：arr[0] 0[arr]
C语言数组入门之数组的声明与二维数组的模拟
12-31
C语言中的数组值得注意的地方有以下两点： C语言中只有一维数组，而且数组的大小必须在编译期就作为一个常数确定下来。然而，C语言中数组的元素可以是任何类型的对象，当然也可以是另外一个数组。这样，要“仿真”出...
C语言数组型双向链表的处理
08-26
ALIST是一段基于C语言的数组型双向链表的处理代码，接口简单明了，易于使用，标准C语言开发，可添加在任何C/C++语言工程中，需要注意的是，如果使用了操作系统，请自行在库中修改指向处添加资源锁定，避免因操作系统...
C语言中全局数组和局部数组的问题
01-20
今天同学遇到一个在C语言中全局数组和局部数组的问题，卡了许久，我也没有第一时间看出问题，现在把问题梳理一下，并给出解决方案。 问题描述： 在全局声明的数组与在局部声明的数组有着不同的效果。 首先来看一个...
IOS开发之路–C语言数组和字符串
01-20
一维数组操作比较简单，但是需要注意，数组长度必须是固定的，长度不能使用变量进行初始化；如果声明的同时进行赋值则数组长度可以省略，编译器会自动计算数组长度；同时数组不能先声明再一次性赋值（当然可以对每个...
c语言数组初始化注意事项,C语言-基础教程-数组的初始化
weixin_39576104的博客
05-21 929
5.4.1 数组初始化C语言允许在说明时对全局数组和静态局部数组初始化，但不能对非静态局部数组初始化。与其它变量相似，数组初始化的一般形式如下：type-specifier array_name[size1]...[sizen]={value-list};数值表是一个由逗号分隔的常量表。这些常量的类型与类型说明相容，第一个常量存入数组的第一个单元，第二个常量存入第二个单元，等等，注意在括号“ }”...
C数组注意事项
justdoit1024
11-11 219
假设有数组int a [2][3] = {1,2,3,4,5,6}   1、数组名为数组第一个元素的地址，即a为a[0]的地址   2、*（a+i）与a[i]是等价的   3、指向行的指针前面加上一个*，就转换为指向列的指针。如a+1是指向行的指针，那么*（a+1）表示指向第1行第0列的元素。   4、指向列的指针前加上一个&amp;，就转换为指向行的指针。如a[0]是指向第0行0...
C语言注意事项
lidaxia_it的博客
01-13 858
个人学习笔记，若有错误请指正 1.没有定义的小数，默认为 double，不可取余“%” 。sqrt()返回值也为double类型，不可%。1.5f为float 。正整数为 int。浮点数可以省略前面的整数，保留小数 2.标识符 首字符必须为 “字母”“ 下划线”包括：数字，字母，下划线。不可出现符号。 3.long int ，short int 可以省略 int ,写成 long(4字节) ，short (2字节)
c语言数组的注意事项
最新发布
qq_45755259的博客
01-03 468
3.c语言规定数组是有下标的，下标从0开始，n个元素的数组，最后一个元素的下标为n-1，下标相当于数组元素的编号。6.二维数组按照行进行初始化，注意二维数组是一个一维数组的数组，存放一维数组的数组，二维数组的每个元素是一维数组。sizeof()返回的是字符串数组的大小，包括字符串末尾的 null 字符，而不是字符串的长度。如数组int arr[10]={1,2,3,4,5,6,7,8,9,10};2.数组的类型，数组是一种自定义数据类型，去掉数组名留下的就是数组的类型。
c语言 关于数组 我们需要注意什么
mxrrr_sunshine的博客
11-22 4300
一维数组1创建与初始化int arr[10];注：下标引用操作符[ ]里要给一个常量，不能使用变量。int arr1[10]={1,2,3}; int arr2[]={1,2,3,4};注：数组在创建时如果不指定数组大小，就得初始化。元素个数由初始化的内容确定。 2数组的使用 总结：数组是使用下标来访问的，下标是从0开始。 数组的大小可以通过计算得到。int arr[10]
c语言数组下标知识点
10-29
C语言数组下标是指数组中每个元素的位置编号，从0开始递增。通过下标可以访问数组中的元素，进行读取或修改操作。需要注意的是，下标不能越界，即不能超出数组的范围。下标越界会导致程序崩溃或者出现不可预知的错误。在使用数组时，需要特别注意下标的使用。 下面是一些关于C语言数组下标的知识点： 1. 数组下标从0开始，最大下标为数组长度减1。 2. 数组下标可以是整型变量或常量，也可以是表达式。 3. 数组下标可以是负数，但是不推荐使用。 4. 数组下标越界会导致程序崩溃或者出现不可预知的错误。 5. 数组下标可以作为指针使用，例如：*(arr+i)和arr[i]等价。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值