精华内容
下载资源
问答
  • c语言字符串未初始化
    2021-05-19 08:47:01

    C语言字符串初始化错误

    在写指针数组题目时,遇到数字转换问题。

    问题如下:

    将大于0小于1000的阿拉伯数字转换为罗马数字。

    表示个位数:I,II,III,IV,V,VI,VII,VIII,IX

    表示十位数:X,XX,XXX,XL,L,LX,LXX,LXXX,XC

    表示百位数:C,CC,CCC,CD,D,DC,DCC,DCCC,CM

    我选择了查表法。

    第一次(错误的)代码如下:

    #include

    int main()

    {

    char* a[][10] = { "","I","II","III","IV","V","VI","VII","VIII","IX"//应有逗号

    "","X","XX","XXX","XL","L","LX","LXX","LXXX","XC",

    "","C","CC","CCC","CD","D","DC","DCC","DCCC","CM" };//将罗马数字储存在字符串数组里。

    int n, t;

    while (scanf("%d", &n) > 0) {

    for (int i = 0, j = 1000; i < 3; ++i, j /= 10) {

    t = (n % j) / (j / 10);//t为(j-1)所在数位的数值

    printf("%s", a[2 - i][t]);

    }

    printf("\n");

    }

    }

    编译器可以正常运行但一直在警告。

    [Warning] deprecated conversion from string constant to ‘char*’ [-Wwrite-strings]

    //警告:不推荐从字符串常量转换为’char '[-Wwrite-strings]

    为什么呢?

    经过查阅资料,我了解到原来char *背后的含义是:给我个字符串,我要修改它。

    而理论上,我们传给函数的字面常量是没法被修改的。

    所以说,比较合理的办法是把参数类型修改为const char *。

    这个类型说背后的含义是:给我个字符串,我只要读取它。

    第二次(错误的)代码如下:

    #include

    int main()

    {

    const char* a[][10] = { "","I","II","III","IV","V","VI","VII","VIII","IX"//应有逗号

    "","X","XX","XXX","XL","L","LX","LXX","LXXX","XC",

    "","C","CC","CCC","CD","D","DC","DCC","DCCC","CM" };//将罗马数字储存在字符串数组里。

    int n, t;

    while (scanf("%d", &n) > 0) {

    for (int i = 0, j = 1000; i < 3; ++i, j /= 10) {

    t = (n % j) / (j / 10);

    printf("%s", a[2 - i][t]);

    }

    printf("\n");

    }

    }

    经过测试得到以下数据

    1

    CXI

    9

    CXIX

    10

    CXX

    11

    CXXI

    99

    CIX

    100

    CCX

    150

    CCLX

    999

    (null)IX

    一开始看到这串数据,我整个人都炸了。

    经过多次推理,我坚信我解题的逻辑并没有问题

    但我锲而不舍地测试以及学长的帮助下后,代码终于崎岖且正确了。

    第三次(正确的)代码如下:

    int main()

    {

    const char* a[][10] = { "","I","II","III","IV","V","VI","VII","VIII","IX"//应有逗号

    "","X","XX","XXX","XL","L","LX","LXX","LXXX","XC",

    "","C","CC","CCC","CD","D","DC","DCC","DCCC","CM" };//将罗马数字储存在字符串数组里。

    int n, t;

    while (scanf("%d", &n) > 0) {

    if (n < 10)

    printf("%s", a[0][n]);

    else {

    for (int i = 0, j = 1000; i < 3; ++i, j /= 10) {

    t = (n % j) / (j / 10);

    if (i == 2)

    printf("%s", a[2 - i][t]);

    else if(t>=1)

    printf("%s", a[2 - i][t - 1]);

    }

    }

    printf("\n");

    }

    }

    经过测试代码正确,这说明字符数组存储""是无效的。

    但我一直在想,它为什么会是无效的?

    看了很多资料,我一直都没有找到答案。

    刚刚在优化代码的时候无意中发现了字符串数组a[0][10]"IX"后没有逗号。

    第四次(正确的)代码如下:

    #include

    int main()

    {

    const char* a[][10] = { "","I","II","III","IV","V","VI","VII","VIII","IX",

    "","X","XX","XXX","XL","L","LX","LXX","LXXX","XC",

    "","C","CC","CCC","CD","D","DC","DCC","DCCC","CM" };//将罗马数字储存在字符串数组里。

    int n, t;

    while (scanf("%d", &n) > 0) {

    for (int i = 0, j = 1000; i < 3; ++i, j /= 10) {

    t = (n % j) / (j / 10);

    printf("%s", a[2 - i][t]);//t为(j-1)所在数位的数值

    }

    printf("\n");

    }

    }

    没想到一个简简单单的符号引起了一系列的错误。

    写代码一定要严谨呀!

    更多相关内容
  • 都会出错,于是我将错误定位到输入边的这个位置 上面就是我在循环之前,定义了两个字符指针,准备用来存放字符串,但是只要一scanf之后,只要访问其中某一个变量就会出现段错误,难道是说这个地址不能别访问?...

    之前,我在做图的存储结构的时候,用邻接矩阵来表示一张图,遇到一个段错误问题:

    上面只要一输入一条边,就会出现段错误,而段错误,往往就是内存地址访问出错,比如数组越界,访问了未分配的地址,访问系统已经分配的地址,都会出错,于是我将错误定位到输入边的这个位置

    上面就是我在循环之前,定义了两个字符指针,准备用来存放字符串,但是只要一scanf之后,只要访问其中某一个变量就会出现段错误,难道是说这个地址不能别访问?

    于是我做了一个实验,如下操作:

    直接上代码:

    #define _CRT_SECURE_NO_WARNINGS
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    
    
    void test(char* str)
    {
    	printf("str=%s\n", str);
    	if (strcmp("love", str) == 0) {
    		printf("哈哈,字符串相等\n");
    	}
    	else 
    	{
    		printf("字符串不相等\n");
    	}
    }
    
    int main()
    {
    	char* v1;
    	scanf("%s", &v1);
    	test(v1);
    	system("pause");
    	return 0;
    }

       然后就会内存地址访问错误

       那我又改成如下代码:

    #define _CRT_SECURE_NO_WARNINGS
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    
    
    void test(char* str)
    {
    	printf("str=%s\n", str);
    	if (strcmp("love", str) == 0) {
    		printf("哈哈,字符串相等\n");
    	}
    	else 
    	{
    		printf("字符串不相等\n");
    	}
    }
    
    int main()
    {
    	
    	test("love");
    
    	system("pause");
    	return 0;
    }

    运行正常:

            

            

    换句话说,问题就出在:

             

     也就是说,不能用sacnf来初始化char*,下面我们就来分析一下:

      

    那么就是说,char* p存放的是常量字符串的地址,那我们就不能用scanf来初始化 ,因为如果用scanf来初始化,我们根本在常量区没有空间指向。而且就算有空间指向了常量区,也不能用scanf去初始化,比如如下:

            

    因为常量区的数据读写本来就是一旦定义了就不允许改动的 

    那么如果我们非要用scanf来初始化一个字符串呢,那么这里我们第一时间考虑的应该是一个字符数组,代码如下:

            

    #define _CRT_SECURE_NO_WARNINGS
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    
    
    void test(char* str)
    {
    	printf("str=%s\n", str);
    	if (strcmp("love", str) == 0) {
    		printf("哈哈,字符串相等\n");
    	}
    	else 
    	{
    		printf("字符串不相等\n");
    	}
    }
    
    int main()
    {
    	char str[10] = "pxx";//OK,并且带有'\0'
    	scanf("%s", str);
    	test(str);//char*指向了一个数组空间
    	system("pause");
    	return 0;
    }

     运行结果:

            

    对于test来说,相当于用char* str指向了char str[10]的这片数组空间,这个时候char*  str有指向了,并且可以改动,我们既可以用scanf来直接赋值。

            代码改动如下:

                     

            运行结果:

             

    展开全文
  • C语言字符串初始化

    千次阅读 2021-03-19 14:27:23
    字符串是最常用的数据类型之一。C语言中,是没有类型来存储字符串的,字符串被看做是一组连续的类型。所以,字符串有两种表示方法,分别是字符数组和字符指针,而这两种表示的初始化却又不尽相同...

    字符串是最常用的数据类型之一。

    C语言中,是没有String类型来存储字符串的,字符串被看做是一组连续char类型。

    所以,字符串有两种表示方法,分别是字符数组字符指针,而这两种表示的初始化却又不尽相同。

    为了方便比较结果,定义全局变量LENGTH15,定义输出函数print如下:

    /** Display the outputs.
     * args: chars[], The char array to print.
     *       length, The size of the char array you wanna print.
     *       type, Tht format you wanna print those chars.
     *              16: hexadecimal
     *               0: chars
     */
    void print(char* chars, int length, int type){
        // printf("%ld:", sizeof(chars));
        if (type == 16)
        {
            for (int i = 0; i < length; i++)
            {   
                printf("0x%x ", *(chars + i));
            }
        } else if (type == 0)
        {
            for (int i = 0; i < length; i++)
            {   
                printf("%c", *(chars + i));
            }
        }
        
        printf("\n");
    }
    

    其中type0时直接输出字符串,为16时,以16进制输出。

    字符数组

    以字符串赋值

    char array_1[LENGTH] = "array_1";
    print(array_1, LENGTH, 16);
    printf("%ld\n", sizeof(array_1));
    

    先来看结果

    0x61 0x72 0x72 0x61 0x79 0x5f 0x31 0x0 0x0 0x0 0x0 0x0 0x0 0x0 0x0 
    15
    

    这种情况下,字符串以0结尾,并且没有赋值的部分,也都已经初始化为char类型的0

    strcpy赋值

    char array_2[LENGTH];
    strcpy(array_2, "array_2");
    print(array_2, LENGTH, 16);
    printf("%ld\n", sizeof(array_1));
    

    结果为

    0x61 0x72 0x72 0x61 0x79 0x5f 0x32 0x0 0xfffffff0 0x6c 0x7f 0x0 0x0 0xffffffc0 0xfffffff3
    15
    

    可见,使用strcpy函数赋值,字符串到\0结束,之后的数据,类型都是随机的。

    和方法一对比可知,字符数组在声明时,是没有初始化为全零的。

    以字符数组赋值

    在C语言中,一个字符串结束的标志位是\0, 那么在用于初始化的字符数组最后一位要不要写\0呢?

    不加\0的情况:

    char array_3[LENGTH] = {'a', 'r', 'r', 'a', 'y', '_', '3'};
    print(array_3, LENGTH, 16);
    printf("%ld\n", sizeof(array_1));
    

    结果为

    0x61 0x72 0x72 0x61 0x79 0x5f 0x33 0x0 0x0 0x0 0x0 0x0 0x0 0x0 0x0
    15
    

    \0的情况

    char array_4[LENGTH] = {'a', 'r', 'r', 'a', 'y', '_', '4', '\0'};
    print(array_4, LENGTH, 16);
    printf("%ld\n", sizeof(array_1));
    

    结果为

    0x61 0x72 0x72 0x61 0x79 0x5f 0x34 0x0 0x0 0x0 0x0 0x0 0x0 0x0 0x0
    15
    

    可见,这两种方法并没有什么区别。直接赋值时,数组会按声明的长度,把每个位置都初始化为\0

    值得一提

    • 声明为数组的变量,是不能先申明,再用常量赋值的。以下两种写法都不能通过编译
    char array_5[LENGTH];
    array_5 = "test";
    array_5 = {'t', 'e', 's', 't'};
    
    • 另外,用sizeof实际上是求的指针变量的大小,也就是数组声明的长度。但是用strlen函数可以求出字符串的有效长度,也就是到\0的长度,可自行验证

    字符指针

    在将变量声明为指针时,只有两种赋值方法。

    以字符串直接赋值

    char* pointer_1 = "pointer_1";
    print(pointer_1, LENGTH, 16);
    printf("%ld\n", sizeof(pointer_1));
    

    结果为

    0x70 0x6f 0x69 0x6e 0x74 0x65 0x72 0x5f 0x31 0x0 0x70 0x6f 0x69 0x6e 0x74
    8
    

    值得注意的是,此时,sizeof便可求出字符串的有效长度了。

    以字符串间接赋值

    char* pointer_5;
    pointer_5 = "pointer_5";
    print(pointer_5, LENGTH, 16);
    printf("%ld\n", sizeof(pointer_1));
    

    结果为

    0x70 0x6f 0x69 0x6e 0x74 0x65 0x72 0x5f 0x35 0x0 0x0 0x1 0x1b 0x3 0x3b
    8
    

    其他方法

    • 在使用**strcpy函数赋值**时,编译器会提示指针变量未初始化。

      可见以数组声明时,虽然数组中的值没有初始化为0,但是地址空间已经得到了。

      而用指针声明时,没有指明长度,自然没办法申请空间。

    • 至于用字符数组赋值的方法,由于现在变量是声明为字符指针的,类型不同,自然是行不通的。

    完整测试代码

    #include<stdlib.h>
    #include<string.h>
    #include<stdio.h>
    
    #define LENGTH 15
    
    
    /** Display the outputs.
     * args: chars[], The char array to print.
     *       length, The size of the char array you wanna print.
     *       type, Tht format you wanna print those chars.
     *              16: hexadecimal
     *               0: chars
     */
    void print(char* chars, int length, int type){
        // printf("%ld:", sizeof(chars));
        if (type == 16)
        {
            for (int i = 0; i < length; i++)
            {   
                printf("0x%x ", *(chars + i));
            }
        } else if (type == 0)
        {
            for (int i = 0; i < length; i++)
            {   
                printf("%c", *(chars + i));
            }
        }
        
        printf("\n");
    }
    
    
    int main()
    {
        // Define as array;
        char array_1[LENGTH] = "array_1";
        print(array_1, LENGTH, 16);
        printf("%ld\n", sizeof(array_1));
    
        char array_2[LENGTH];
        strcpy(array_2, "array_2");
        print(array_2, LENGTH, 16);
        printf("%ld\n", sizeof(array_1));
    
    
        char array_3[LENGTH] = {'a', 'r', 'r', 'a', 'y', '_', '3'};
        print(array_3, LENGTH, 16);
        printf("%ld\n", sizeof(array_1));
    
        char array_4[LENGTH] = {'a', 'r', 'r', 'a', 'y', '_', '4', '\0'};
        print(array_4, LENGTH, 16);
        printf("%ld\n", sizeof(array_1));
    
    
        // char array_5[LENGTH];
        // array_5 = "test";
    
        // Define as pointer.
        char* pointer_1 = "pointer_1";
        print(pointer_1, LENGTH, 16);
        printf("%ld\n", sizeof(pointer_1));
    
        // char* pointer_2;
        // strcpy(pointer_2, "pointer_2");
        // print(pointer_2, LENGTH, 16);
    
        // char* pointer_3 = {'p', 'o', 'i', 'n', 't', 'e', 'r', '_', '3'}; 
        // print(pointer_3, LENGTH, 16);
    
        // char* pointer_4 = {'p', 'o', 'i', 'n', 't', 'e', 'r', '_', '3', '\0'};
        // print(pointer_4, LENGTH, 16);
    
        char* pointer_5;
        pointer_5 = "pointer_5";
        print(pointer_5, LENGTH, 16);
        printf("%ld\n", sizeof(pointer_1));
    
        return 0;
    }
    
    
    展开全文
  • c语言字符串初始化 数组方式初始化 int main(){ char string[]="character type"; char string[32]="character type";//这种方式定义的数组大小一定要大于字符串的长度; return 0; } 可以使用指针加法 *...

    c语言字符串的初始化

    数组方式初始化

    int main(){
    	char string[]="character type";
    	char string[32]="character type";//这种方式定义的数组大小一定要大于字符串的长度;
    	return 0;
    }
    
    • 可以使用指针加法 *(string+1)
    • 不可使用指针自增
    • 会重新分配内存给string并复制"character type"到新地址,原始"character type"在数据段.

    指针方式初始化

    int main(){
    	char* string="character type";
    	const char* string1="character type";
    	return 0;
    }
    
    • 可数组方式访问元素
    • 可进行指针加法
    • 可使用指针自增
    • string指向数据段中的"character type";指针方式初始化时最好使用const限定符,相同字符串字面量编译器在编译时使用的同一个地址储存数据,如下代码打印的数据就是很好的证明.
    #include <stdio.h>
    #include <string.h>
    
    int main() {
        char heart[] = "I love Tillie!";
        printf("%s\n", heart);
        int len = strlen(heart);
        for (int i = 0; i < len; ++i) {
            *(heart + i) = '\0';
    
        }
        printf("%s\n", heart);
    
    
        char *head = "I love Millie!";
        printf("%s\n", head);
        len = strlen(head);
        for (int j = 0; j < len; ++j, head++) {
            *head = 0;
        }
        printf("%s\n", head);
        printf("%s", "I love Millie!");
        return 0;
    }
    
    /home/dp/dir/cstudy/server/cmake-build-clion/test4
    I love Tillie!
    
    I love Millie!
    
    Process finished with exit code 139 (interrupted by signal 11: SIGSEGV)
    
    展开全文
  • C语言中的字符串初始化

    万次阅读 多人点赞 2019-03-09 18:30:33
    1、C语言没有字符串类型,通过字符数组模拟,C语言字符串,以字符‘\0’, 数字0。 2、数组指定长度后,后面没有赋值的元素,自动补0。 char buf[100] = { 'a', 'b', 'c' }; 3、所有元素赋值为0。 char ...
  • //字符数组的初始化 char c1[3] = {'A','a','c'}; printf(&quot;%d\n&quot;, sizeof(c1)); //3 char c2[10] = { 'A', 'a', 'c'}; printf(&quot;%d\n&quot;, sizeof(c2)); //10 char c3[] = { 'A'...
  • C 字符串数组初始化问题

    千次阅读 2021-05-19 09:29:16
    1、定义的时候直接用字符串赋值char a[10]="hello";注意:不能先定义再给它赋值,如char a[10]; a[10]="hello";这样是错误的!2、对数组中字符逐个赋值char a[10]={'h','e','l','l','o'};3、利用strcpychar a[10]; ...
  • 浅析C语言字符串初始化

    万次阅读 2017-03-11 19:34:19
    在说c的字符串之前,先来看看另一个东西,字符数组。这两者的区别搞清楚了,看到...可以看到上面的形式就是一般的数组初始化形式。 如果改成: char CharArray[6]={'h','e','l','l','o','\0'}; 这其实就是一个...
  • C语言字符数组未初始化的问题

    千次阅读 2018-11-11 19:32:53
    今天写一个十六进制数转换八进制数的算法,调了一天都发现有错,最后一步一步测试,发现是字符数组没有初始化的问题,但是其中的原因让我费解,甚至是感到不可思议。 以下是遇到问题的代码部分: int main(){ int ...
  • 字符数组的初始化与赋值 ...C语言中表示字符串有两种方式,数组和指针,字符数组是我们经常使用的方式。变量的定义包括指明变量所属类型、变量名称、分配空间以及初始化。可以看出,变量的初始化是变量定义的...
  • C语言字符串初始化与操作

    万次阅读 多人点赞 2016-08-01 21:44:40
    C语言中字符一般是单引号,而字符串是双引号,且字符串是以NULL(\0)结尾的零个或多个字符序列。C中没有字符串这个数据类型的,只能通字符数组或者字符指针来存储字符串变量。下面具体看看C中字符串怎么实现和操作 ...
  • c语言未初始化变量的后果

    千次阅读 2020-08-28 11:43:53
    如果在c语言未初始化变量会有什么结果? 注意:以下代码均在Microsoft visual c++ 6.0中测试 在vc6.0中如果未初始化变量不会报错误; 全局变量未初始化(int),打印结果为0; 局部变量未初始化(int),...
  • C语言中字符数组的初始化与赋值,字符串相关函数

    万次阅读 多人点赞 2018-09-23 20:56:37
    C语言中字符数组的初始化与赋值,字符串相关函数! 1.字符数组初始化C语言中,字符串是当做字符数组来处理的;所以字符串有两种声明方式,一种是字符数组,一种是字符指针。 (1)直接逐个初始化字符数组:...
  • C语言数组字符串初始化问题C语言中,初始化操作就是在定义变量的时候,对变量进行赋值,即称为变量的初始化。对于字符变量也是一样的。 举例如下: char ch='a'; // 定义一个字符变量,变量名为ch,并进行初始化char...
  • C语言数组字符串初始化问题恋爱语录:能牵手的时候,请别肩并肩,能拥抱的时候,请别手牵手,能相爱的时候,请别说分开;拥有了爱情,请别去碰暧昧字符数组的定义与初始化字符数组的初始化,最容易理解的方式就是...
  • C语言字符串类型题目

    2019-11-30 14:21:27
    其功能是统计w指向的数组中的n个单词在a指向的字符串中各自出现的次数(将非字母字符看做单词分隔符),并将统计结果依次保存在b指向的数组中。 ⑵ 编写main()函数,采用数组定义的同时进行初始化的方式,将数据...
  • 一、字符数组的定义和初始化 字符数组的初始化,最容易理解的方式就是逐个字符赋给数组中各元素。 charstr[10]={'I','','a','m','',‘h’,'a','p','p','y'}; 即把10个字符分别赋给str[0]到str[9]10个元素 如果花...
  • C语言字符串初始化字符数组

    千次阅读 2018-04-13 11:11:48
    #include&...//作为字符数组应该是五个字节(\o),作为字符串是四个字节 int len=strlen(buf);//长度,不包括0 printf("%d\n",len); size=sizeof(buf);//内存块大小 printf("%...
  • C语言 字符串指针初始化

    千次阅读 2013-05-10 00:02:54
    #include "stdio.h" #include "stdlib.h" int main(){  char *ps=(char*)malloc(sizeof(char)*3);  ps="abc";  free(ps);  printf("%s.\n",ps); }
  • 复制字符 c(一个无符号字符)到参数 str 所指向的字符串的前 n 个字符 返回值:该值返回一个指向存储区 str 的指针。 参数 (1)str – 指向要填充的内存块。 (2)c – 要被设置的值。该值以 int 形式传递,但是...
  • //以字符串形式出现的,编译器会在结尾自动添加\0 const char *str2="hello world";//以字符串形式出现的,编译器会在结尾自动添加\0 //等价与const char *str2;str2="hello world";//str2的值为hello wolrd,即 ...
  • 3、注意:在字符数组长度确定的情况下,如果用于初始化初始化列表或者字符串常量长度大于字符数组长度,则会出现语法错误。 最后再讨论用scanf()进行格式化输入字符串的各种情形 1、对于键盘输入字符串长度...
  • c语言字符串1

    2021-01-12 23:42:39
    下一篇:c语言字符串2 字符数组 char word[]={'H','e','l','l','o','!'}; 这不是c语言的字符串,因为不能用字符串的方式做计算 如何定义字符串? char word[]={'H','e','l','l','o','\0'}; 这才是字符...
  • C语言字符串

    千次阅读 多人点赞 2022-04-15 19:05:27
    字符串字面量是const 的数据(常量),由于 *b 指向这个 const 数据,所以实际上b 是const char * b ,但是由于历史的原因,编译器接受不带 const 的写法,这意味这不能用 b 改变它指向的数据,但是仍然可以改变 b ...
  • 众所周知,C语言中没有数据类型能够存储字符串,char数据类型仅仅能够存储一个字符的数据,那么在C语言中关于存储字符串这一难题我们改何去何从呢? 下面将详述相关的字符串存储方法; 1、使用字符数组存; [root@Qrui...
  • C语言 字符串拷贝

    千次阅读 2021-10-31 16:00:33
    C语言 字符串拷贝 2020.10.31 字符串的拷贝有几种写法 代码: 1.简单数组式写法 #include<stdio.h> void My_strcpy1(char crr[],char arr[]) { int i; for (i = 0; arr[i] != '\0'; i++) { crr[i] = arr...
  • 由外部对字符串初始化的方法 设定义字符串为 char str[10]; 1.for循环+scanf(“%c”,str);一个一个输入字符 2.直接用scanf(“%s”,str);直接输入一整串字符 3.包含在头文件<stdio.h>中的gets函数,也可以...
  • C语言字符串匹配函数

    千次阅读 2021-05-19 07:54:35
    C语言字符串匹配函数,保存有需要时可以用:#include #include #include #include #include /*pattern:pos:*/static int badShift[];static int goodPostfixLastPos(const char *pattern,int pos){#define _break...
  • 字符数组及其定义和初始化C语言字符数组详解字符串的存储方式有字符数组和字符指针,我们先来看看字符数组。因为字符串是由多个字符组成的序列,所以要想存储一个字符串,可以先把它拆成一个个字符,然后分别对...
  • C语言字符数组的初始化

    千次阅读 2018-03-22 23:21:41
    C语言字符数组有几种不同的初始化方式, 它们之间存在着一些差别. char message1[] = {'h', 'e', 'l', 'l', 'o'}; 执行上述初始化后内存情况为: 注意到字符数组并不是以 ‘\0’ 结尾. char message2[] = {'h', ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 141,861
精华内容 56,744
热门标签
关键字:

c语言字符串未初始化