精华内容
下载资源
问答
  • 2021-06-02 19:04:59

    正确初始化:

    a = [[0 for _ in range(n)] for _ in range(n)]
    

    错误的初始化:

    a = [0 * n] * n
    

    这会导致

    a[0][1] = 1
    print(a[1][1])
    输出:1
    

    也就是说第一行和第二行是一样的a[0][1]a[1][1]指向的是同一个id,因为复制的时候,其他行都是第一行的快捷方式,你找第二行就等于找第一行。

    a = [[0] * 2] * 2
    print (id(a[0]))
    print (id(a[1]))
    输出:
    139872120628928
    139872120628928
    

    嘶,可是为什么一维的时候不会发生这样的事啊?
    因为解释器在你改变值的时候给你偷偷换了id:

    a = [0] * 2
    print(id(a[0]))
    print(id(a[1]))
    a[0] = 1
    print(a[0])
    print(a[1])
    print(id(a[0]))
    print(id(a[1]))
    输出:
    140576878282432
    140576878282432
    0
    140576878282464
    140576878282432
    

    在回过来看第一种初始化:

    n = 2
    a = [[0 for _ in range(n)] for _ in range(n)]
    print(id(a[0][0]))
    print(id(a[0][1]))
    print(id(a[1][0]))
    print(id(a[1][1]))
    输出:
    139828550207168
    139828550207168
    139828550207168
    139828550207168
    

    啊,原来一开始的时候大伙都是一样的,当有一个不一样的时候就变出去

    n = 2
    a = [[0 for _ in range(n)] for _ in range(n)]
    a[0][0] = 1
    print(id(a[0][0]))
    print(id(a[0][1]))
    print(id(a[1][0]))
    print(id(a[1][1]))
    输出:
    139828550207200
    139828550207168
    139828550207168
    139828550207168
    

    总结

    第一种正确初始化方式:n * n个元素直接从第一个元素生成而来,一开始的时候大伙都是第一个元素的快捷方式,找任意行任意列的元素都会找到第一个元素。当其他元素有了自己的值以后,就变成独立的元素啦。
    第二种初始化方式:先由一个元素生成一行,再以这一行生成其他行。所以,即使其他行的某个元素改变了,其实也只是在改变第一行的元素。

    更多相关内容
  • C语言中二维数组初始化和作为形参的设定细节

    1、int二维数组初始化方式

    int A[2][3] = {1, 2, 3, 4, 5, 6};
    对应顺序是
    A[0][0]=1; A[0][1]=2; A[0][2]=3;
    A[1][0]=4; A[1][1]=5; A[1][2]=6;
    
    int A[2][3] = {1, 2, 3, 4};
    其中剩余的未赋值元素编译器自动初始化为0。
    数组元素值对应顺序是
    A[0][0]=1; A[0][1]=2; A[0][2]=3;
    A[1][0]=4; A[1][1]=0; A[1][2]=0;
    
    int A[2][3] = {{1, 2, 3}, {4}};
    其中剩余的未赋值元素编译器自动初始化为0。
    数组元素值对应顺序是
    A[0][0]=1; A[0][1]=2; A[0][2]=3;
    A[1][0]=4; A[1][1]=0; A[1][2]=0;
    
    int A[][3] = {{1, 2, 3}, {4}};
    省略行数,切记列数无法省略。其中剩余的未赋值元素编译器自动初始化为0。
    数组元素值对应顺序是
    A[0][0]=1; A[0][1]=2; A[0][2]=3;
    A[1][0]=4; A[1][1]=0; A[1][2]=0;
    

    2、char二维数组初始化方式

    char A[2][3] = {'a', 'b', 'c', 'd'};
    其中未初始化的部分,编译器自动初始为'0'NULL)。
    printf("%s\n", A);
    输出"abcd"
    
    char A[2][3] =  {{'a'}, {'d', 'e', 'f'}};
    其中未初始化的部分,编译器自动初始为'0'NULL)。
    printf("%s\n", A);
    输出"a",输出第一行时遇到结束符导致停止输出。
    
    char A[2][3] = {{'a', 'b', 'c'}, {'d', 'e', 'f'}};
    printf("%s\n", A);
    输出"abcdef"
        
    char A[][3] = {{'a', 'b'}, {'d'}};
    省略行数,切记列数无法省略。
    printf("%s\n", A);
    输出"ab"
    

    3、二维数组作为形参

    想要在函数中传递一个一维数组作为参数,必须以下面三种方式来声明函数形式参数,这三种声明方式的结果是一样的,因为每种方式都会告诉编译器将要接收一个整型指针

    方式1,形式参数是一个指针
    void myFunction1(int *param)
    
    方式2,形式参数是一个已定义大小的数组
    void myFunction2(int param[10])
    
    方式3,形式参数是一个未定义大小的数组
    void myFunction3(int param[])
    
    int param[3] = {0};
    myFunction1(param);
    myFunction2(param);
    myFunction3(param);
    int *param2;
    myFunction1(param2);
    myFunction2(param2);
    myFunction3(param2);
    

    就函数而言,一维数组作为形参时的长度是无关紧要的,因为 C 不会对形式参数执行边界检查。

    同样的方式也可以传递一个多维数组作为形式参数?

    方式1,形式参数是一个指针
    void myFunction1(int **param)
    
    方式2,形式参数是一个已定义大小的数组
    void myFunction2(int param[2][10])
    void myFunction2(int param[2][3])
    
    方式3,形式参数是一个未定义一维宽度的数组
    void myFunction3(int param[][3])
    
    方式4
    void myFunction4(int (*a)[3])
    
    方式5
    void myFunction5(int *a[3])
    
    int param[2][3] = {0};
    myFunction1(param);
    错误,[Error] cannot convert 'int (*)[3]' to 'int**' for argument '1' to 'void myFunction(int**)'int param[2][3]中param其实是"int (*)[3]"类型,不是"int**"类型,这两者不能混用
    myFunction2(param);
    二维宽度为10的错误,[Error] cannot convert 'int (*)[3]' to 'int (*)[10]' for argument '1' to 'void myFunction2(int (*)[10])',可以理解为"int (*)[3]""int (*)[10]"不是一种类型
    为3的正确,二维数组作为函数形参会进行边界检查,所以第二个维度必须一致
    myFunction3(param);
    myFunction4(param);
    myFunction5(param);
    错误,注意如果是int *a[3],因为"[]"的优先级比"*"高,所以会导致该形参被编译器识别为"int**"
    
    int **param2 = (int **)malloc(sizeof(int *) * 2);
    myFunction1(param);
    myFunction2(param);
    myFunction3(param);
    myFunction4(param);
    myFunction5(param);
    只有myFunction1和myFunction5正确,其余的形参都不是"int**"类型
    注意myFunction5中的"a[3]"类似一维数组作形参的效果,不管数组大小都被当作"int *"
    

    4、综合例子

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    // 二维数组作为函数的形式参数会进行边界检查,所以第二个维度必须为5 
    void example(char acHello[][5])
    {
    	printf("%d\n", sizeof(char (*)[5])); // 输出8
    	printf("%d\n", sizeof(acHello)); // 输出8,为sizeof(char (*)[5]),指针为8 
    	printf("%d\n", strlen(acHello[0])); // 输出9,因为acHello[0]并没有'\0'结束符,所以是acHello的总长度 
    	acHello[0][0] = 'c';
    	return;
    }
    
    int main(void)
    {
    	char str[] = "\\\\";
    	printf("%d\n", sizeof(str)); // 输出3,\\其实是转义,所以2个'\'加字符串自带的1个'\0'是3 
    	printf("%d\n", strlen(str)); // 输出2,即2个'\' 
    	
    	char *str2 = "\\\\";
    	printf("%d\n", sizeof(str2)); // 输出8,str是char*类型的指针,指针在64位下都是8 
    	printf("%d\n\n", strlen(str2)); // 输出2,即2个'\' 
    
    	char str3[2][3] = {"qw", "er"};
    	printf("%c ", *(*(str3 + 0) + 0));
    	printf("%c ", *(*(str3 + 0) + 1));
    	printf("%c ", *(*(str3 + 1) + 0));
    	printf("%c\n", *(*(str3 + 1) + 1));
    
    	printf("%c ", *(str3[0] + 0));
    	printf("%c ", *(str3[0] + 1));
    	printf("%c ", *(str3[1] + 0));
    	printf("%c\n", *(str3[1] + 1));
    
    	printf("%c ", str3[0][0]);
    	printf("%c ", str3[0][1]);
    	printf("%c ", str3[1][0]);
    	printf("%c\n\n", str3[1][1]);
    	// *(str3 + 0)等效于str3[0],*(*(str3 + 0) + 0)等效于str3[0][0] 
    
    	char *szStr = "abcde";
    	printf("%c\n", szStr[0]); // 输出a 
    	printf("%llu\n", szStr); // 输出4210713,该值为"abcde"这个常串中字符a所在的地址
    	szStr += 2;
    	printf("%c\n", szStr[0]); // 输出c 
    	printf("%llu\n\n", szStr); // 输出4210715,该值为"abcde"这个常串中字符c所在的地址
    
    	char dqq[][10] = {{'h', 'e', 'l', 'l', 'o'}, {'q', 'w', 'e'}};
    	printf("%s\n", dqq); // 输出hello,因为第一维多的部分被自动初始化为'\0',所以输出的时候截断了 
    	printf("%s\n", dqq[1]); // 将第二维输出,所以是输出qwe
    	printf("%c\n\n", dqq[1][0]); // 输出q
    
    	char acHello[][5] = {{'h', 'e', 'l', 'l', 'o'}, {'h', 'e', 'l', 'l'}};
    	example(acHello);
    	printf("%s\n\n", acHello); // 输出cellohell,由于是传的指针,所以第一个字符被修改为c
    
    	return 0;
    }
    
    展开全文
  • 题目:给定一串文本数据,以 “|” 为分隔符,将其进行分段处理。...博主比较水,第一时间想到的是用二维数组来进行分段,代码如下: char DstMessage[ ][50] = {0}; char Begin=0,End=0,Index=0; for(;.
    题目:给定一串文本数据,以 “|” 为分隔符,将其进行分段处理。
         文本数据:char Message[256] = { "水中月是天上月     | 眼前人是意中人    | 向来心是看客心    |奈何人是剧中人       |      " };

    PS:以下编译器使用:VC++6.0

    博主比较水,第一时间想到的是用二维数组来进行分段,代码如下:

    char DstMessage[ ][50] = {0};
    
    char Begin=0,End=0,Index=0;
    
         for(;End<strlen(Message);End++)
         {
               if(Message[End] == '|')
              {
                    memcpy(DstMessage[Index],&Message[Begin],End-Begin);
    
                    printf("Index = %d,String = %s\n",Index,DstMessage[Index]);
                    Index ++;
                    Begin = End + 1;
    					
               }
         }

         得到的结果并不与预期一致:

         通过汇编可以得到,变量 Index 、Begin 以及 End 内存地址分别如下:

           文本数据存储在地址 “0019FB30” 中:

    而中间则是二维数组开辟的50个字节的空间:

    当遇到第一个符号 “ | ” 时,会将前面的内容复制到二维数组开辟第一维新空间中来:

           而当遇到第二个“|”时,正常来说会将前面的内容复制到二维数组的第二维新空间中去,但是在初始化的时候并没有初始化第二维的空间,怎么办呢?编译器就会在第一维的下方继续开辟一个新空间当作第二维使用:

            但是问题就出现了,上面所提及的文本数据存储在地址 “0019FB30” 中,刚好就这样被覆盖掉了,而字符串打印是以“ \0 ” 为结束标志的,在内存中表示为“ 00 ”,但图中“00”出现位置在“0019FB88”中,所以第二次打印会将圈字符打印出来:

           后面打印的字符由于被覆盖原因导致中文显示不全(一个中文字体需要两个字节组成,若其中一个字节被覆盖就会显示出乱码),就不详细说明了,这个问题如何解决好呢?在二维数组初始化时就把所有维数全部初始化,不要只写一半:

    char DstMessage[4][50] = {0};

           编译器会根据维数开辟足够空间:

    得出的结果是:

    当然,内存会这样分配很大一部分原因是因为编译器内部的内存分配规则是否完美,博主实验室用的编译器是VC++6.0,如果在VS2015上测试时会出现以下情况:

    内存溢出:

    可以知道编译器的不同,内存分配规则也会有所出入,故不能一概而论。

    展开全文
  • 二维数组初始化

    万次阅读 2019-09-26 10:32:19
    (1)二维数组初始化 int a[ ][4]={1,2,3,4,5,6,7,8,9,10,11,12} ; int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12} ; int a[3][4]={ {1,2,3},{4,5,6},{7,8,9},{10,11,12} } ; 这三者赋值方式等价; 这个赋值方法是...

    (1)二维数组的初始化
    int a[ ][4]={1,2,3,4,5,6,7,8,9,10,11,12} ;
    int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12} ;
    int a[3][4]={ {1,2,3},{4,5,6},{7,8,9},{10,11,12} } ;
    这三者赋值方式等价;
    在这里插入图片描述
    这个赋值方法是正确的;

    这种赋值方法是错误的,对于这个定义而言,无法确定是3行几列,(c语言中二维数组是按行存放的,因此必须知道行数,才知道他的逻辑存储结构)

    展开全文
  • C语言的二维数组初始化的几种方式介绍1、直接赋值2、循环对每个元素赋值3、借用memset/memset_s初始化为0或-14、`数组所有元素初始化为相同值` 1、直接赋值 适合数组元素较少的,各元素的值可以不同。 int[2][3] arr...
  • //错误,如果提供了数组初始化操作,则不能定义表达式 int[] a; a = new int[5]; //正确,与(2)相同 int[] a; a = {1,2,3,4,5}; //错误,数据常量只能在初始化操作中使用,如(3) int a[]; a[0] = 1; a[1] = 2...
  • java之二维数组初始化

    2019-11-21 21:16:49
    package libai; public class meihua { public static void main(String[] args) { // TODO Auto-generated method stub char a[][]=new char[4][]; //数组初始化 a[0]=new char[]{'云','想','衣'...
  • C++ vector 二维数组初始化方式

    万次阅读 2019-06-30 15:00:54
    原文:... 在LeetCode刷算法的时候发现,使用vector<vector<int>> 时如果声明时不初始化,会报空指针引用错误:reference binding to null pointer of type 'value_type'。 根据《...
  • java二维数组两种初始化方法

    万次阅读 多人点赞 2019-04-25 00:06:39
    写这篇博客的原因是因为从大一学习c语言开始 就对二维数组的声明 和初始化 一直没有搞懂。。。。直到学到了Java依旧搞得不是很清楚。 先看一道Java的基础题 这道题 错误的选项 是 B. 二维数组初始化的两种...
  • 本文实例讲述了C#二维数组基本用法。分享给大家供大家参考,具体如下: //定义数组 string[,] classes = new string[5, 2]; //正确的C#二维数组使用方法 classes[i, 0] = ; //错误的使用方法 classes[i][0]=; 据说...
  • Java数组及二维数组初始化与赋值方法总结

    万次阅读 多人点赞 2020-05-21 21:47:21
    1.定义数组直接赋值 int a[]= {1,2,3,4,5}; 2.用new在数组中创建元素 int a[]=new int[]{1,2,3}; 注意:后面的[]不要忘...输出结果为[0, 0, 0],Arrays.toString产生一维数组的可打印版本。 4.先声明再赋值 int c
  • 二维数组正确初始化规则

    万次阅读 多人点赞 2019-03-19 20:30:50
    最近刷题总在二维数组初始化这里栽跟头,接下来总结一点二维数组的初始化规则以便记忆 这里提一句一维数字代表行,二维数字代表列 arr[2][3]就是创建两行三列的数组 二维数组在初始化的时候可以分行进行初始化 int...
  • 二维数组初始化

    2020-05-26 20:04:35
    在使用二维数组arr的时候,如果二维数组没有初始化, 进行下标运算的时候,很容易内存泄漏; 在C语言中对二维数组进行初始化 int n = 6; int arr[n][n]; //这样初始化不可以,语法错误 #define N 6 int arr[N]; //...
  • 数组 数组(Array)是在内存中连续存储的具有相同类型的一组数据的集合。 数组是一组相同类型元素的集合。*这些元素在内存中依次连续挨着存放。 数组中,若将有限个类型相同的变量的集合命名,那么这个名称为数组名...
  • 一维数组,二维数组的传参与初始化,没有你想象的那么简单呦~快进来看看这些你都学会了没
  • 二维数组初始化 1) 常规初始化: int arr[3][5] = {{2, 3, 54, 56, 7 }, {2, 67, 4, 35, 9}, {1, 4, 16, 3, 78}}; 2) 不完全初始化: int arr[3][5] = {{2, 3}, {2, 67, 4, }, {1, 4, 16, 78}}; 未被初始化的...
  • • 在函数体内定义的内置数组,其元素无初始化。•不管数组在哪里定义,如果其元素为类类型,则自动调用该类的默认构造函数进行初始化;如果该类没有默认构造函数,则必须为该数组的元素提供显式初始化。使用一组...
  • 一、二维数组的创建 //数组创建 int arr[3][4]; char arr[3][5]; double arr[2][4]; #include<...//二维数组的创建 ...二、二维数组初始化 完全初始化: 不完全初始化二维数组
  • 一维/二维数组的几种初始化方法

    千次阅读 2020-08-03 20:54:18
    维数组初始化方法 方式一:静态初始化 数据类型[] 数组名 = {元素1,元素2,元素3...};//必须在一个语句中完成,不能分开两个语句写 举例: 定义存储1,2,3,4,5整数的数组容器 int[] arr = {1,2,3,...
  • 描述c语言二维数组如何初始化1 有两种方法(1)在定义时可以直接赋值来初始化(2)在定义后可以为其元素一个个来赋值2 示例1234567891011121314151617181920212223242526272829#include《stdio.h》void display(int arr...
  • Java中二维数组的动态初始化

    千次阅读 2020-07-11 17:50:27
    java中二维数组的动态初始化: 使用new关键字实例化,不是直接等于{{“hello”, “world”}, {“I”, “am”, “coming”}} 注意:维度 和 初始化不能同时出现。... //静态初始化一个二维数组 String[][] strArray = {
  • (二)二维数组初始化格式 1.动态初始化 1.1 二维数组格式1 数据类型[][] 变量名 = new 数据类型[m][n]; m表示这个二维数组有多少个一维数组 必须写上 n表示每一个一维数组的元素个数 可选 举例: int[][] arr = new ...
  • 二维数组的使用(包括二维数组的定义,二维数组的声明和初始化(动态初始化,静态初始化),二位数组的常见赋值方法(动态初始化,静态初始化的赋值),错误的定义赋值方法等) 详解均在代码注释里,非常详细,细心...
  • C++开辟动态二维数组的几种方法总结 原文链接:https://blog.csdn.net/xiang_shao344/article/details/99684395 一、用 new 来动态开辟一个二维数组 int **p = new int*[m]; //m行n列型 for (i = 0; i < m; ...
  • 声明二维数组与一维数组一样,使用Dim语句来声明二维数组。例如,语句Dim myArray(3,7) AsInteger声明了一个名为myArray的包含4行8列共32个元素的二维整型数组,如图1所示。 图1也可以使用以下语句,使myArray数组的...
  • Verilog中的二维数组及其初始化

    万次阅读 2019-05-04 00:00:13
    Verilog中的二维数组 Verilog中提供了两维数组来帮助我们建立内存的行为模型。具体来说,就是可以将内存宣称为一个reg类型的数组,这个数组中的任何一个单元都可以通过一个下标去访问。这样的数组的定义方式如下: ...
  • 关于vector二维动态数组初始化

    千次阅读 2017-11-13 16:54:29
    可是,如果我们只知道行或者列其中的一个数量,可以进行动态数组初始化吗?  答案是可以的。如果我们知道行数,那么初始化可以如此写:vector>Name(row,vector(0))。这样的含义是:行数为row,列数为0。那如何对这...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 61,672
精华内容 24,668
关键字:

以下二维数组初始化错误的是