精华内容
下载资源
问答
  • 上节讲解的数组可以看作是一行连续的...本节只介绍二维数组,多维数组可由二维数组类推而得到。二维数组的定义二维数组定义的一般形式是:dataType arrayName[length1][length2];其中,dataType 为数据类型,arrayNa...

    上节讲解的数组可以看作是一行连续的数据,只有一个下标,称为一维数组。在实际问题中有很多数据是二维的或多维的,因此C语言允许构造多维数组。多维数组元素有多个下标,以确定它在数组中的位置。本节只介绍二维数组,多维数组可由二维数组类推而得到。

    二维数组的定义

    二维数组定义的一般形式是:

    dataType arrayName[length1][length2];

    其中,dataType 为数据类型,arrayName 为数组名,length1 为第一维下标的长度,length2 为第二维下标的长度。

    我们可以将二维数组看做一个 Excel 表格,有行有列,length1 表示行数,length2 表示列数,要在二维数组中定位某个元素,必须同时指明行和列。例如:

    int a[3][4];

    定义了一个 3 行 4 列的二维数组,共有 3×4=12 个元素,数组名为 a,即:

    a[0][0], a[0][1], a[0][2], a[0][3]

    a[1][0], a[1][1], a[1][2], a[1][3]

    a[2][0], a[2][1], a[2][2], a[2][3]

    如果想表示第 2 行第 1 列的元素,应该写作 a[2][1]。

    也可以将二维数组看成一个坐标系,有 x 轴和 y 轴,要想在一个平面中确定一个点,必须同时知道 x 轴和 y 轴。

    二维数组在概念上是二维的,但在内存中是连续存放的;换句话说,二维数组的各个元素是相互挨着的,彼此之间没有缝隙。那么,如何在线性内存中存放二维数组呢?有两种方式:

    一种是按行排列, 即放完一行之后再放入第二行;

    另一种是按列排列, 即放完一列之后再放入第二列。

    在C语言中,二维数组是按行排列的。也就是先存放 a[0] 行,再存放 a[1] 行,最后存放 a[2] 行;每行中的 4 个元素也是依次存放。数组 a 为 int 类型,每个元素占用 4 个字节,整个数组共占用 4×(3×4)=48 个字节。

    你可以这样认为,二维数组是由多个长度相同的一维数组构成的。

    【实例1】一个学习小组有 5 个人,每个人有 3 门课程的考试成绩,求该小组各科的平均分和总平均分。

    --

    Math

    C

    English

    张涛

    80

    75

    92

    王正华

    61

    65

    71

    李丽丽

    59

    63

    70

    赵圈圈

    85

    87

    90

    周梦真

    76

    77

    85

    对于该题目,可以定义一个二维数组 a[5][3] 存放 5 个人 3 门课的成绩,定义一个一维数组 v[3] 存放各科平均分,再定义一个变量 average 存放总平均分。最终编程如下:

    #include

    int main(){

    int i, j; //二维数组下标

    int sum = 0; //当前科目的总成绩

    int average; //总平均分

    int v[3]; //各科平均分

    int a[5][3]; //用来保存每个同学各科成绩的二维数组

    printf("Input score:\n");

    for(i=0; i<3; i++){

    for(j=0; j<5; j++){

    scanf("%d", &a[j][i]); //输入每个同学的各科成绩

    sum += a[j][i]; //计算当前科目的总成绩

    }

    v[i]=sum/5; // 当前科目的平均分

    sum=0;

    }

    average = (v[0] + v[1] + v[2]) / 3;

    printf("Math: %d\nC Languag: %d\nEnglish: %d\n", v[0], v[1], v[2]);

    printf("Total: %d\n", average);

    return 0;

    }

    运行结果:

    Input score:

    80 61 59 85 76 75 65 63 87 77 92 71 70 90 85↙

    Math: 72

    C Languag: 73

    English: 81

    Total: 75

    程序使用了一个嵌套循环来读取所有学生所有科目的成绩。在内层循环中依次读入某一门课程的各个学生的成绩,并把这些成绩累加起来,退出内层循环(进入外层循环)后再把该累加成绩除以 5 送入 v[i] 中,这就是该门课程的平均分。外层循环共循环三次,分别求出三门课各自的平均成绩并存放在数组 v 中。所有循环结束后,把 v[0]、v[1]、v[2] 相加除以 3 就可以得到总平均分。

    二维数组的初始化

    二维数组的初始化可以按行分段赋值,也可按行连续赋值。

    例如,对于数组 a[5][3],按行分段赋值应该写作:

    int a[5][3]={ {80,75,92}, {61,65,71}, {59,63,70}, {85,87,90}, {76,77,85} };

    按行连续赋值应该写作:

    int a[5][3]={80, 75, 92, 61, 65, 71, 59, 63, 70, 85, 87, 90, 76, 77, 85};

    这两种赋初值的结果是完全相同的。

    【实例2】和“实例1”类似,依然求各科的平均分和总平均分,不过本例要求在初始化数组的时候直接给出成绩。

    #include

    int main(){

    int i, j; //二维数组下标

    int sum = 0; //当前科目的总成绩

    int average; //总平均分

    int v[3]; //各科平均分

    int a[5][3] = {{80,75,92}, {61,65,71}, {59,63,70}, {85,87,90}, {76,77,85}};

    for(i=0; i<3; i++){

    for(j=0; j<5; j++){

    sum += a[j][i]; //计算当前科目的总成绩

    }

    v[i] = sum / 5; // 当前科目的平均分

    sum = 0;

    }

    average = (v[0] + v[1] + v[2]) / 3;

    printf("Math: %d\nC Languag: %d\nEnglish: %d\n", v[0], v[1], v[2]);

    printf("Total: %d\n", average);

    return 0;

    }

    运行结果:

    Math: 72

    C Languag: 73

    English: 81

    Total: 75

    对于二维数组的初始化还要注意以下几点:

    1) 可以只对部分元素赋值,未赋值的元素自动取“零”值。例如:

    int a[3][3] = {{1}, {2}, {3}};

    是对每一行的第一列元素赋值,未赋值的元素的值为 0。赋值后各元素的值为:

    1  0  0

    2  0  0

    3  0  0

    再如:

    int a[3][3] = {{0,1}, {0,0,2}, {3}};

    赋值后各元素的值为:

    0  1  0

    0  0  2

    3  0  0

    2) 如果对全部元素赋值,那么第一维的长度可以不给出。例如:

    int a[3][3] = {1, 2, 3, 4, 5, 6, 7, 8, 9};

    可以写为:

    int a[][3] = {1, 2, 3, 4, 5, 6, 7, 8, 9};

    3) 二维数组可以看作是由一维数组嵌套而成的;如果一个数组的每个元素又是一个数组,那么它就是二维数组。当然,前提是各个元素的类型必须相同。根据这样的分析,一个二维数组也可以分解为多个一维数组,C语言允许这种分解。

    例如,二维数组a[3][4]可分解为三个一维数组,它们的数组名分别为 a[0]、a[1]、a[2]。

    这三个一维数组可以直接拿来使用。这三个一维数组都有 4 个元素,比如,一维数组 a[0] 的元素为 a[0][0]、a[0][1]、a[0][2]、a[0][3]。

    展开全文
  • C语言二维数组知识点介绍数组可以看作是一行连续的数据,只有一个下标,称为一维数组。在实际问题中有很多量是二维的或多维的,因此C语言允许构造多维数组。多维数组元素有多个下标,以确定它在数组中的位置。本节只介绍...

    C语言二维数组知识点介绍

    数组可以看作是一行连续的数据,只有一个下标,称为一维数组。在实际问题中有很多量是二维的或多维的,因此C语言允许构造多维数组。多维数组元素有多个下标,以确定它在数组中的位置。本节只介绍二维数组,多维数组可由二维数组类推而得到。

    1feb7ce5f53053b1badab051a5f78da4.png

    C语言二维数组知识点介绍

    二维数组的定义一般形式是:

    dataType arrayName[length1][length2];

    其中,dataType 为数据类型,arrayName 为数组名,length1 为第一维下标的埠度,length2 为第二维下标的埠度。例如:

    int a[3][4];

    定义了一个3行行4列的数组,共有3×4=12个元素,数组名为a,即:

    a[0][0], a[0][1], a[0][2], a[0][3]

    a[1][0], a[1][1], a[1][2], a[1][3]

    a[2][0], a[2][1], a[2][2], a[2][3]

    在二维数组中,要定位一个元素,必须给出一维下标和二维下标,就像在一个平面中确定一个点,要知道x坐标和y坐标。例如,a[3][4] 表示a数组第3行第4列的元素。

    二维数组在概念上是二维的,但在内存中地址是连续的,也就是说存储器单元是按一维线性排列的。那么,如何在一维存储器中存放二维数组呢?有两种方式:一种是按行排列, 即放完一行之后顺次放入第二行。另一种是按列排列, 即放完一列之后再顺次放入第二列。

    在C语言中,二维数组是按行排列的。也就是先存放a[0]行行,再存放a[1]行行,最后存放a[2]行行;每行行中的四个元素也是依次存放。数组a为int类型,每个元素占用4个字节,整个数组共占用用4×(3×4)=48个字节。

    【示例】一个学习小组有5个人,每个人有三门课的考试成绩。求全组分科的平均成绩和各科总平均成绩。

    -- 张 王 李 赵 周

    Math 80 61 59 85 76

    C 75 65 63 87 77

    English 92 71 70 90 85

    可设一个二维数组a[5][3]存放五个人三门课的成绩。再设一个一维数组v[3]存放所求得各分科平均成绩,设变量average 为全组各科总平均成绩。编程如下:

    #include

    int main(){

    int i, j; //二维数组下标

    int sum=0; //当前科目的总成绩

    int average; //总平均分

    int v[3]; //各科平均分

    int a[5][3]; //用来保存每个同学各科成绩的二维数组

    printf("Input score:

    ");

    for(i=0; i<3; i++){

    for(j=0; j<5; j++){11.

    scanf("%d", &a[j][i]); //输入每个同学的'各科成绩

    sum+=a[j][i]; //计算当前科目的总成绩

    }

    v[i]=sum/5;

    sum=0;

    // 当前科目的平均分

    }

    average =(v[0]+v[1]+v[2])/3;

    printf("Math: %d

    C Languag: %d

    English: %d

    ", v[0], v[1],v[2]);

    printf("Total:%d

    ", average);

    return 0;

    }

    运行结果:

    Input score:

    80 61 59 85 76 75 65 63 87 77 92 71 70 90 85↙

    Math: 72

    C Languag: 73

    English: 81

    Total:75

    程序中首先用了一个双重循环。在内循环中依次读入某一门课程的各个学生的成绩,并把这些成绩累加起来,退出内循环后再把该累加成绩除以5送入v[i]之中,这就是该门课程的平均成绩。外循环共循环三次,分别求出三门课各自自的平均成绩并存放在v数组之中。退出外循环之后,把v[0]、v[1]、v[2]相加除以3即得到各科总平均成绩。最后按题意输出各个成绩。

    二维数组的初始化可以按行分段赋值,也可按行连续赋值。

    例如对数组a[5][3],按行分段赋值可写为:

    int a[5][3]={ {80,75,92}, {61,65,71}, {59,63,70}, {85,87,90}, {76,77,85} };

    按行连续赋值可写为:

    int a[5][3]={80, 75, 92, 61, 65, 71, 59, 63, 70, 85, 87, 90, 76, 77, 85};

    这两种赋初值的结果是完全相同的。

    【示例】求各科平均分和总成绩平均分。

    #include

    int main(){

    int i, j; //二维数组下标

    int sum=0; //当前科目的总成绩

    int average; //总平均分

    int v[3]; //各科平均分

    int a[5][3]={ {80,75,92}, {61,65,71}, {59,63,70}, {85,87,90}, {76,77,85} };

    for(i=0; i<3; i++){

    for(j=0; j<5; j++){

    sum+=a[j][i]; //计算当前科目的总成绩

    }

    v[i]=sum/5; // 当前科目的平均分14.

    sum=0;

    }

    average =(v[0]+v[1]+v[2])/3;

    printf("Math: %d

    C Languag: %d

    English: %d

    ", v[0], v[1],v[2]);

    printf("Total:%d

    ", average);

    return 0;

    }

    运行行结果:

    Math: 72

    C Languag: 73

    English: 81

    Total:75

    对于二维数组初始化赋值还有以下说明:

    1) 可以只对部分元素赋初值,未赋初值的元素自动取0值。例如:

    int a[3][3]={{1},{2},{3}};

    是对每一行行的第一列元素赋值,未赋值的元素取0值。 赋值后各元素的值为:

    1 0 0

    2 0 0

    3 0 0

    int a [3][3]={{0,1},{0,0,2},{3}};

    赋值后的元素值为:

    0 1 0

    0 0 2

    3 0 0

    2) 如对全部元素赋初值,则第一维的长度可以不给出。例如:

    int a[3][3]={1,2,3,4,5,6,7,8,9};

    可以写为:

    int a[][3]={1,2,3,4,5,6,7,8,9};

    3) 数组是一一种构造类型的数据。二维数组可以看作是由一维数组的嵌套而构成的。设一维数组的每个元素都又是一个数组,就组成了二维数组。当然,前提是各元素类型必须相同。根据这样的分析,一个二维数组也可以分解为多个一维数组。

    如二维数组a[3][4],可分解为三个一维数组,其数组名分别为:a[0]、a[1]、a[2]。

    对这三个一维数组不需另作说明即可使用。这三个一维数组都有4个元素,例如:一维数组a[0]的元素为a[0][0], a[0][1], a[0][2], a[0][3]。必须强调的是,a[0], a[1], a[2]不能当作下标变量使用用,它们是数组名,不是一个单纯的下标变量。

    【C语言二维数组知识点介绍】相关文章:

    展开全文
  • 1.编写程序,把下面的数据输入到一个二维数组中: 25 36 78 13 12 26 8我自己编的,用VISUAL C++6.0 测试过了 #include"stdio.h" void Print(int a[4][4]) { int i,j; for(i=0;i输入4行4列的二维数组,CSS布局HTML小...

    1.编写程序,把下面的数据输入到一个二维数组中: 25 36 78 13 12 26 8我自己编的,用VISUAL C++6.0 测试过了 #include"stdio.h" void Print(int a[4][4]) { int i,j; for(i=0;i

    输入4行4列的二维数组,CSS布局HTML小编今天和大家分享计算主对角线各元素之和,2 3 5 8 1 0 1 2 4 5 7 6 1 0 2 3 i=0 to 3 j=0 to 3 if(i==j) sum=su#include int main(void) { int a[4][4]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}; int i,j,sum1,sum2;//定义sum1,sum2,分别存放两条对线元素的和; sum1=sum2=0; for(i=0;i

    C语言编程题:定义一个5╳5的矩阵,CSS布局HTML小编今天和大家分享对角线上的元要CSS布局HTML小编今天和大家分享:1)5╳5的矩阵是一个整型二维数组。 2)对角线上交叉的元素只加一次。

    ee4e4073169634d2e069433b6231ec85.png

    #include #include #include void main() { int a[4][4],i,j,s1=0,s2=0,sum=0; srand(time(NULL));//生成随机种子 for(i=0;i

    CSS布局HTML小编今天和大家分享一个5行5列的整型二维数组对角线元素之和(数组#include int main() { int i,j,sum=0; int arr[5][5]; printf("请输入数组元素的值:\n"); for(i=0;i

    CSS布局HTML小编今天和大家分享二维数组对角线之和的C++程序。

    用C++编一个程序,要CSS布局HTML小编今天和大家分享输入一个4*4矩阵对角线之和,并CSS布局HTML小编今天和大家分享其最大最小值,简述思路吧 定义一个存放最大值的变量max 定义一个存放最小值的变量Min 定义一个存放对角线之和变量sum 遍历二维数组所有元素 for(i=0;i

    c语言 二维数组 对角线相加

    通过java语言编程实现输出二维数组主对角线上的最大值

    import java.util.Scanner;public class max { public static void main(String[] args) { Scanner stdIn = new Scanner(System.in); int rows, cols; // 行数与列数 System.out.print("Enter number of rows" + " for the matrix: "); rows = s

    输出二维数组主对角线上元素中, if(i == j) prin很简单,就是在主对角线的下标都相等的时候,肯定就是主对角线上的元素了,判断对了,就输出来了啊,。

    c语言中如何输出二维数组a[5][5]的对角线元素

    /* * Date: 2015/12/18 */#include #include int main(int argc, char *argv[]){ int a[5][5] = { {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} }; int i; for ( i = 0; i < 5; i++ ) { printf("%

    展开全文
  • C语言 二维数组

    千次阅读 2016-01-15 22:21:24
    # 二维数组基本概念 ##1.二维数组的基本概念 - 所谓多维数组就是一个一维数组的每个元素又被声明为一 维数组,从而构成二维数组. 可以说二维数组是特殊的一维数组。 - 示例  +int a[2][3]  +可以看作由一维数组a[0]...

    # 二维数组基本概念

    ##1.二维数组的基本概念

    - 所谓多维数组就是一个一维数组的每个元素又被声明为一 维数组,从而构成二维数组. 可以说二维数组是特殊的一维数组。

    - 示例

        +int a[2][3]

        +可以看作由一维数组a[0]和一维数组a[1]组成,这两个一维数组都包含了3个int类型的元素

    ##2.二维数组的定义

    - 格式:

        +数据类型 数组名[一维数组的个数][一维数组的元素个数]

           *  数据类型 数组名[行数][列数]

        +其中"一维数组的个数"表示当前二维数组中包含多少个一维数组

        +其中"一维数组的元素个数"表示当前前二维数组中每个一维数组元素的个数

    ##3.二维数组的初始化

    - 二维数的初始化可分为两种:

        +定义的同时初始化

           * 按行分段赋值

           * 按行连续赋值

        +先定义后初始化

    - 定义的同时初始化

    - 先定义后初始化

    int a[2][3];

    a[0][0] = 80;

    a[0][1] = 75;

    a[0][2] = 92;

    a[1][0] = 61;

    a[1][1] = 65;

    a[1][2] = 71;

    - 按行分段赋值

    int a[2][3]={ {80,75,92}, {61,65,71}};

    - 按行连续赋值

    int a[2][3]={ 80,75,92,61,65,71};

    - 其它写法

        +完全初始化,可以省略第一维的长度

    int a[][3]={{1,2,3},{4,5,6}};

    int a[][3]={1,2,3,4,5,6};

        +部分初始化,可以省略第一维的长度

           * 为初始化的部分默认为0

    int a[][3]={{1},{4,5}};

    int a[][3]={1,2,3,4};

       >+ 注意: 有些人可能想不明白,为什么可以省略行数,但不可以省略列数。也有人可能会问,可不可以只指定行数,但是省略列数?

    其实这个问题很简单,如果我们这样写:

    int a[2][] = {1, 2, 3, 4, 5, 6}; // 错误写法

    大家都知道,二维数组会先存放第1行的元素,由于不确定列数,也就是不确定第1行要存放多少个元素,所以这里会产生很多种情况,可能1、2是属于第1行的,也可能1、2、3、4是第一行的,甚至1、2、3、4、5、6全部都是属于第1行的

        +指定元素的初始化

           * 未初始化的部分默认为0

    int a[2][3]={[1][2]=10};

    int a[2][3]={[1]={1,2,3}}

    ##3.二维数组的应用

    - 生活中的应用

    - 游戏中的应用

    # 二维数组与函数

    ##1.二维数组的元素作为函数参数

    - 二维数组的元素就相当于变量,作为函数参数与变量相同

    void test(char c);

    int main(int argc, const char * argv[]) {

       char cs[2][3] =

        {

           {'l', 'n', 'j'},

           {'l', 'm', 'j'}

       };

       printf("cs[0][0] = %c\n", cs[0][0]);

       test(cs[0][0]);

       printf("cs[0][0] = %c\n", cs[0][0]);

       return 0;

    }

    void test(char c)

    {

        c= 'w';

       printf("我被执行了\n");

    }

    输出结果:

    cs[0][0] = l

    我被执行了

    cs[0][0] = l

    ##2.二维数组中的一维数组作为函数

    - 二维数组的一维数组实际上就是一个一维数组,作为函数参数与一维数组相同

    void test(char c[]);

    int main(int argc, const char * argv[]) {

       char cs[2][3] =

        {

           {'l', 'n', 'j'},

           {'l', 'm', 'j'}

       };

        printf("cs[0][0]= %c\n", cs[0][0]);

       test(cs[0]);

       printf("cs[0][0] = %c\n", cs[0][0]);

       return 0;

    }

    void test(char c[])

    {

       c[0] = 'w';

       printf("我被执行了\n");

    }

    输出结果:

    cs[0][0] = l

    我被执行了

    cs[0][0] = w

    ```

    ##3.二维数组作为函数参数

    - **二维数组作为函数参数是地址传递**

    - 二维数组作为函数形参,参数中一维数组的元素个数不可以省略

    void test(char cs[2][]) // 错误写法

    {

       printf("我被执行了\n");

    }

     

    void test(char cs[2][3]) // 正确写法

    {

       printf("我被执行了\n");

    }

     

    void test(char cs[][3]) // 正确写法

    {

       printf("我被执行了\n");

    }

    - 二维数组作为函数参数,在被调函数中不能获得其有多少行,需要通过参数传入。

    void test(char cs[2][3])

    {

       int row = sizeof(cs);

       printf("row = %zu\n", row);

    }

    输出结果:

    row = 8

     

    - 二维数组作为函数参数,在被调函数中可以计算出二维数组有多少列

    void test(char cs[2][3])

    {

       size_t col = sizeof(cs[0]);

       printf("col = %zd\n", col);

    }

    输出结果:

    col = 3

    # 字符串常用方法

    ##1.字符串长度

    - 利用sizeof字符串长度

        +因为字符串在内存中是逐个字符存储的,一个字符占用一个字节,所以字符串的结束符长度也是占用的内存单元的字节数。

       char name[] = "520it";

       int size = sizeof(name);// 包含\0

       printf("size = %d\n", size);

        输出结果:6

    - 利用系统函数

        +格式: strlen(字符数组名)

        +功能:测字符串的实际长度(不含字符串结束标志‘\0’)并作为函数返回值。

       char name[] = "520it";

       size_t len = strlen(name2);

       printf("len = %lu\n", len);

        输出结果:5

    - 以“\0”为字符串结束条件进行统计

    /**

     *  自定义方法计算字符串的长度

     *

     * @param name 需要计算的字符串

     *

     * @return 不包含\0的长度

     */

    int myStrlen2(char str[])

    {

       //    1.定义变量保存字符串的长度

       int length = 0;

       while (str[length] != '\0')

        {

           length++;//1 2 3 4

        }

       return length;

    }

    /**

     *  自定义方法计算字符串的长度

     *

     * @param name  需要计算的字符串

     * @param count 字符串的总长度

     *

     * @return 不包含\0的长度

     */

    int myStrlen(char str[], int count)

    {

    //   1.定义变量保存字符串的长度

       int length = 0;

    //   2.通过遍历取出字符串中的所有字符逐个比较

       for (int i = 0; i < count; i++) {

    //       3.判断是否是字符串结尾

           if (str[i] == '\0') {

               return length;

           }

           length++;

        }

       return length;

    }

    # 字符串练习

     

    - 编写一个函数char_contains(charstr[],char key),

         如果字符串str中包含字符key则返回数值1,否则返回数值0

    int charContaines(char name[], char key)

    {

       int index = 0;

       while (name[index] != '\0') {

           if (key == name[index]) {

               return 1;

           }

           index++;

        }

       return 0;

    }

    int charContaines(char name[], char key)

    {

    //   int index = 0;

       int index = -1;

       while (name[++index]) {

           if (key == name[index]) {

               return 1;

           }

        }

       return 0;

    }

    int charContaines(char name[], char key)

    {

       int index = -1;

    //        取出name中的元素判断是不是要找的key,如果不是就继续找

    //        但是必须要求取出的元素也不是\0,因为如果取出的元素是\0代表字符串已经遍历完了

       while (name[++index] != key && name[index] != '\0');

    //   循环结束只有两种可能,1.找到了key, 2.字符串遍历到了结尾

    //    判断当前索引对应的元素是否是\0,如果是\0代表字符串到了结尾都没有找打

    //   int rs = name[index] == '\0' ? 0 : 1;

    //   int rs = name[index] ? 1 : 0;

    //   return rs;

       return name[index] ? 1 : 0;

    }

    # 字符串数组

    ##1. 字符串数组基本概念

    - 字符串数组其实就是定义一个数组保存所有的字符串

     

        +1.一维字符数组中存放一个字符串,比如一个名字char name[20] = “nj”

     

        +2.如果要存储多个字符串,比如一个班所有学生的名字,则需要二维字符数组,char names[15][20]可以存放15个学生的姓名(假设姓名不超过20字符)

     

        +3. 如果要存储两个班的学生姓名,那么可以用三维字符数组char names[2][15][20]

    ##2.字符串数组的初始化

    1.char names[2][10] = { {'l','n','j','\0'},{'l','m','j','\0'} };

    2.char names2[2][10] = { {"lnj"},{"lmj"} };

    3.char names3[2][10] = { "lnj","lmj" };

    # 字符串输入输出

    ##1.字符串输出

    - 在采用字符串方式后,字符数组的输入输出将变得简单方便。除了上述用字符串赋初值的办法外,还可用printf函数和scanf函数一次性输出输入一个字符数组中的字符串,而不必使用循环语句逐个地输入输出每个字符。

    - 使用的格式字符串为“%s”,表示输入、输出的是一个字符串

    字符串的输出

    - 输出

        +%s的本质就是根据传入的name的地址逐个去取数组中的元素然后输出,直到遇到\0位置

    char ch[] = "lnj";

    printf("%s\n", ch);

    - \0引发的脏读

    char name[] = {'c', 'o', 'o', 'l' , '\0'};

    char name2[] = {'l', 'n', 'j'};

    printf("name2 = %s\n", name2);

    输出结果: lnjcool

    ##2.字符串输入

    char ch[10];

    scanf("%s",ch);

    - 注意:

        +对一个字符串数组, 如果不做初始化赋值, 必须指定数组长度

        +ch最多存放由9个字符构成的字符串,其中最后一个字符的位置要留给字符串的结尾标示‘\0’当用scanf函数输入字符串时,字符串中不能含有空格,否则将以空格作为串的结束符。

    ##2.练习

    - 使用 scanf() 从控制台输入一个字符串,然后使用 printf()将其输出。

       char str[9];

       scanf("%s", str);

       printf("str = %s\n", str);

    # 指针基本概念

    ##1.什么是地址

    - 生活中的地址:

    - 内存地址:

    - 地址与内存单元中的数据是两个完全不同的概念

        +地址如同房间编号

        +内存单元如同房间

        +内存单元中存放着数据

    - 变量地址:

        +系统分配给"变量"的"内存单元"的起始地址

    如:

    char c = 'a'; // 占用1个字节

    那么变量c的地址为:0x10A5

    int n = 250; // 占用4个字节

    那么变量c的地址为:0x10A1

    ##2.什么是指针

    - 在计算机中所有数据都存储在内存单元中,而每个内存单元都有一个对应的地址, 只要通过这个地址就能找到对应单元中存储的数据. 由于通过地址能找到所需的变量单元,可以说,地址指向该变量单元。因此,将地址形象化的称为“指针”

    - 内存单元的指针(地址)和内存单元的内容是两个不同的概念。

    # 指针变量基本概念

    ##1.什么是指针变量

    - 在C语言中,允许用一个变量来存放指针,这种变量称为指针变量。因此,一个指针变量的值就是

    某个内存单元的地址或称为某内存单元的指针。

        +严格意义上说,指针是一个地址,是一个常量

        +针变量是存放一个地址,是一个变量。

    - 示例

    ##2.定义指针变量的格式

    - 指针变量的定义包括两个内容:

        +指针类型说明,即定义变量为一个指针变量;

        +指针变量名;

    ![](./images/zzbldygs.png)

       >+ 其中,*表示这是一个指针变量,变量名即为定义的指针变量名,类型说明符表示本指针变量所指向的变量的数据类型。

    - 示例

    char *p; // 一个用于指向字符形变量的指针

    int *q; // 一个用于指向整形变量的指针

    long *t; // 一个用于指向长整形变量的指针

    float *r; // 一个用于指向单精度浮点形变量的指针

    double *s; // 一个用于指向双精度浮点形变量的指针

    - 注意

        +1)在定义指针时,“*”号表示定义的变量是指针变量,变量的值只能存放地址。

        +2)一个类型的指针只能指向同类型的变量,不能指向其他类型的变量。

    + 3)指针也可以被声明为全局、静态局部和局部的。

    # 指针变量初始化

    ##1.指针变量的初始化方法

    - 指针变量初始化的方法有两种:定义的同时进行初始化和先定义后初始化

        + 定义的同时进行初始化

    int a = 5;

    int *p = &a;

        + 先定义后初始化

    int a = 5;

    int *p;

    p=&a;

        + 把指针初始化为NULL

    int *p=NULL;

    int *q=0;

    - 不合法的初始化:

        + 指针变量不能被赋值一个整数值(因为我们不知道这个整形常量是内存哪块地址

    int *p;

    p =  250; // 错误写法

        + 被赋值的指针变量前不能再加“*”

    int *p;

    *p=&a; //错误写法

    - 注意:

    - 多个指针变量可以指向同一个地址

        -指针的指向是可以改变的

    int a = 5;

    int *p = &a;

    int b = 10;

    p = &b; // 修改指针指向

    - 指针没有初始化里面是一个垃圾值,这时候我们这是一个野指针

        + 野指针可能会导致程序崩溃

        + 野指针访问你不该访问数据

        + 所以指针必须初始化才可以访问其所指向存储区域

    ##2.访问指针所指向的存储空间

    - C语言中提供了地址运算符&来表示变量的地址。其一般形式为:

        + &变量名;

    - C语言中提供了*来定义指针变量和访问指针变量指向的内存存储空间

        + 在定义变量的时候 * 是一个类型说明符,说明定义的这个变量是一个指针变量

    int *p=NULL; // 定义指针变量

        + 在不是定义变量的时候 *是一个操作符,访问指针所指向存储空间

    int a = 5;

    int *p = &a;

    printf("a =%d", *p); // 访问指针变量

    # 指针练习

    ##1.

    -  定义一个函数交换两个变量的值

    void swap(int*v1,int *v2)

    {

        int temp;

        temp = *v1;

        *v1 = *v2;

        *v2 = temp;

    }

    - 写一个函数,同时返回两个数的和与差

    intsumAndMinus(int v1, int v2, int *v3)

    {

        *v3 = v1 - v2;

        return v1 + v2;

    }

    # 多级指针

    ##1.二级指针介绍

    - 如果一个指针变量存放的又是另一个指针变量的地址,则称这个指针变量为指向指针的指针变量。也称为“二级指针”

        char c = 'a';

        char *cp;

        cp = &c;

        char **cp2;

        cp2 = &cp;

        printf("c = %c", **cp2);

    ##2.多级指针介绍

    int ***m1; 取值***m1

    int *****m2 取值*****m2

    # 指针类型

    ##1.指针为什么要区分类型

    - 在同一种编译器环境下,一个指针变量所占用的内存空间是固定的。比如,在16位编译器环境下,任何一个指针变量都只占用8个字节,并不会随所指向变量的类型而改变。

    - 虽然所有的指针都只占8个字节,但不同类型的变量却占不同的字节数。

        + 一个int占用4个字节,一个char占用1个字节,而一个double占用8字节;

        + 现在只有一个地址,我怎么才能知道要从这个地址开始向后访问多少个字节的存储空间呢,是4个,是1个,还是8个。

        + 所以指针变量需要它所指向的数据类型告诉它要访问多少个字节存储空间

    # 指针与数组

    ##1.数组指针的概念及定义

    - 数组元素指针

        + 一个变量有地址,一个数组包含若干元素,每个数组元素都有相应的地址 指针变量可以指向数组元素(把某一元素的地址放到一个指针变量中) 所谓数组元素的指针就是数组元素的地址

        printf(“%p %p”, &(a[0]), a);

    输出结果:0x1100, 0x1100

    ```

        >+ 注意: 数组名a不代表整个数组,只代表数组首元素的地址。

        >+ “p=a;”的作用是“把a数组的首元素的地址赋给指针变量p”,而不是“把数组a各元素的值赋给 p”

    ##2.使用指针引用数组元素

    - 可以用指针去访问数组

        int main (void)

    {

          int a[5] = {2, 4, 6, 8, 22};

          int *p;

          // p = &(a[0]); /* p has addressof  a[1]*/

          p = a;

          printf(“%d %d\n”,a[0],*p);

    }

    输出结果: 2, 2

    ```

    - 在指针指向数组元素时,允许以下运算:

        + 加一个整数(用+或+=),如p+1

        + 减一个整数(用-或-=),如p-1

        + 自加运算,如p++,++p

        + 自减运算,如p--,--p

        >+ 如果指针变量p已指向数组中的一个元素,则p+1```指向```同一数组中的下一个元素,p-1```指向```同 一数组中的上一个元素。

    - 结论:

        + 引用一个数组元素,可用下面两种方法:

            * 下标法,如a[i]形式

            * 指针法, *(p+i)形式

    - 注意:

        + 数组名虽然是数组的首地址,但是,数组名所所保存的数组的首地址是不可以更改的

    ```

        int x[10];

             x++; //illegal

             int* p = x;

             p++; //legal

    ##3.指针变量之间运算

    - 两指针变量相减所得之差是两个指针所指数组元素之间相差的元素个数。

        + 实际上是两个指针值(地址)相减之差再除以该数组元素的长度(字节数)。

        + (pointer2地址值 -pointer地址值) /sizeof(所指向数据类型)

    - 注意:

        + 指针之间可以相减,但不可以相加(相加无意义)

    # 指针与字符串

    ##1.字符串指针

    - 定义字符串的两种方式

        + 字符数组

    ```

    char string[]=”Ilove China!”;

    printf("%s\n",string);

        + 字符串指针指向字符串

            * 格式: ```char *变量名="字符串内容";```

    ```

    char*str="abc"

    ```

    - 字符串指针变量的定义说明与指向字符变量的指针变量说明是相同的。只能按对指针变量的赋值不同来区别

    ```

    char c = 'b';

    char *p=&c;// 表示p是一个指向字符变量c的指针变量。

    char *s="CLanguage"; // 则表示s是一个指向字符串的指针变量。把字符串的首地址赋予s。

    ```

    - 注意:

        + 1、使用字符数组来保存的字符串是保存栈里的,保存栈里面东西是可读可写,所有我 们可以改变里面的字符当把一个字符串常量赋值一个字符数组的时候,那么它会把字符串常量中的没有字符都放到字符数组里面

        + 2、使用字符指针来保存字符串,它保存的是字符串常量地址,常量区是只读的,所 以我们不可以修改字符串中的字符

    ##2.字符串指针使用注意事项

    - 可以查看字符串的每一个字符

    ```

    char *str ="lnj";

    for(int i = 0; i< strlen(str);i++)

    {

        printf("%c-", *(str+i));

    }

    输出结果:l-n-j

    ```

    - 不可以修改字符串内容

    ```

    char *str ="lnj";

    *(str+2) = 'y';// 错误

    ```

    - 不能够直接接收键盘输入

    ```

    char *str;

    scanf("%s",str);

    ```

        >+ 错误的原因是:str是一个野指针,他并没有指向某一块内 存空间,所以不允许这样写如果给str分配内存空间是可以这样用 的

    # 返回指针的函数

    ---

    ##1.指针函数概念

    - 前面我们介绍过,所谓函数类型是指函数返回值的类型。在C语言中允许一个函数的返回值是一个指针(即地址),这种返回指针值的函数称为指针型函数。

    ##2.指针函数的定义和使用

    - 格式:

    ```

    类型说明符 *函数名(形参表) {

        /*函数体*/

    }

    ```

        >+ 其中函数名之前加了“*”号表明这是一个指针型函数,即返回值是一个指针。类型说明符表示了 返回的指针值所指向的数据类型。

    # 指向函数指针

    ##1.为什么指针可以指向一个函数?

    - 函数作为一段程序,在内存中也要占据部分存储空间,它也有一个起始地址,即函数的入口地址。函数有自己的地址,那就好办了,我们的指针变量就是用来存储地址的。因此,可以利用一个指针指向一个函数。其中,函数名就代表着函数的地址。

    ##2.针函数的定义和使用

    - 格式:

    ```

    函数的返回值类型 (*指针变量名)(形参1, 形参2, ...);

    ```

        + 其中“类型说明符”表示被指函数的返回值的类型。

        + “(* 指针变量名)”表示“*”后面的变量是定义的指针变量。

        + 最后的空括号表示指针变量所指的是一个函数。

    ```

        int sum(int a,int b)

        {

            return a + b;

        }

        int (*p)(int,int);

        p = sum;

    ```

    - 技巧

        + 1、把要指向函数头拷贝过来

        + 2、把函数名称使用小括号括起来

        + 3、在函数名称前面加上一个*

        + 4、修改函数名称

    ---

    - 应用场景

        + 调用函数

        + 将函数作为参数在函数间传递

    ##3.使用注意

    - 由于这类指针变量存储的是一个函数的入口地址,所以对它们作加减运算(比如p++)是无意义的

    - 函数调用中"(*指针变量名)"的两边的括号不可少,其中的*不应该理解为求值运算,在此处它 只是一种表示符号

    # 字符串的基本概念

    ##1.字符串概念

    - 字符串是位于双引号中的字符序列

        + 在内存中以“\0”结束,所占字节比实际多一个

    ---

    ##2.字符串的初始化

    - 在C语言中没有专门的字符串变量,通常用一个字符数组来存放一个字符串。前面介绍字符串常量时,已说明字符串总是以‘\0’作为串的结束符。因此当把一个字符串存入一个数组时,也把结束符‘\0’存入数组,并以此作为该字符串是否结束的标志。有了‘\0’标志后,就不必再用字符数组的长度来判断字符串的长度了。

    - 初始化

    ```

        char name[9] = "lnj"; //在内存中以“\0”结束, \0ASCII码值是0

        char name1[9] = {'l','n','j','\0'};

        char name2[9] = {'l','n','j',0};

        char name3[9] = {'l','n','j'};//静态数组如果没有赋值默认就是0,0就相当于\0

    ```

    - 错误的初始化方式

    ```

         //不正确地写法,结尾没有\0 ,只是普通的字符数组

        char name4[] = {'l','n','j'};

         //   \0的作用:字符串结束的标志

        char name[] = "c\0ool";

         printf("name = %s\n",name);

    输出结果: c

    # 字符串常用方法(二)

    - C语言提供了丰富的字符串处理函数,大致可分为字符串的输入、输出、合并、修改、比较、转换、复制、搜索几类。使用这些函数可大大减轻编程的负担。

        + 用于输入输出的字符串函数,在使用前应包含头文件"stdio.h"

        + 使用其它字符串函数则应包含头文件"string.h"。

    ##1.字符串输出函数:puts

    - 格式: puts(字符数组名)

    - 功能:把字符数组中的字符串输出到显示器。即在屏幕上显示该字符串。

    - 优点:

        + 自动换行

        + 可以是数组的任意元素地址

    - 缺点

        + 不能自定义输出格式, 例如puts("hello %s");

    ```

    char ch[] ="lnj";

    puts(ch);

    输出结果: lnj

    ```

        >+ 从程序中可以看出puts函数中可以使用转义字符,因此输出结果成为两行。puts函数完全可以由printf函数取代。当需要按一定格式输出时,通常使用printf函数。

     

    展开全文
  • C语言二维数组

    2018-03-09 11:50:00
    上节讲解的数组可以看作是一行连续的...本节只介绍二维数组,多维数组可由二维数组类推而得到。 二维数组的定义 二维数组定义的一般形式是: dataType arrayName[length1][length2]; 其中,dataType 为数据类型...
  • C语言二维数组的使用

    2020-02-23 10:43:55
    二维数组的定义 二维数组定义的一般形式是: dataType arrayName[length1][length2]; 其中,dataType 为数据类型,arrayName 为数组名,length1 为第一维下标的长度,length2 为第二维下标的长度。 我们可以将二维...
  • c语言二维数组

    2021-03-03 19:28:58
    c语言二维数组: 1.源码 #include #include #include int main() { int b[3][3]={0,1,2,0,1,2,0,1,2},i,j,t=1; for(i=0;i;i++) for(j=i;j;j++)t+=b[i][b[j][i]]; printf("%d\n",t); system("pause"); return 0; }...
  • 上节讲解的数组可以看作是一行连续的...本节只介绍二维数组,多维数组可由二维数组类推而得到。二维数组的定义二维数组定义的一般形式是:dataType arrayName[length1][length2];其中,dataType 为数据类型,arrayNa...
  • C语言二维数组的定义和引用

    千次阅读 2014-09-06 22:23:43
    一维数组只有一个下标,...本节只介绍二维数组,多维数组可由二维数组类推而得到。 二维数组的定义 二维数组定义的一般形式是:  类型说明符 数组名[常量表达式1][常量表达式2] 其中常量表达式1表示第一维下标的长
  • 字符串二维数组感觉也没教什么呀。。所以我也做了蛮久,现依次把这几道题放在这里留作纪念。题目1:请写一个程序,对于一个m行m列(2)的方阵,求其每一行、每一列及主、辅对角线元素之和(注:主对角线是方阵从左上角...
  • 一、建立二维数组并赋值 程序1: #include <stdio.h> int main() { int a[6][6],i,j; //定义一个六行六列的二维数组 for(i=1;i<6;i++) for(j=1;j<6;j++) a[i][j] = (i/j)*(j/i); //对除第一行...
  • 杨辉三角你只要是明白了思路就好办,下面是我的思路: 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 我是 用二维数组来做的,我们可以看出来,这个规律是每一列的第一项和最后一项都是1,也就对应...
  • 一个关于C语言二维数组问题

    千次阅读 2008-06-13 08:40:00
    //定义一个二维数组aprintf("%d",a[100]);//输出a[100]}如果是以前,我会认为上面的代码肯定有错误……可是它居然能不出错误,且能输出一个整数,例如536为什么?我问了一个老师,为什么一个定义好的二维数组可以用...
  • 1.7.3将二维数组作为函数参数>>>1.函数原型当将数组的数组作为函数参数时,数组名同样视为地址,因此相应的形参如同一维数组一样也是一个指针,比较困难的是如何正确地声明一个指针变量pData指向一个数组的...
  • 实验一 二维数组的使用 一实验目的 1学习C语言中的二维数组的使实验一 二维数组的使用一、实验目的1.学习C语言中的二维数组的使用方法。2.编写程序,在评测系统上运行程序并查看返回结果。3.掌握二维数组中数组元素...
  • 杨辉三角你只要是明白了思路就好办,下面是我的思路: 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 我是 用二维数组来做的,我们可以看出来,这个规律是每一列的第一项和最后一项都是1,也就对应...
  • 1 //两个二维数组相加 2 #include<stdio.h> 3 #include<stdlib.h> 4 #define M 3 5 #define N 4 6 void main() 7 { 8 int i,j; 9 //二位数组A和B求和,和放在数组C中 10 int A[M][N]; ...
  • 原标题:C语言二维数组的定义二维数组的定义二维数组定义的一般形式是:dataType arrayName[length1][length2];其中,dataType 为数据类型,arrayName 为数组名,length1 为第一维下标的长度,length2 为第二维...
  • 初识JAVA二维数组相加

    千次阅读 2018-02-15 16:26:06
    今天初学JAVA数组 通过与C语言对比 JAVA与C语言数组定义大致类似,但是在细节类容上还是稍微有偏差:通过网络课程的自学 进一步了解了JAVA数组知识JAVA代码如下: public class Erweishuzu { //通过对打印结果...
  • 重温C语言 | 二维数组

    2019-07-10 00:29:09
    二维数组: 矩阵的表示形式 多个一维数组组成二维数组 二维数组的定义: 定义格式:数据类型 数组名[长度1] [长度2] 数据类型:表示数组中元素的类型 长度1 : 表示二维数组的行数 长度2 : 表示二维数组的列数 说明...
  • 本节只介绍二维数组,多维数组可由二维数组类推而得到。 1.二维数组的定义 二维数组定义的一般形式是: 类型说明符 数组名[常量表达式1][常量表达式2] 其中常量表达式1表示第一维下标的长度,常量表达式2 ...
  • C语言二维数组求和

    千次阅读 2020-04-12 15:08:08
    输入2个正整数m和n(1<=m<=6, 1<=n<=6) ,然后输入矩阵a(m行n列) 中的元素, 分别求出各行元素之和, 并输出。 编码如下: /*输入2个正整数m和n(1<...=6) ,然后输入矩阵a(m行n列) 中的元素...
  • 1.C语言数组的概念在《更加优美的C语言输出》一节中我们举了一个例子,是输出一个 4×4 的整数矩阵,代码如下:#include <stdio.h>#include <stdlib.h>int main(){ int a1=20, a2=345, a3=700, a4=22; ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,994
精华内容 2,397
关键字:

c语言二维数组相加

c语言 订阅