精华内容
下载资源
问答
  • C++ 字符型常量

    千次阅读 2020-07-12 23:12:05
    用一对单引号括起来的一个或多个字符称为字符型常量,如’A’、‘AA’、’\n’和’5’等,其中’A’、’?'和’5’称为单字符常量,‘AA’称为双字符常量,’\n’称为转义字符序列。由以下代码可以看出,对双字符常量...

    用一对单引号括起来的一个或多个字符称为字符型常量,如’A’、‘AA’、’\n’和’5’等,其中’A’、’?'和’5’称为单字符常量,‘AA’称为双字符常量,’\n’称为转义字符序列。由以下代码可以看出,对双字符常量来说,系统将其解释为一个int类型的数据,前面的字符作为低位字节,后面的字符作为高位字节,这种方式仅适用于可显示字符。

    #include <iostream>
    
    using namespace std ;
    
    int main(int argc, const char** argv) {
        
        cout << "\'A\' is "<<'A'<<endl ;
        cout << "\'B\' is "<<'B'<<endl ;
        cout << "\'AB\' is "<<'AB'<<endl ;
        
        return 0;
    }
    

    输出结果如下所示。

    'A' is A
    'B' is B
    'AB' is 16706
    

    同样可以使用“‘ABA’”和“‘ABAB’”这样的形式,唯一的限制来自于int的字节数,对有些系统来说,int型占两个字节,则“‘ABA’”和“‘ABAB’”不合法,对int类型占4个字节的系统来说,“‘ABA’”和“‘ABAB’”完全可用。但不管对什么样的系统,“‘ABABA’”及更多字母组合的写法都是错误的。

    提示

    多字符常量除了增加程序阅读难度外,似乎没有其他的好处,不推荐使用。字符型量在C++中可作为单字节的整型常量来用。

    展开全文
  • C中字符常量&字符数组&字符常量

    千次阅读 多人点赞 2019-12-17 11:21:42
    在 C 语言中,字符串有两种存储方式,一种是通过字符数组存储,另一种是通过字符指针存储。 一、字符常量: 一个用单引号括起来的单个字符(或字符转义序列或三...字符常量字符常量是用单引号括起来的一个字符,...

    在 C 语言中,字符串有两种存储方式,一种是通过字符数组存储,另一种是通过字符指针存储。

    一、字符常量:

     一个用单引号括起来的单个字符(或字符转义序列或三字母词)

    实质(含义):是一个整形值。属于四大基本数据类型(分别是整型,浮点型,指针,聚合类型)中的整型(integers)。

    C语言字符常量与字符串常量

    备注:字符常量和字符变量:

    • 字符常量
      字符常量是用单引号括起来的一个字符,如'a'、'A'、'1'、'='。因此字符常量有以下特点:
      I. 字符常量只能用单引号括起来,不能用双引号或其他符号。
      II. 字符常量只能是单个字符,即单引号内只能有一个字符。
      转义字符是一种特殊的字符常量,有以下特点:
      I. 转义字符以反斜线"\"开头,后面跟一个或几个字符。
      II. 转义字符具有特定的含义,不同于字符原有的意义。
    • 字符变量
      I. 字符变量的类型说明符为char,字符变量定义格式为:char a;、char a,b;
      II. 字符变量用来存储字符常量,字符值是以ASCII码的二进制形式存放在变量的内存单元之中的,如字符'x'的ASCII码是120,定义字符变量char a = 'x';,实际上字符变量a内存放120的二进制代码。若将整型值直接赋值给字符变量,如char a = 100;,实际上是将ASCII码为100的字符'd'赋值给了字符变量a。
      III. 字符型可看做一种特别短的整型
      类型说明符:[signed] char,表示的数值范围:-128 ~ 127,存储大小:1字节
      类型说明符:unsigned char,表示的数值范围:0 ~ 255,存储大小:1字节

    字符型参与算术运算

    由于字符型可看做一种特别短的整型,因此可以将字符型与整型进行算术运算。

    #include <stdio.h>
    
    int main(void)
    {
        printf("%d\n", 'A'+2);
        printf("%c\n", 'A'+2);
    }
    

    以上程序输出:

    67
    C
    

    字符型参与算术运算,实际上是将字符对应的ASCII码进行算术运算。字符'A'对应的ASCII码为65,应此'A'+2以十进制形式输出带符号整数的结果为67;而ASCII码值为67的字符为'C',应此'A'+2以单个字符输出的结果为C。

    \n——换行,

    \t——tab,

    \r——回车,

    \f——换页,

    \b——退格,

    \ddd——1到3位8进制的数代表的字符

    二、字符串常量:

     两种定义方式:

    (字符数组)数组方式定义字符串:当数组名用于表达式中时,它们的值也是个指针常量。我们可以对它们进行下标引用、间接访问以及指针运算。

    (字符串指针)指针常量定义字符串:当一个字符串常量出现在表达式中时,它的值是个指针常量。编译器把这些指定字符的一份拷贝存储在内存的某个位置,并存储一个指向第一个字符的指针。(一个是指针的地址,一个是字符串的地址)

    1、

    char str[] = "hello, world";
    str[1] = 'a';
    
    

    2、

    char *str = "hello, world";
    str[1] = 'a';
    
    

    两个程序都可以编译,但第二个运行会出现段错误。

    两个程序的区别在:

    第一个程序的 str 属于初始化变量,str 如果是局部变量则指向栈上的内存区域,如果是 static 或全局变量则指向进程的 data 段内存区域。data 段权限是可读可写

    第二个程序中 "hello, world" 是一个字符串面量,str 的确指向其地址,但该地址存在于在进程的 text 段,text 段除了保存常量还保存可执行代码,因此是不允许可写权限的,而是只允许可读可执行权限

     实例:

    char p[] = "hello"; // 方式1
    
    char *p = "hello"; // 方式2
    
    char *p;
    p = (char *)malloc(sizeof(char)*6);
    strcpy(p, "hello"); // 方式3
    
    

    这三种情况下:
    方式1:所有6个char字符都连续的存放在栈区。内容可更改!
    方式2:"Hello"存在程序内存的常量区中,是编译时就固定下来的(不可更改),然后p是一个指向常量区"hello"的指针,p本身存在栈区
    方式3: malloc向堆申请了空间,p存放在栈区,指向malloc申请出来的地址,最后"hello"就被copy到了p所指向的地址。内容可更改!
    从速度来看1中栈的数据都是直接读的,另外两种都需要通过指针间接读取,所以1显然是最快的。
    我觉得首先如果字符串很小且确定,可以用1的写法,在栈区速度快。
    如果字符串很大或者不确定,要知道栈区大小是有限的,所以采用3的动态分配比较好。
    如果字符串被大量复用,其实可以采用2中写法,这样只要引用了常量区的同一字符串,他们将会共用同一块地址。(当然这种共用是合理的,因为那里的字符串是不可修改的,且到程序结束才会被释放)。

    C语言字符串常量

    示例代码:

    #include <stdio.h>
    #include <string.h>
    int main() {
    	printf("\t方式1……\n");
    	char p0[] = "hello"; // 方式1
    	printf("输出数组定义字符串:%s\n",p0);
    	printf("输出数组定义字符串地址:%p\n",p0);
    	//更改数组P0中的某一个元素
    	p0[0] = 'H';
    	printf("输出数组定义字符串:%s\n", p0);
    	/*
    	printf("\t方式2……\n");
    	char *p1 = "hello"; // 方式2
    	printf("输出指针定义字符串:%s\n", p1);
    	printf("输出指针定义字符串地址:%p\n", &p1);
    	//更改数组P1中的某一个元素
    	p1[0] = 'H';
    	printf("输出指针定义字符串:%s\n", p1);
    	*/
    	printf("\t方式3……\n");
    	char *p2;// 方式3
    	p2 = (char *)malloc(sizeof(char) * 6);
    	strcpy(p2, "hello");
    	printf("输出指针定义字符串:%s\n", p2);
    	printf("输出指针定义字符串地址:%p\n", &p2);
    	//更改数组P2中的某一个元素
    	p2[0] = 'H';
    	printf("输出指针定义字符串:%s\n", p2);
    	return 0;
    }
    

    运行结果:

    示例代码:

    #include <stdio.h>
    #include <string.h>
    int main() {
    	printf("\t方式1……\n");
    	char p0[] = "hello"; // 方式1
    	printf("输出数组定义字符串:%s\n",p0);
    	printf("输出数组定义字符串地址:%p\n",p0);
    	//更改数组P0中的某一个元素
    	p0[0] = 'H';
    	printf("输出数组定义字符串:%s\n", p0);
    	
    	printf("\t方式2……\n");
    	char *p1 = "hello"; // 方式2
    	printf("输出指针定义字符串:%s\n", p1);
    	printf("输出指针定义字符串地址:%p\n", &p1);
    	//更改数组P1中的某一个元素
    	p1[0] = 'H';
    	printf("输出指针定义字符串:%s\n", p1);
    	
    	printf("\t方式3……\n");
    	char *p2;// 方式3
    	p2 = (char *)malloc(sizeof(char) * 6);
    	strcpy(p2, "hello");
    	printf("输出指针定义字符串:%s\n", p2);
    	printf("输出指针定义字符串地址:%p\n", &p2);
    	//更改数组P2中的某一个元素
    	p2[0] = 'H';
    	printf("输出指针定义字符串:%s\n", p2);
    	return 0;
    }

     方式2可以编译,但运行会出现错误

    运行结果:

     C语言中字符串常量的问题

    如下示例,表明不同的字符串所在的内存位置不一样,故不相等

    C/C++对字符串常量的处理策略

    指针常量示例:

    【 C 】彻底学会字符串常量

    示例代码:

    /*
    #include <stdio.h>
    int main() {
    	char *p_char = "Hello World";
    	printf("输出字符串:%s\n",p_char);
    	printf("输出指针指向字符串的地址:%p\n",&p_char);
    	printf("输出字符串:%c\n", p_char[1]);
    	p_char[1] = 'H';
    	printf("输出字符串:%s\n", p_char);
    	//printf("输出指针指向字符串的地址:%p\n", &(p_char+1));
    	char str[] = "I Love Beijing";
    	printf("输出数组定义字符串:%s\n",str);
    	printf("输出数组定义字符串地址:%p\n",str);
    
    	return 0;
    }
    */
    
    /*
    #include <stdio.h>
    #include <string.h>
    int main() {
    	printf("\t方式1……\n");
    	char p0[] = "hello"; // 方式1
    	printf("输出数组定义字符串:%s\n",p0);
    	printf("输出数组定义字符串地址:%p\n",p0);
    	//更改数组P0中的某一个元素
    	p0[0] = 'H';
    	printf("输出数组定义字符串:%s\n", p0);
    	
    	printf("\t方式2……\n");
    	char *p1 = "hello"; // 方式2
    	printf("输出指针定义字符串:%s\n", p1);
    	printf("输出指针定义字符串地址:%p\n", &p1);
    	//技巧:
    	printf("输出指针定义字符串:%c\n", *"hello");
    	printf("输出指针定义字符串:%c\n", *("hello"+1));
    	printf("输出指针定义字符串:%c\n", *(p1 + 1));
    	//更改数组P1中的某一个元素
    	p1[0] = 'H';
    	printf("输出指针定义字符串:%s\n", p1);
    	
    	printf("\t方式3……\n");
    	char *p2;// 方式3
    	p2 = (char *)malloc(sizeof(char) * 6);
    	strcpy(p2, "hello");
    	printf("输出指针定义字符串:%s\n", p2);
    	printf("输出指针定义字符串地址:%p\n", &p2);
    	//更改数组P2中的某一个元素
    	p2[0] = 'H';
    	printf("输出指针定义字符串:%s\n", p2);
    	return 0;
    }
    */
    
    #include <stdio.h>
    #include <string.h>
    int main() {
    	printf("\t方式1……\n");
    	char p0[] = "hello"; // 方式1
    	printf("输出数组定义字符串:%s\n", p0);
    	printf("输出数组定义字符串地址:%p\n", p0);
    	//更改数组P0中的某一个元素
    	p0[0] = 'H';
    	printf("输出数组定义字符串:%s\n", p0);
    
    	printf("\t方式2……\n");
    	char *p1 = "hello"; // 方式2
    	printf("输出指针定义字符串:%s\n", p1);
    	printf("输出指针定义字符串地址:%p\n", &p1);
    	//技巧:
    	printf("输出指针定义字符串:%c\n", *"hello");
    	printf("输出指针定义字符串:%c\n", *("hello" + 1));
    	printf("输出指针定义字符串:%c\n", *(p1 + 1));
    	//更改数组P1中的某一个元素
    	p1[0] = 'H';
    	printf("输出指针定义字符串:%s\n", p1);
    
    
    	return 0;
    }
    
    

    运行结果:

     

     C语言字符常量与字符串常量

    来自知乎的提问:

    为什么char *a="xxxxx", *b="xxx"; strcpy(a, b);的用法不行?

    展开全文
  • 用一对单引号将一个字符括起表示合法的字符常量。例如‘a’。数值包括整型、浮点型。整型可用十进制,八进制,...但数字被定义为字符型之后就不能参与数值运算。如'5'和5是不同的。’5’是字符常量,不能参与运算。...

    用一对单引号将一个字符括起表示合法的字符常量。例如‘a’。数值包括整型、浮点型。整型可用十进制,八进制,十六进制。八进制前面要加0,后面由0到7八个数表示。

    在C语言中,字符常量有以下特点:

    字符常量只能用引号括起,不能用双引号或其它括号。

    字符常量只能是单个字符,不能是字符串。

    字符可以是字符集中任意字符。但数字被定义为字符型之后就不能参与数值运算。如'5'和5是不同的。’5’是字符常量,不能参与运算。

    c9871499366f444d8255fa72d8a26cbd.png

    扩展资料:

    字符常量的表示:

    所谓字符常量,就是用英文单引号括起的一个字符。在使用字符常量时应该注意:

    1、单引号内的大小写字符代表不同的字符常量,例如‘Y’、‘y’是两个不同的字符常量。

    2、字符常量只能用英文单引号括起,不能用双引号。例如“Y”不是一个字符常量,而是一个字符串。

    3、单引号内如果是一个空格符,也是一个字符常量。

    4、单引号内只能包含1个字符,‘xyz’写法是错误的。但超过1个的字符的话,除最后一个外前面的会动失效,当然这在编程使用中应该避免。

    5、字符常量的值,就是它在ASCII编码表中的值。是个从0—127之间的整数。因此字符常量可以作为整型数据进行运算。

    参考资料源:百度百科-c语言

    展开全文
  • C++常量(C++数值常量字符常量、符号常量) 一、 数值常量 数值常量就是通常所说的常数。在C++中,数值常量是区分类型的,从字面形式即可识别其类型。 1. 整型常量(整数)的类型 在上一节中已知道: 整型数据...

    C++常量(C++数值常量、字符串常量、符号常量)

    一、 数值常量

    数值常量就是通常所说的常数。C++,数值常量是区分类型的,从字面形式即可识别其类型。

    1. 整型常量(整数)的类型
    在上一节中已知道: 整型数据可分为int,short int,long int以及unsigned int,unsigned short,unsigned long等类别。整型常量也分为以上类别。为什么将数值常量区分为不同的类别呢?因为在进行赋值或函数的参数虚实结合时要求数据类型匹配。

    那么,一个整型常量怎样从字面上区分为以上的类别呢?

    1 一个整数,如果其值在-32768~+32767范围内,认为它是short int,它可以赋值给short int型、int型和long int型变量。

    2 一个整数,如果其值超过了上述范围,而在-2147483648~+2147483647范围内,则认为它是long int,可以将它赋值给一个intlong int型变量。

    3 如果某一计算机系统的C++版本(例如Visual C++)确定intlong int型数据在内存中占据的长度相同,则它们能够表示的数值的范围相同。因此,一个int型的常量也同时是一个long int型常量,可以赋给int型或long int型变量。

    4 常量无unsigned型。但一个非负值的整数可以赋值给unsigned整型变量,只要它的范围不超过变量的取值范围即可。

    5
    一个整型常量可以用3种不同的方式表示:十进制整数。如1357,-432,0等。在一个整型常量后面加一个字母lL,则认为是long int型常量。例如123L,421L,0L,这往往用于函数调用中。如果函数的形参为long int,则要求实参也为long int,此时用123作实参不行,而要用123L作实参。

    6 八进制整数。在常数的开头加一个数字0,就表示这是以八进制数形式表示的常数。如020表示这是八进制数20,(20)8,它相当于十进制数16

    7 十六进制整数。在常数的开头加一个数字0和一个英文字母X(x),就表示这是以十六进制数形式表示的常数。如0X20表示这是十六进制数20,(20)16,它相当于十进制数32

    2.浮点数的表示方法

    一个浮点数可以用两种不同的方式表示:

    8 十进制小数形式。如21.456,-7.98等。它一般由整数部分和小数部分组成,可以省略其中之一(78..06,.0),但不能二者皆省略。C++编译系统把用这种形式表示的浮点数一律按双精度常量处理,在内存中占8个字节。如果在实数的数字之后加字母Ff,表示此数为单精度浮点数,1234F,-43f,4个字节。如果加字母Ll,表示此数为长双精度数(long double),GCC中占12个字节,Visual C++ 6.0中占8个字节。

    9 指数形式(即浮点形式)
    一个浮点数可以写成指数形式,3.14159可以表示为0.314159×101,3.14159×100,31.4159×10-1,
    314.159×10-2等形式。在程序中应表示为: 0.314159e1,3.14159e0,31.4159e-1 ,314.159e-2,用字母e表示其后的数是以10为底的幂,e12表示1012。其一般形式为:
    数符 数字部分 指数部分
    上面各数据中的0.314159,3.14159, 31.4159, 314.159 等就是其中的数字部分。可以看到: 由于指数部分的存在,使得同一个浮点数可以用不同的指数形式来表示,数字部分中小数点的位置是浮动的。例如:
    a=0.314159e1;
    a=3.14159e0;
    a=31.4159e-1;
    a=314.159e-2;
    以上4个赋值语句中,用了不同形式的浮点数,但其作用是相同的。


    在程序中不论把浮点数写成小数形式还是指数形式,在内存中都是以指数形式(即浮点形式)存储的。例如不论在程序中写成314.159314.159e0,31.4159e1,3.14159e2, 0.314159e3等形式,在内存中都是以规范化的指数形式存放,如图2.3所示。

    数字部分必须小于1,同时,小数点后面第一个数字必须是一个非0数字,例如不能是0.0314159。因此314.159314.159e0,31.4159e1,3.14159e2, 0.314159e3在内存中表示成0.314159×103。存储单元分为两部分,一部分用来存放数字部分,一部分用来存放指数部分。为便于理解,在图2.3中是用十进制表示的,实际上在存储单元中是用二进制数来表示小数部分,2的幂次来表示指数部分的。

    对于以指数形式表示的数值常量,也都作为双精度常量处理。

    二、字符常量

    1. 普通的字符常量
    用单撇号括起来的一个字符就是字符型常量。如′a′,′#′,′%′,′D′都是合法的字符常量,在内存中占一个字节。注意:
    字符常量只能包括一个字符,′AB′ 是不合法的。
    字符常量区分大小写字母,′A′′a′是两个不同的字符常量。
    撇号(′)是定界符,而不属于字符常量的一部分。如cout<<′a′;输出的是一个字母“a”,而不是3个字符“′a′ ”

    2. 转义字符常量
    除了以上形式的字符常量外,C++还允许用一种特殊形式的字符常量,就是以 “\”开头的字符序列。例如,′\n′代表一个换行符。“cout<<′\n′; ” 将输出一个换行,其作用与“cout<<endl; ” 相同。这种控制字符”,在屏幕上是不能显示的。在程序中也无法用一个一般形式的字符表示,只能采用特殊形式来表示。

    3. 字符数据在内存中的存储形式及其使用方法
    将一个字符常量存放到内存单元时,实际上并不是把该字符本身放到内存单元中去,而是将该字符相应的ASCII代码放到存储单元中。如果字符变量c1的值为′a′,c2的值为′b′,则在变量中存放的是′a′ASCII97,′b′ ASCII98,如图2.4(a)所示,实际上在内存中是以二进制形式存放的,如图2.4(b)所示。

    既然字符数据是以ASCII码存储的,它的存储形式就与整数的存储形式类似。这样,C++中字符型数据和整型数据之间就可以通用。一个字符数据可以赋给一个整型变量,反之,一个整型数据也可以赋给一个字符变量。也可以对字符数据进行算术运算,此时相当于对它们的ASCII码进行算术运算。

    2.1 将字符赋给整型变量。
    #include <iostream>
    using namespace std;
    int main( )
    {
    int i,j; //ij是整型变量
    i=′A′; //将一个字符常量赋给整型变量i
    j=′B′; //将一个字符常量赋给整型变量j
    cout<<i<<′ ′<<j<<′\n′; //输出整型变量ij的值,′\n′ 是换行符
    return 0;
    }
    执行时输出
    65 66
    ij被指定为整型变量。但在第5和第6行中,将字符′A′′B′分别赋给ij,它的作用相当于以下两个赋值语句:
    i=65;j=66;
    因为′A′′B′ASCII码为6566。在程序的第5和第6行是把6566直接存放到ij的内存单元中。因此输出6566

    可以看到:在一定条件下,字符型数据和整型数据是可以通用的。但是应注意字符数据只占一个字节,它只能存放0~255范围内的整数。

    2.2 字符数据与整数进行算术运算。下面程序的作用是将小写字母转换为大写字母。
    #include <iostream>
    using namespace std;
    int main( )
    {
    char c1,c2;
    c1=′a′;
    c2=′b′;
    c1=c1-32;
    c2=c2-32;
    cout<<c1<<′ ′<<c2<<endl;
    return 0;
    }
    运行结果为
    A B
    ′a′ASCII码为97,′A′ASCII码为65,′b′98,′B′66。从ASCII代码表中可以看到每一个小写字母比它相应的大写字母的ASCII代码大32C++符数据与数值直接进行算术运算,′a′-32得到整数65,′b′-32得到整数66。将6566存放在c1,c2,由于c1,c2是字符变量,因此用cout输出c1,c2,得到字符AB(AASCII码为65,BASCII码为66)

    三、 字符串常量

    用双撇号括起来的部分就是字符串常量,″abc″,″Hello!″,″a+b″,″Liping″都是字符串常量。字符串常量″abc″在内存中占4个字节(而不是3个字节),见图2.5

    编译系统会在字符串最后自动加一个′\0′作为字符串结束标志。但′\0′并不是字符串的一部分,它只作为字符串的结束标志。如
    cout<<″abc″<<endl;
    输出3个字符abc,而不包括′\0′

    注意: ″a″′a′代表不同的含义,″a″是字符串常量,′a′ 是字符常量。前者占两个字节,后者占1个字节。请分析下面的程序片段:
    char c;//定义一个字符变量
    c=′a′;//正确
    c=″a″; //错误,c只能容纳一个字符

    请思考: 字符串常量″abc\n″包含几个字符?不是5个而是4个字符,其中“\n”是一个转义字符。但它在内存中占5个字节(包括一个“\0”字符) 。编译系统遇到“\”时就会把它认作转义字符的标志,把它和其后的字符一起作为一个转义字符。

    如果“\”后面的字符不能与“\”组成一个合法的转义字符(″\c″),则在编译时显示出错信息。如果希望将“\”字符也作为字符串中的一个字符,则应写为″abc\\n″,此时字符包括5个字符,a,b,c,\,n。如果有以下输出语句:
    cout<<″abc\\\n″<<endl;
    则会输出: abc\,然后换行。同理执行
    cout<<″I say \″Thank you!\″\n″;
    的输出是: I say ″Thank you!″

    如果在一个字符串中最后一个字符为“\”,则表示它是续行符,下一行的字符是该字符串的一部分,且在两行字符串间无空格。如
    cout<<″We must study C\//本行最后的“\”后面的空格和换行均不起作用
    ++ hard!″;//本行的字符紧连在上一行最后的“\”前面字符之后
    则输出:
    We must study C++ hard!

    四、符号常量

    为了编程和阅读的方便,C++程序设计中,常用一个符号名代表一个常量,称为符号常量,即以标识符形式出现的常量。例2.3 符号常量的使用。
    #define PRICE 30 //注意这不是语句,末尾不要加分号
    int main ( )
    {
    int num,total;
    num=10;
    total=num * PRICE;
    cout<<″total=″<<total<<endl;
    return 0;
    }
    程序中用预处理命令#define指定PRICE在本程序单位中代表常量30,此后凡在本程序单位中出现的PRICE都代表30,可以和常量一样进行运算,程序运行结果为
    total=300
    请注意符号常量虽然有名字,但它不是变量。它的值在其作用域(在本例中为主函数)内是不能改变的,也不能被赋值。如用赋值语句“PRICE=40;”PRICE赋值是错误的。 使用符号常量的好处是:

    10 含义清楚。

    11 在需要改变一个常量时能做到一改全改。 如
    #define PRICE 35

    转载

    guyue

    2014—7—24

    展开全文
  • 关于C语言数值常量字符常量

    千次阅读 多人点赞 2019-08-12 16:22:36
    在C语言中,字符常量以下特点:  ...但数字被定义为字符型之后就不能参与数值运算。 下面四个选项中,均是正确的数值常量或字符常量的选项是()。 A.0.0 0f 8.9e ‘&’ B.“a” 3.9e-2.5 lel ‘\”’ C.’3...
  • 在C/C++中,一个字符常量表示的是该字符串第一个元素的地址,就跟char指针名,char数组名表示的是字符串第一个元素的地址一样。 想要打印一个地址,用一个简单的 cout << 地址; 语句就可以搞定; 但是下面...
  • C语言讲常量变量与标志符整型实型字符型数据第3讲 常量、变量与标志符 整型、实型、字符型数据 2.1~2.5 常量、变量与标识符 例2.1 符号常量的使用 2. 变量 3. 标识符 标识符的分类 2.3 整型数据 2.整型变量 3. 整型...
  • 字符常量的注意事项

    2021-01-12 20:55:37
    字符常量需要符合以下特点: 1、单引号内的大小写字符代表不同的字符常量,例如‘Y’、‘y’是两个不同的字符常量。 2、字符常量只能用英文单引号括起来,不能用双引号。例如“Y”不是一个字符常量,而是一个字符串...
  • #include&...//这里的a与下面的p一样,都表示字符串的搜地址 return 0; } /*#include&lt;stdio.h&gt; int main() { char *p="good luck"; printf("%s",p);系统先输出p所
  • 常量

    2020-07-06 15:52:08
    浮点型常量:数据是小数,必须有小数点,如2.5、-2.1、0.0 布尔常量:只有两种取值,即true和false 空常量:表示没有任何数据,用null表示 输出常量 字符串常量 System.out.println(""); //输出的内容为空 ...
  • 文章目录整型浮点数复数布尔型字符常量 整型 Go语言同时提供了有符号和无符号类型的整数运算。这里有int8、int16、int32和int64四种截然不同大小的有符号整数类型,分别对应8、16、32、64bit大小的有符号整数,与...
  • 第六章 字符型数据

    2020-01-31 12:58:02
    字符型常量 C语言中,一个字符常量代表ASCII字符集中的一个字符,在程序中用单引号把一个字符括起来作为字符常量。 说明: (1)单引号中的大写字母和小写字母代表不同的字符常量 (2)单引号中的空格符’ ’ 也...
  • 在c里面如果指针是一个基本数值 int ,foalt ,long等,如果输出里有 cout << ptr << endl; 其中ptr是指针的名,则输出的值是指针的地址, 如果是char * (char指针) 则输出的是char指针的值。 在C++中,...
  • C语言的数据类型→字符型数据一、字符常量C语言的字符常量是用单撇号括起来的一个字符。如:'a' 、'x' 、'D'、 '?' 、 '$' 等都是字符常量。注意:'a'、 'A'是不同的字符常量。C语言有一个特殊之处,就是允许用一...
  • 2018年09月一、单项选择题。本大题共40个小题,每小题2.5 分,共100.0分。在每小题给出的选项中,只有一项是符合题目要求的。...在表示字符常量的时候不需要人为在其末尾加入′\0′D.在C语言中,字符串常量隐含处...
  • 1.字符型常量 (1)字符常量 定义:‘一个字符’ 注:(1)‘大小写字母 ’ 代表不同的字符常量 (2)’ ‘ 中只能包含一个字符 (’abc' X) (3)只能用单引号,不能用双引号 (”a“是字符串,不是字符...
  • 作为初级c语言菜鸟,用...(1)以下选择中合法的c语言字符常量是(D) (A)'\128' (B)"a" (C)'ab' (D)'\x43' 解析: A:‘\128’表示8进制,而在8进制中出现8属于越界。错误。 B:在字符常量中,只有‘ ’,没有“ ”。
  • 基本数据类型分为数值型、字符型和布尔类型 数值型 数值型分为整数型和浮点型(小数型) 整数型 包含:int、 short、 byte、long 浮点型(小数型) 包含:float、double 字符型(char) 布尔型...
  • C语言的数据类型→字符型数据 一、字符常量 C语言的字符常量是用单撇号括起来的一个字符。 如:'a' 、'x' 、'D'、 '?' 、 '$' 等都是字符常量。 注意:'a'、 'A'是不同的字符常量。 C语言有一个特殊之处,...
  • 单片机C语言C51的变量和常量

    千次阅读 2020-03-31 16:45:37
    在C51中支持整型常量、浮点型常量、字符型常量和字符串型常量。 一.整型常量 整型常量也就是整型常数,根据其值范围在计算机中分配不同的字节数来存放。在C51中它可以表示以下几种形式: 十进制整数。如234、-...
  • C++常量

    2017-07-16 11:41:33
    整数常量整数常量可以是十进制、八进制或十六进制的常量。 前缀指定基数: 0x 或 0X 表示十六进制 0 表示八进制 不带前缀则默认表示十进制 整数常量也可以带一个后缀,后缀是 U 和 L 的组合,U 表示无符号整数...
  • 在未初始化时大多数现代编译器把未初始化标记为警告,但C#编译器把它当作错误来看待。这样可以防止我们无意中从其他程序遗留下来的内存中获取垃圾值。 2.数据的初始化默认值: 数据类型 默认值 ...
  • 在C语言中,实型常量有两种表示形式:小数形式和指数形式。 (1)小数形式 规则如下:1. 有且仅有一个小数点。 2. 左边和右边可以有一边没有数据,但是不能同时没有数据。 如:3.14159 0.158 12. .36 0.0 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 54,503
精华内容 21,801
关键字:

以下表示字符型常量错误的是