char 订阅
char用于C或C++中定义字符型变量,只占一个字节,取值范围为 -128 ~ +127(-2^7~2^7-1)。C语言中如int、long、short等不指定signed或unsigned时都默认为signed,但char在标准中不指定为signed或unsigned,编译器可以编译为带符号的,也可以编译为不带符号的。 [1] 展开全文
char用于C或C++中定义字符型变量,只占一个字节,取值范围为 -128 ~ +127(-2^7~2^7-1)。C语言中如int、long、short等不指定signed或unsigned时都默认为signed,但char在标准中不指定为signed或unsigned,编译器可以编译为带符号的,也可以编译为不带符号的。 [1]
信息
外文名
char
类    型
C/C++整型数据之一
定    义
可容纳单个字符的数据类型
中文名
字符
范    围
-128 ~ +127
charchar数据类型
(1)定义:char型数据是计算机编程语言中只可容纳单个字符的一种基本数据类型。(2)取值范围:char : -2^7 ~ 2^7-1 ;  signed char: -2^7 ~ 2^7-1  unsigned char : 0 ~ 2^8-1而且关于char还有一个特殊的语言就是char *,它在C/C++中有专门的语义,既不同于signed char *,也不同于unsigned char *,专门用于指以'\0'为结束的字符串。 [2]  在C++中,下列程序是可以通过编译的:但如果用或都是不能通过编译的。 [3]  判断编译器的默认char符号方法如下:
收起全文
精华内容
参与话题
问答
  • char码值对应列表大全

    万次阅读 2018-09-06 16:39:56
    Char(“0”) 为0的字符 Char(“1”) Char(“2”) Char(“3”) Char(“4”) Char(“5”) Char(“6”) Char(“7”) 响铃 Char(“8”) 回格 Char(“9”) tab(水平制表符) Char(“10”) 换行 Char(“11”) ...

    Char(“0”) 为0的字符
    Char(“1”)
    Char(“2”)
    Char(“3”)
    Char(“4”)
    Char(“5”)
    Char(“6”)
    Char(“7”) 响铃
    Char(“8”) 回格
    Char(“9”) tab(水平制表符)
    Char(“10”) 换行
    Char(“11”) tab(垂直制表符)
    Char(“12”) 换页
    Char(“13”) 回车 chr(13)&chr(10) 回车和换行的组合
    Char(“14”)
    Char(“15”)
    Char(“16”)
    Char(“17”)
    Char(“18”)
    Char(“19”)
    Char(“20”)
    Char(“21”)
    Char(“22”)
    Char(“23”)
    Char(“24”)
    Char(“25”)
    Char(“26”) 结束 End
    Char(“27”) 脱离 Pause break
    Char(“28”)
    Char(“29”)
    Char(“30”)
    Char(“31”)
    Char(“32”) 空格 SPACE
    Char(“33”) !
    Char(“34”) ”
    Char(“35”) #
    Char(“36”) $
    Char(“37”) %
    Char(“38”) &
    Char(“39”) ’
    Char(“40”) (
    Char(“41”) )
    Char(“42”) * 
    Char(“43”) +
    Char(“44”) ,
    Char(“45”) -
    Char(“46”) .
    Char(“47”) /
    Char(“48”) 0
    Char(“49”) 1
    Char(“50”) 2
    Char(“51”) 3
    Char(“52”) 4 
    Char(“53”) 5
    Char(“54”) 6
    Char(“55”) 7
    Char(“56”) 8
    Char(“57”) 9 
    Char(“58”) :
    Char(“59”) ;
    Char(“60”) <
    Char(“61”) =
    Char(“62”) > 
    Char(“63”) ?
    Char(“64”) @
    Char(“65”) A
    Char(“66”) B
    Char(“67”) C 
    Char(“68”) D
    Char(“69”) E
    Char(“70”) F
    Char(“71”) G
    Char(“72”) H 
    Char(“73”) I
    Char(“74”) J
    Char(“75”) K
    Char(“76”) L
    Char(“77”) M 
    Char(“78”) N
    Char(“79”) O
    Char(“80”) P
    Char(“81”) Q
    Char(“82”) R 
    Char(“83”) S
    Char(“84”) T
    Char(“85”) U
    Char(“86”) V
    Char(“87”) W 
    Char(“88”) X
    Char(“89”) Y
    Char(“90”) Z
    Char(“91”) [
    Char(“92”) \ 
    Char(“92”) \
    Char(“93”) ]
    Char(“94”) ^
    Char(“95”) _
    Char(“96”) `
    Char(“97”) a 
    Char(“98”) b
    Char(“99”) c
    Char(“100”) d
    Char(“101”) e
    Char(“102”) f 
    Char(“103”) g
    Char(“104”) h
    Char(“105”) i
    Char(“106”) j
    Char(“107”) k 
    Char(“108”) l
    Char(“109”) m
    Char(“110”) n
    Char(“111”) o
    Char(“112”) p 
    Char(“113”) q
    Char(“114”) r
    Char(“115”) s
    Char(“116”) t
    Char(“117”) u 
    Char(“118”) v
    Char(“119”) w
    Char(“120”) x
    Char(“121”) y
    Char(“122”) z 
    Char(“123”) {
    Char(“124”) |
    Char(“125”) }
    Char(“126”) ~
    Char(“127”)
    Char(“128”) €
    Char(“129”)
    Char(“130”) ‚
    Char(“131”) ƒ
    Char(“132”) „
    Char(“133”) …

    其实也可以一个循环就读出来

    for (int i = 0; i < 133; i++)
                {
                    char a = (char)i;
                    Console.WriteLine("Char("+i+")----"+a);
                }
    展开全文
  • 深入 char * ,char ** ,char a[ ] ,char *a[]

    万次阅读 多人点赞 2016-09-19 19:52:18
    1 数组的本质 数组是多个元素的集合,在内存中分布在地址相连的单元中,所以可以通过其下标访问不同单元的元素。 2 指针。 指针也是一种变量,只不过它的内存单元中保存的是一个标识其他位置的地址。...

    前些天发现了一个巨牛的人工智能学习网站,通俗易懂,风趣幽默,忍不住分享一下给大家。点击跳转到教程 

     

    1 数组的本质


       数组是多个元素的集合,在内存中分布在地址相连的单元中,所以可以通过其下标访问不同单元的元素。

     

     

     

     

     2 指针。


       指针也是一种变量,只不过它的内存单元中保存的是一个标识其他位置的地址。。由于地址也是整数,在32位平台下,指针默认为32位。。

     

     

     

     

     

     

     3 指针的指向?


       指向的直接意思就是指针变量所保存的其他的地址单元中所存放的数据类型。

       int  * p ;//p 变量保存的地址所在内存单元中的数据类型为整型

       float *q;// ........................................浮点型

       不论指向的数据类型为那种,指针变量其本身永远为整型,因为它保存的地址。

     

     

     

     

     

     

     

     4  字符数组。。。


        字面意思是数组,数组中的元素是字符。。确实,这就是它的本质意义。

        char  str[10];
        定义了一个有十个元素的数组,元素类型为字符。

       C语言中定义一个变量时可以初始化。

        char  str[10] = {"hello"};

        当编译器遇到这句时,会把str数组中从第一个元素把hello\0 逐个填入。。

        由于C语言中没有真正的字符串类型,可以通过字符数组表示字符串,因为它的元素地址是连续的,这就足够了。

        C语言中规定数组代表数组所在内存位置的首地址,也是 str[0]的地址,即str = &str[0];

        而printf("%s",str); 为什么用首地址就可以输出字符串。。

        因为还有一个关键,在C语言中字符串常量的本质表示其实是一个地址,这是许多初学者比较难理解的问题。。。

        举例:

        char  *s ;

        s = "China";

        为什么可以把一个字符串赋给一个指针变量。。

        这不是类型不一致吗???

        这就是上面提到的关键 。。

        C语言中编译器会给字符串常量分配地址,如果 "China", 存储在内存中的 0x3000 0x3001 0x3002 0x3003 0x3004 0x3005 .

        s = "China" ,意识是什么,对了,地址。

        其实真正的意义是 s ="China" = 0x3000;

        看清楚了吧 ,你把China 看作是字符串,但是编译器把它看作是地址 0x3000,即字符串常量的本质表现是代表它的第一个字符的地址。。。。。。。。。。

        s = 0x3000

        这样写似乎更符合直观的意思。。。

        搞清楚这个问题。。

        那么 %s ,它的原理其实也是通过字符串首地址输出字符串,printf("%s ", s);   传给它的其实是s所保存的字符串的地址。。。

        比如
        #include <stdio.h>  

        int main()  
        {  
          char *s;  
          s = "hello";  
          printf("%p\n",s);  
          return 0;  
        }  

        结果:

        00422020

        可以看到 s = 0x00422020 ,这也是"hello"的首地址

        所以,printf("%s",0x00422020);也是等效的。。

         

        字符数组:

        char  str[10] = "hello";

        前面已经说了,str = &str[0] , 也等于 "hello"的首地址。。

        所以printf("%s",str); 本质也是 printf("%s", 地址");

        C语言中操作字符串是通过它在内存中的存储单元的首地址进行的,这是字符串的终极本质。。。


    5  char *  与 char  a[ ];

       char  *s;

       char  a[ ] ;

       前面说到 a代表字符串的首地址,而s 这个指针也保存字符串的地址(其实首地址),即第一个字符的地址,这个地址单元中的数据是一个字符,

       这也与 s 所指向的 char 一致。

       因此可以 s = a;
       但是不能 a = s;
       C语言中数组名可以复制给指针表示地址, 但是却不能赋给给数组名,它是一个常量类型,所以不能修改。。
       当然也可以这样:

        char  a [ ] = "hello";  
        char *s =a;  
        for(int i= 0; i < strlen(a) ; i++)  
              printf("%c", s[i]);  
        或  printf("%c",*s++);

        字符指针可以用 间接操作符 *取其内容,也可以用数组的下标形式 [ ],数组名也可以用 *操作,因为它本身表示一个地址 。。

        比如 printf("%c",*a);  将会打印出 'h'

        char * 与 char a[ ] 的本质区别:

        当定义 char a[10 ]  时,编译器会给数组分配十个单元,每个单元的数据类型为字符。。

        定义 char *s 时,  这是个指针变量,只占四个字节,32位,用来保存一个地址。。

        sizeof(a) = 10 ;
     
        sizeof(s)  = ?

        当然是4了,编译器分配4个字节32位的空间,这个空间中将要保存地址。。。

        printf("%p",s);

        这个表示 s 的单元中所保存的地址。。

        printf("%p",&s);

        这个表示变量本身所在内存单元地址。。。。,不要搞混了。。

        用一句话来概括,就是 char *s 只是一个保存字符串首地址的指针变量, char a[] 是许多连续的内存单元,单元中的元素为char ,之所以用 char *能达到

        char a[] 的效果,还是字符串的本质,地址,即给你一个字符串地址,便可以随心所欲的操所他。。但是,char* 和 char a[ ] 的本质属性是不一样的。。

        

     

     

     

    6 char **  与char  *a[ ] ;


      先看 char  *a[ ] ;

      由于[ ] 的优先级高于* 所以a先和 [ ]结合,他还是一个数组,数组中的元素才是char * ,前面讲到char * 是一个变量,保存的地址。。

      所以 char *a[ ] = {"China","French","America","German"};

      同过这句可以看到, 数组中的元素是字符串,那么sizeof(a) 是多少呢,有人会想到是五个单词的占内存中的全部字节数 6+7+8+7 = 28;

      但是其实sizeof(a) = 16;

      为什么,前面已经说到, 字符串常量的本质是地址,a 数组中的元素为char * 指针,指针变量占四个字节,那么四个元素就是16个字节了

      看一下实例:

      #include <stdio.h>  
      int main()  
      {  
        char *a [] = {"China","French","America","German"};  
        printf("%p %p %p %p\n",a[0],a[1],a[2],a[3]);  
        return 0;  
      }  
     
      可以看到数组中的四个元素保存了四个内存地址,这四个地址中就代表了四个字符串的首地址,而不是字符串本身。。。

      因此sizeof(a)当然是16了。。

      注意这四个地址是不连续的,它是编译器为"China","French","America","German" 分配的内存空间的地址, 所以,四个地址没有关联。

      #include <stdio.h>  
      int main()  
      {  
        char *a [ ] = {"China","French","America","German"};  
        printf("%p %p %p %p\n",a[0],a[1],a[2],a[3]); //数组元素中保存的地址  
        printf("%p %p %p %p\n",&a[0],&a[1],&a[2],&a[3]);//数组元素单元本身的地址  
        return 0;  
      }  

      可以看到 0012FF38 0012FF3C 0012FF40 0012FF44,这四个是元素单元所在的地址,每个地址相差四个字节,这是由于每个元素是一个指针变量占四个字节。。。

      char **s;
      char **为二级指针, s保存一级指针 char *的地址,关于二级指针就在这里不详细讨论了 ,简单的说一下二级指针的易错点。  

      举例:
      char *a[] = {"China","French","America","German"};  
      char **s = a;  

      为什么能把 a赋给s,因为数组名a代表数组元素内存单元的首地址,即 a = &a[0] = 0012FF38;

      而 0x12FF38即 a[0]中保存的又是 00422FB8 ,这个地址, 00422FB8为字符串"China"的首地址。

      *s = 00422FB8 = "China";

      这样便可以通过s 操作 a 中的数据

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

      都是一样的。。。

      但还是要注意,不能a = s,前面已经说到,a 是一个常量。。

      再看一个易错的点:

      char **s = "hello world";

      这样是错误的,

      因为  s 的类型是 char **  而 "hello world "的类型是 char *

      虽然都是地址, 但是指向的类型不一样,因此,不能这样用。,从其本质来分析,"hello world",代表一个地址,比如0x003001,这个地址中的内容是 'h',为 char 型,而 s 也保存一个地址 ,这个地址中的内容(*s) 是char * ,是一个指针类型, 所以两者类型是不一样的。 。。

     如果是这样呢?

     char  **s;  
     *s = "hello world";  

     貌似是合理的,编译也没有问题,但是 printf("%s",*s),就会崩溃

     why??

     咱来慢慢推敲一下。。

     printf("%s",*s); 时,首先得有s 保存的地址,再在这个地址中找到 char *  的地址,即*s;

     举例:

     s = 0x1000;  

     在0x1000所在的内存单元中保存了"hello world"的地址 0x003001 , *s = 0x003001;

    这样printf("%s",*s);

    这样会先找到 0x1000,然后找到0x003001;

    如果直接 char  **s;

    *s = "hello world";  

    s 变量中保存的是一个无效随机不可用的地址, 谁也不知道它指向哪里。。。。,*s 操作会崩溃。。

    所以用 char **s 时,要给它分配一个内存地址。

    char  **s ;  
    s = (char **) malloc(sizeof(char**));  
    *s =  "hello world";

    这样 s 给分配了了一个可用的地址,比如 s = 0x412f;
    然后在 0x412f所在的内存中的位置,保存 "hello world"的值。。

    再如:

       

    #include  <stdio.h>  
    void  buf( char **s)  
     {  
            *s = "message";  
     }  
     int main()  
     {  
         char *s ;  
         buf(&s);  
         printf("%s\n",s);  
     }  


    二级指针的简单用法。。。。,说白了,二级指针保存的是一级指针的地址,它的类型是指针变量,而一级指针保存的是指向数据所在的内存单元的地址,虽然都是地址,但是类型是不一样的。。。

     

     

     

     

     

    最后说明,sizoof(指针)的大小更具电脑操作系统而定,一般32位操作系统所占用的内存大小是4,64位操作系统指针的大小是8。

     

     

     

    这篇博客是转转的

     char  **s;  
     *s = "hello world";
    在我的ubuntu上打印 printf("%s",*s),没有崩溃

    展开全文
  • c++中charchar*类型所占字节数

    千次阅读 2018-09-01 11:55:37
    char c = 'a'; char *p = &amp;c; char a = 'abcd'; char *d[2]; printf("%d\n",sizeof(c)); //1 printf("%d\n",sizeof(p)); //4 printf("%d\n",sizeof(a)); //1 print...

    #include<stdio.h>
    int main()
    {
    char c = 'a';
    char *p = &c;
    char a = 'abcd';
    char *d[2];
    printf("%d\n",sizeof(c));   //1
    printf("%d\n",sizeof(p));   //4
    printf("%d\n",sizeof(a));   //1
    printf("%d\n",sizeof(d));   //8

    return 0;
    }

    64位操作系统下测试

    展开全文
  • const char * 、char const *、 char * const 三者的区别

    万次阅读 多人点赞 2017-08-09 15:58:28
    const char *ptr; char const *ptr; char * const ptr; 整理三者之间的区别与联系。 一、const char *ptr; 定义一个指向字符常量的指针,这里,ptr是一个指向 char* 类型的常量,所以不能用ptr来修改所指向的...

    C/C++ 中关于以下三种定义:

    const char *ptr;

    char const *ptr;

    char * const ptr;

    整理三者之间的区别与联系。

    一、const char *ptr;

            定义一个指向字符常量的指针,这里,ptr是一个指向 char* 类型的常量,所以不能用ptr来修改所指向的内容,换句话说,*ptr的值为const,不能修改。但是ptr的声明并不意味着它指向的值实际上就是一个常量,而只是意味着对ptr而言,这个值是常量。实验如下:ptr指向str,而str不是const,可以直接通过str变量来修改str的值,但是确不能通过ptr指针来修改。

    gcc编译报错信息:

    注释掉16行ptr[0] = 's';运行正常,运行结果为:

    hello world
    gello world

    另外还可以通过重新赋值给该指针来修改指针指向的值,如上代码中取消7、18行的注释,运行结果为:

    hello world
    good game!!

     

    二、char const *ptr;
            此种写法和const char *等价,大家可以自行实验验证。

     

    三、char * const ptr;

            定义一个指向字符的指针常数,即const指针,实验得知,不能修改ptr指针,但是可以修改该指针指向的内容。实验如下:

    gcc报错信息:

    注释掉17行代码运行正常,运行结果为:

    hello world
    sello world

    展开全文
  • char与byte的区别

    万次阅读 多人点赞 2012-07-21 16:18:02
    很多初学者(包括我,已经学了一年多java了)肯会对char和byte这两种数据类型有所疑惑,相互混淆,今天特地查了好多资料,对byte和char两种数据类型进行了总结和比较,先将结果与大家分享:  byte 是字节数据类型...
  • 深入 char * ,char ** ,char a[ ] ,char *a[] 内核

    万次阅读 多人点赞 2013-02-23 15:34:13
    C语言中由于指针的灵活性,导致指针能代替数组使用,或者混合使用,这些导致了许多指针和数组的迷惑,因此,刻意再次深入探究了指针和数组这玩意儿,其他类型的数组比较简单,容易混淆的是字符数组和字符指针这两个...
  • int spitString2(char *buf1,char c,char **myp,int *count) { //strcpy(buf2[0],"aaaaa"); //strcpy(buf2[1[,"bbbbb"); char *p=NULL,*pTmp=NULL; int tmpcount=0; //p和ptmp初始化 p=buf1; pTmp=...
  • char fullname[len]; int handicap; }; 同时写了函数void setgolf()来对结构的成员进行操作,函数定义如下: void setgolf(golf & g, const char * name, int hc) { g.fullname=name;//报这个错误:expression ...
  • char* str = new char[3]; str[0] = 0; str[1] = 65; str[2] = 66; lua_pushstring(L, str); lua_pcall(L, 1, 1, 0); const char* newP = lua_tostring(L, 1); cout [0] [1] [2]; lua_close(L)...
  • >c:\program files\microsoft sdks\windows\v7.0a\include\windef.h(154): error C2632: 'char' followed by 'char' is illegal 3>c:\program files\microsoft sdks\windows\v7.0a\include\windef.h(154): warning ...
  • char和unsigned char

    千次阅读 2019-11-07 23:11:27
    网络编程中一般都用unsigned char,而不用char,是因为把char强制转换成int或long时,系统会进行类型扩展。 #include <stdio.h> int main() { int a = 0xde; //1101 1110 char b = a; unsigned char u_...
  • 编写一个函数,void fun(char *str, char *substr1, char *subtr2 , …)实现将字符串str中的子串substr1替换为子串substr2,并同时统计替换后str字符串长度,要求:接口定义中已有部分不许修改,但允许在…处自由...
  • 关于char*a,char a[],const char *a,以及字符串常量的问题。c++。具体问题是我需要解析一个xml文件,取出的字符串是const char *型。取出得数据放在map<char *,struct vdata>中,其中key值是从xml中获得的const ...
  • int code_convert(char *from_charset, char *to_charset, char *inbuf, size_t inlen, char *outbuf, size_t outlen) { iconv_t cd; char **pin = &inbuf; char **pout = &outbuf; cd = iconv_...
  • char * my_strlwr(char * str) {  if(str == NULL)  return NULL;  char * pStr = str;  for(; *pStr != '\0'; pStr++)  {  if(*pStr >= 'A' && *pStr )  *pStr += 'a' - 'A';  }  return str; } int main...
  • C语言 char*和char[]用法

    万次阅读 多人点赞 2019-06-15 16:30:38
    char []定义的是一个字符数组,注意强调是数组。 char * 定义的是一个字符串指针,注意强调是指针。 char *s定义了一个char型的指针,它只知道所指向的内存单元,并不知道这个内存单元有多大,所以: 当char *s = ...
  • char name[20]; char number[20]; }NumberInfo[500];//通讯录列表 int NO; int j; FILE *fp; void main(){ NO=10; for(int i =0;i;i++){ NumberInfo[i].name = "张三";//给联系人赋值 NumberInfo[i]....
  • int __stdcall DecodeFile(char* InFile, //要解密的文件 char* Key, //解密的密钥 char* OutFile, //解密后的文件,在解密路径下的同名XML文件 char* Info); //提示信息函数返回 0 成功,非0失败。 2、动态调用...
  • char c = 1 char c = "1" char c = '1'

    千次阅读 2017-11-16 14:45:40
    char c = 1 表示ASCII码=1的字符 char c = "1" 语法错误 char c = '1' 表示1这个字符 #include int main() { char a=1,b='1'; printf("%c %c\n",a,b);// 输出ASCII为1的字符和字符'1' return 0; } ASCII第一次以...
  • bufheader = (char *)malloc(sizeof(char) * BUFLENGTH ); FILE* readheader = fopen(filename, "rb"); fread(bufheader, 1, BUFLENGTH, readheader); BYTE m_byData[MAX]; 我想实现:m_byData = bufheader; ...
  • char basech1 = 'A'; char basech2 = 'a'; int sum = 0; for (int i = 0; i (); i++) { char ch = input.charAt(i); if ( ch != '\0' && ch != '(' && ch != ')') { if ((int)ch > 90) {...
  • 无法从const char* 转换为char*

    千次阅读 2018-12-17 22:44:08
    “初始化“::无法从const char* 转换为char* C和C++11有所不同,C中可以用下面的语句 char *a="hello"; char *b={"hello","world"}; 而在C++11中应改成 const char *a="hello&...
  • unsigned charchar

    千次阅读 2015-01-29 12:35:48
    char 和 unsigned char是无符号的 两者都作为字符用的话是没有区别的,但当整数用时有区别:  char 整数范围为-128到127( 0x80~0x7F),  而unsigned char 整数范围为0到255( 0~0xFF ) 多数情况下,...
  • unsigned charchar

    千次阅读 2012-05-15 11:06:05
    本质上两种类型都占一个字节。 作为字符使用时,都是存储字符的ASCII码。 比如:unsigned char uc='a';char c='a';...unsigned char 可取0至255,而char可取-128至+127。 比如:unsigned char uc=255;char
  • C语言charchar*赋值

    万次阅读 2018-05-16 15:50:39
    1.单字符char a=’1’; 2.多字符char a[5]=”1133”; 3.字符数不确定char a[]=”1132131233”; 4.char* str = new char[10];str = “2131”; 5.char* str = “12312”; 6.char* str = new char[10];strcpy(str,...
  • Tip: char *和char*的区别

    千次阅读 2016-03-15 01:40:23
    char *和char*的区别 这两种写法编译上面都没有问题,但是在某些情况下会造成歧义 char* p1, p2 这样的写法声明了指针p1,字符p2 char *p1, *p2 这样的写法表示声明了两个指向字符的指针 *是变量的修饰...
  • C语言声明优先级 const char* char * const

    千次阅读 2014-09-26 21:02:06
    const char * var和char const * var和char * const var 可以这么理解 const char var 表示var是个char类型的常量 char * var 表示var是一个指针,指向一个char const char * var 表示var是一个指针,指向一个...
  • java中char类型的默认值到底是什么? 直接po代码和截图 ``` public class TestJavaDataType { //字符型 char flag; //布尔型 boolean sex; /*数值型*/ //整数类型 byte number; short ...
  • ``` ... char* a="AAAA"; char* b="BBBB"; char* c="CCCC"; const char*x=a; //二维 char *y[3]= {a,b,c}; const char** z=y; } ``` 最后一行 ``` const char** z=y; ``` 错误,求指教

空空如也

1 2 3 4 5 ... 20
收藏数 477,238
精华内容 190,895
关键字:

char