第三章——处理数据

最新推荐文章于 2024-04-24 15:15:48 发布

hdnsjskksnsbd

最新推荐文章于 2024-04-24 15:15:48 发布

阅读量117

点赞数

文章标签： c++ c语言 cocos2d

本文链接：https://blog.csdn.net/weixin_48140839/article/details/125067378

版权

1、C++变量的命名规则
2、C++内置的整型——unsigned long、long、unsigned int、int、unsigned short、short、char、unsigned char、signed char和bool。
3、C++11新增的整型：unsigned long long和long long。
4、表示各种整型的系统限制的climits文件。
5、各种整型的数字字面值（常量）
6、使用const限定符来创建符号常量
7、C++内置的浮点类型：float、double和long double
8、表示各种浮点类型的系统限制的cfloat文件
9、各种浮点类型的数字字面值
10、C++算术运算符
11、自动类型的转换
12、强制类型的转换
面向对象编程（OOP）的本质是设计并扩展自己的数据类型。设计自己的数据类型就是让类型与数据匹配。然而，在创建自己的类型之前，必须了解并理解C++内置的类型，因为这些类型是创建自己类型的基本组件。
内置的C++类型分两组：基本类型和复合类型。
基本类型：整数和浮点数
复合类型：包括数组、字符串、指针和结构。
当然，程序还需要一种标识存储数据的方法——使用变量
3.1 简单变量
程序通常都需要存储信息，为了把信息存储在计算机中，程序必须记录三个基本属性：
*信息将存储在哪里
*要存储什么值
*存储何种类型的信息
3.1.1 变量名
C++提倡使用有一定含义的变量名，且必须遵循几种简单的C++命名规则。
*在名称中只能使用字母字符、数字和下划线_
*名称的第一个字符不能是数字
*区分大写字符与小写字符
*不能将C++关键字用作名称
*以两个下划线或下划线和大写字母字母打头的名称被保留给实现使用。以一个下划线开头的名称被保留给实现，用作全局标识符。
*C++对于名称的长度没有限制，名称中所有的字符都有意义，但有些平台有长度限制。
3.1.2 整型
整数就是没有小数部分的数字，但是有限的计算机内存不能用来表示所有的整数。因此，语言只能表示所有整数的一个子集。有些语言只提供一种整型，而C++提供好几种。这样便能够根据程序的具体要求选择最合适的整型。C++的基本整型分别是char、short、int、long和C++ 新增的long long，其中每种类型都有符号版本和无符号版本，因此共有10种类型可供选择。
3.1.3 整型short、int、long和long long
计算机内存由一些叫做bit的单位组成，每种类型通过使用不同数目的位来储存值，最多只能表示四种不同的整数宽度。C++提供了一种灵活的标准，它确保了最小长度，如下所示：
*short至少16位
*int至少与short一样长
*long至少32位，且至少与int一样长
*long long至少64位，且至少与long一样长

#include <iostream>
#include <climits>
int main()
{
	using namespace std;
	int n_int = INT_MAX;
	short n_short = SHORT_MAX;
	long n_long = LONG_MAX;
	long long n_llong = LLONG_MAX;
	cout<<"int is "<<sizeof (int)<<" bytes."<<endl;
	cout<<"short is"<<sizeof n_short<<" bytes."<<endl;
	cout<<"long is"<<sizeof n_long<<" bytes."<<endl;
	cout<<"long long is"<<sizeof n_llong<<" bytes."<<endl;
	cout<<endl;

	cout<<"Maximum values:"<<endl;
	cout<<"int:"<<n_int<<endl;
	cout<<"short:"<<n_short<<endl;
	cout<<"long:"<<n_long<<endl;
	cout<<"long long: "<<n_llong<<endl<<endl;
	cout<<"Minimum int value = "<<INT_MIN<<endl;
	cout<<"Bits per bytes = "<<CHAR_BIT<<endl;
	return 0;
}

![运算结果](https://img-blog.csdnimg.cn/afbf8b0a4c524b648d30780d5fe5b92d.png)


	1、运算符sizeof和头文件limits
	sizeof运算符指出，在使用8位字节的系统中，int的长度为4个字节。可对类型名和变量名使用sizeof运算符。对类型名（如int）使用sizeof运算符时，应将名称放在括号中：但对变量名（如n_short）使用该运算符，括号是可选的。
	头文件climits定义了符号常量来表示类型的限制。
	limits中的符号常量：

在这里插入图片描述

在这里插入图片描述
２、初始化
初始化将赋值和声明合并在一起，例如，下面的语句声明了变量n_int，并将int的最大取值赋给它：

int n_int = INT_MAX;

警告：如果不对函数内部定义的变量进行初始化，该变量的值将是不确定的。这意味着该变量的值将是它被创建之前，相应内存单元保存的值。
3、C++初始化的方式
还有另一种初始化方式，这种方式用于数组和结构。=，但在C++中，也可用于单值变量：

int hamburgers = {24};   //set hamburgers to 24
int emus = {7};       //set emus to 7
int rheas = {12};     	//set rheas to 12

当大括号内不包含任何东西时，变量将被初始化为零。

int rocs = {}; 		//set rocs to 0
int psychics{}; 	//set psychics to 0

3.1.4 无符号类型
前面的四种整型short、int、long和long long都有一种不能存储负数值的无符号变体，其优点是可以增大变量能够存储的最大值。例如：short表示的范围为-32768到+32767，则无符号版本的表示范围是0-65535。当且仅当数值不会为负时才应使用无符号类型，比如人口、个数等。要创建无符号版本的基本整型，只需使用关键字unsigned来修改声明即可：

unsigned short change;      //unsigned short type
unsigned int rovert;		//unsigned int type
unsigned quarterback;		//also unsigned int
unsigned long gone; 		//unsigned long type 
unsigned long long lang_lang;	//unsigned long long type

注：unsigned本身是unsigned int的缩写

#include <iostream>
#define ZERO 0   	//make ZERO symbol for 0 value
#include <climits>
int main()
{
	using namespace std;
	short sam = SHRT_MAX;   //initialize a variable to max value,sam=最大short值，是32767
	unsigned short sue = sam;	//okay if variable sam already defined，sue=sam=32767
	cout<<"Sam has "<<sam<<" dollars and Sue has "<<sue;
	cout<<" dollars deposited."<<endl<<"Add $1 to each accout."<<endl<<"Now";
	sam=sam+1; //short的范围是-32768到+32767，故sam=32767+1=-32768
	sue=sue+1; //usigned short的范围是0-65535，故sue=32767+1=32768
	cout<<"Sam has "<<sam<<" dollars and Sue has "<<sue;
	cout<<" dollars deposited.\nPoor Sam!"<<endl;
	sam = ZERO; //设置sam=0
	sue = ZERO; //设置sue=0
	cout<<"Sam has "<<sam<<" dollars and Sue has "<<sue;
	cout<<" dollars deposited."<<endl;
	cout<<"Take $1 from each account."<<endl<<"Now.";
	sam=sam-1; //sam=0-1=-1
	sue=sue-1;  //sue=sue-1=-1=65535
	cout<<"Sam has "<<sam<<" dollars and Sue has "<<sue;
	cout<<"dollars deposited."<<endl<<"Lucky Sue!"<<endl;
	return 0;
}

运行结果

3.1.5 选择整型类型
C++提供了大量整型，如何去选择我们使用的整型呢？一般来说，int被设置为对目标计算机而言最为“自然”的长度，自然长度指的是计算机处理起来效率最高的长度。在没有特别的理由下，我们应该选择使用int。
当变量表示的值不可能为负时，可以使用无符号类型unsigned int，这样变量可以表示更大的值。
如果知道变量可能表示的数值大于16位整数的最大可能值，则使用long。不同计算机系统对应的int长度不同，有的是16位的，有的是32位的。但是应尽量满足最小的系统对应的int长度，这样程序从高系统移到低系统时，也是兼容的。
如果short比int小，则使用short可以节省内存。通常，仅当有大型整型数组时，才有必要使用short。
如果只需要一个字节，可使用char。
3.1.6 整型字面值
整型字面值是显式地书写的常量，与C相同，C++能够以三种不同的计数方式来书写整数：基数为0、基数为8和基数为16.
如果第一位为1-9，则基数为10；
如果第一位是0，第二位1-7，则基数为8；
如果前两位是0x或0X，则基数为16；

#include <iostream>
int main()
{
	using namespace std;
	int chest=42;
	int waist=0x42;
	int inseam=042;

	cout<<"Monsieur cuts a striking figure!\n";
	cout<<"chest="<<chest<<"(42 in decimal)\n";
	cout<<"waist="<<waist<<"(0x42 in hex)\n";
	cout<<"inseam="<<inseam<<"(042 in octal)\n";
	return 0;
}

运行结果
注：在默认情况下，cout以十进制格式显示整数，而不管这些整数在程序中是如何书写的。
cout的特性提供了控制符dec、hex和oct分别用于指示cout以十进制、十六进制和八进制格式显示整数。

#include <iostream>
int main()
{
	using namespace std;
	int chest=42;
	int waist=0x42;
	int inseam=042;

	cout<<"Monsieur cuts a striking figure!\n";
	cout<<"chest="<<chest<<"(42 in decimal)\n";
	cout<<hex;
	cout<<"waist="<<waist<<"(0x42 in hex)\n";
	cout<<oct;
	cout<<"inseam="<<inseam<<"(042 in octal)\n";
	return 0;
}

运行结果
3.1.7 C++如何确定常量的类型
程序的声明将特定的整型变量的类型告诉了C++编译器，但是编译器是如何知道常量的类型的呢？假设在程序中使用常量表示一个数字

cout<<"Year="<<2022<<"\n";

这里程序默认将整型常量存储为int类型，除非有理由存储为其他类型，如使用了特殊后缀来表示特定类型，或者值太大，不能存储为int。
在int为16位，long为32位的系统上，20000被表示为int类型，40000被表示为long类型，3000000000被表示为long long类型。数字22022被存储为int，占16位，数字22022L被存储为long，占32位，22022LU和22022UL都被存储为unsigned long。
3.1.8 char 类型：字符和小整数
另一种整型：char类型。char类型是专为存储字符而设计的。对计算机来说存储数字与存储字母不是一回事，编程语言通过使用字母的数值编码解决了这个问题。因此，char类型是另一种整型，它足够长，能够表示目标计算机系统中的所有基本符号——所有的字母、数字、标点符号等。实际上，很多系统支持的字符都不超过128个，因此，用一个字节就可以表示所有的符号。因此，虽然char最常用来处理字符，但也可以将它用作比short更小的整型。

#include <iostream>
int main()
{
	using namespace std;
	char ch;
	cout<<"Enter a character: "<<endl;
	cin>>ch;
	cout<<"Hola!";
	cout<<"Thank you for the "<<ch<<" character "<<endl;
	return 0;
}

运行结果
在字符编码中M对应的87，程序中输入的是M，而不是87，打印的是M，而不是87，这并不是因为char类型，而是因为cin和cout，它们为我们完成了转换工作。

#include <iostream>
int main()
{
	using namespace std;
	char ch='M';
	int i = ch;
	cout<<"The ASCII code for "<<ch<<" is "<<i<<endl;

	cout<<"Displaying char ch using cout.put(ch): ";
	cout.put(ch);
	cout.put('!');
	cout<<endl<<"Done"<<endl;
	return 0;
}

运行结果
注：成员函数cout.put()
cout.put()是一个重要的C++ OOP概念——成员函数中的一种。类定义了如何表示和控制数据。成员函数归类所有，描述了操纵类数据的方法。类ostream有一个put()成员函数，用来输出字符，它只能通过类的特定对象（例如这里的cout对象）来使用成员函数。通过对象使用成员函数，必须用句点将对象名和函数名称put()连接起来。cout.put()的意思是，通过类对象cout来使用函数put()。
注：char字面值

#include <iostream>
int main()
{
	using namespace std;
	cout<<"\aOperation \"HyperHype\" is now activated!\n";
	cout<<"Enter your agent code:_______\b\b\b\b\b\b\b\b";
	long code;
	cin>>code;
	cout<<"\aYou entered "<<code<<"...\n";
	cout<<"\aCode verified!Proceed with Plan Z3!\n";
	return 0;
}

打印下划线字符后，程序使用退格字符将光标退到第一个下划线处，输入对应内容后，enter。
完整的运行情况

注：通用字符名：
C++实现支持一个基本的源字符集，即可用来编写源代码的字符集。它由标准美国键盘上的字符和数字、C语言中使用的符号以及其他一些字符组成。还有一个基本的执行字符集，它包括在程序执行期间可处理的字符。
注：signed char和unsigned char
与int不同的是，char在默认情况下既不是没有符号，也不是有符号。是否有符号由C++实现决定，这样编译器开发人员可以最大限度地将这种类型与硬件属性匹配起来。如果char有某种特定的行为非常重要，则可以显式地将类型设置为signed char或unsigned char：

char fodo;     //may be signed,may be unsigned
unsigned char bar;   //definitely unsigned
signed char snark;  //definitely  signed

	如果将char用作数值类型，则unsigned char和signed char之间的差异将非常重要。unsigned char类型的表示范围通常是0-255，而signed char的表示范围是-128-127。例如，要使用一个char变量来存储像200这样大的值，则在某些系统上可以，而在另一些系统上可能不可以。但使用unsigned char可以在任何系统上达到这种目的。另一方面，如果使用char变量来存储标准ASCII字符，则char有没有符号都没有关系，在这种情况下，可以使用char。

注： bool类型
在计算中，布尔变量的值可以是true和false。过去，C++和C一样，也没有布尔类型，C++将非零值解释为true，将零解释为false。现在可以使用bool类型来表示真假了，它们分别用预定义的字面值true和false表示。可以这样编写语句：
bool is_ready = true;
字面值true和false都可以通过提升转换为int类型，true被转换为1，而false被转换为0；
int ans=true；
int promise=false；
另外，任何数字值或指针都可以被隐式转换为bool值，任何非零值都被转换为true，而零被转换为false。
bool start=-100; //start assigned true
bool stop=0; //stop assigned false

3.2 const限定符
C++有一种更好的处理符号常量的方法，这种方法就是使用const关键字来修改变量声明和初始化。例如，假设需要一个表示一年中月份数的符号常量，请在程序中输入下面这行代码：
const int Months=12； //Months is symbolic constant for 12
这样，就可以在程序中使用Months，而不是12了。常量（如Months）被初始化后，其值就被固定了，编译器将不允许再修改该常量的值。关键字const叫做限定符，因为它限定了声明的含义。
3.3 浮点数
浮点数能够表示带小数部分的数字，使用浮点类型可以表示诸如2.5564、3.1415926这样的数字，即带小数部分的数字。计算机将这样的值分成两部分存储。一部分表示值，另一部分用于对值进行放大和缩小。比如，对于数字34.1245和34124.5，他们除了小数点的位置不同外，其他都是相同的。可以把第一个数表示为0.341245（基准值）和100（缩放因子），而将第二个数表示为0.341245（基准值相同）和10000（缩放因子更大），缩放因子的作用是移动小数点的位置，术语浮点因此而得。C++内部表示浮点数的方法与此相同，只不过它基于的是二进制数，因此缩放因子是2的幂，而不是10的幂。幸运的是，我们不必详细了解内部表示。重要的是，浮点数能够表示小数值、非常大和非常小的值，他们的内部表示方法与整数有天壤之别。
3.3.1书写浮点数
C++有两种书写浮点数的方式
第一种：使用常用的标准小数点表示法：
比如：12.34、939001.32、0.00023、8.0等
第二种：E表示法，最适合于非常大和非常小的数，指数可以是正数也可以是负数
比如：3.45E6，这指的是3.45*10^6，E6指的是10的6次方。
3.3.2 浮点类型
和C一样，C++也有3种浮点类型：float、double和long double。
事实上，C和C++对于有效位数的要求是，float至少32位，double至少48位，且不少于float，long double至少和double一样多。这三种类型的有效数字可以一样多。然而，通常是float为32位，double为64位，long double为80、96或128位。另外，这三种类型的指数范围至少是-37到37。

#include <iostream>
int main()
{
	using namespace std;
	cout.setf(ios_base::fixed,ios_base::floatfield);     //fixed point
	float tub=10.0/3.0;   	//good to about 6 places
	double mint =10.0/3.0; 			//good to about 15 places
	const_float miLlion = 1.0e6;

	cout<<"tub="<<tub;
	cout<<", a million tubs = "<<miLlion*tub;
	cout<<",\nand ten million tubs=";
	cout<<10*miLlion*tub<<endl;

	cout<<"mint="<<mint<<" and a million mints=";
	cout<<miLlion*mint<<endl;
	return 0;
}

运行结果
1、程序说明：
通常cout会删除结尾的零。例如3333333.250000显示为3333333.25.调用cout.setf()将覆盖这种行为。
这里需要注意的是：为何float的精度比double低。tub和mint都被初始化为10.0/3.0=3.333333333333…
由于cout打印的是6位小数，因此tub和mint都是精确的。但当程序将每个数乘以1000000后，tub在第七个3之后就与正确的值有了误差。tub在7位有效位上还是精确的。然而，double类型的变量显示了13个3，因此它至少有13位是精确的，由于系统确保15位有效位。另外，将tub乘以1000000，再乘以10后，得到的结果不正确，这再一次指出了float的精度限制。
cout所属的ostream类有一个类成员函数，能够精确地控制输出的格式——字段宽度、小数位数、采用小数格式还是E格式等。

3.3.3 浮点常量
在默认情况下，像8.24和2.4E8这样的浮点常量都属于double类型。如果希望常量为float类型，请使用f或F后缀。对于long double类型，可使用l或L后缀。比如：
1.234f //a float constant
2.45E20F //a float constant
2.34244213E28 //a double constant
2.2L //a long double constant

3.3.4 浮点数的优缺点
与整数相比，浮点数有两大优点，首先，他们可以表示整数之间的值。其次，由于有缩放因子，他们可以表示的范围大得多。另一方面，浮点运算的速度通常比整数运算慢，且精度将降低。

#include <iostream>
int main()
{
	using namespace std;
	float a = 2.34E+22f;
	float b = a + 1.0f;

	cout<<"a="<<a<<endl;
	cout<<"b-a="<<b-a<<endl;
	return 0;
}

运行结果
该程序将数字加1，然后减去原来的数字，结果应该为1。上面是我的系统运行该程序时的输出，问题在于，2.34E+22是一个小数点左边有23位的数字。加上1，就是在第23位加1，但float类型只能表示数字中的前6位或前7位，因此修改第23位对这个值不会有任何影响。
3.4 C++算术运算符
C++使用运算符来运算。它提供了几种运算符来完成5种基本的算术计算：+加法、-减法、*乘法、/除法以及%求模(它生成第一个数除以第二个数后的余数)。

#include <iostream>
int main()
{
	using namespace std;
	float hats,heads;

	cout.setf(ios_base::fixed,ios_base::floatfield);
	cout<<"Enter a number:";
	cin>>hats;
	cout<<"Enter another number:";
	cin>>heads;

	cout<<"hats="<<hats<<";heads="<<heads<<endl;
	cout<<"hats+heads="<<hats+heads<<endl;
	cout<<"hats-heads="<<hats-heads<<endl;
	cout<<"hats*heads="<<hats*heads<<endl;
	cout<<"hats/heads="<<hats/heads<<endl;
	cout<<"hats%heads="<<hats%heads<<endl;
	return 0;
}

运行结果
这里50.25+11.17=61.42，但是输出确是61.419998。这不是运算问题；而是由于float类型表示有效位数的能力有限。对于float，C++只保证6位有效位。如果需要更高的精度，请使用double或long double。
3.4.1 运算符优先级和结合性
C++使用优先级规则来决定首先使用哪个运算符。算术运算符遵循通常的代数优先级，先乘除，后加减。因此，3+45指的是3+(45)，而不是（3+4）*5。当然，也可以使用括号来执行自己定义的优先级。
3.4.2 除法分支
除法运算符/的行为取决于操作数的类型。如果两个操作数都是整数，则C++执行整数除法。这意味着结果的小数部分将被丢弃，使得最后的结果是一个整数。如果其中一个操作数是浮点值，则小数部分保留，结果为浮点数。

#include <iostream>
int main()
{
	using namespace std;
	cout.setf(ios_base::fixed,ios_base::floatfield);
	cout<<"Integer division:9/5="<<9/5<<endl;
	cout<<"Floating-point division:9.0/5.0="<<9.0/5.0<<endl;
	cout<<"Mixed division:9.0/5="<<9.0/5<<endl;
	cout<<"double constants:1e7/9.0="<<1.e7/9.0<<endl;
	cout<<"float constants:1e7f/9.0f="<<1.e7f/9.0f<<endl;
	return 0;
}

运行结果

从输出结果的第一行可知：整数除以整数为整数
第二三行可知：存在操作数是浮点数时，输出为浮点数
第四五行可知：如果两个都是double类型，结果为double类型，如果两个都是float类型，结果为float类型。

3.4.3 求模运算符
求模运算符返回整数除法的余数。它与整数除法相结合，尤其适用于解决要求将一个量分成不同整数单元的问题。例如：一英石等于14磅，多数英国浴室都使用这样的单位。下面的程序使用整数除法来计算合多少英石，再用求模运算符来计算余下多少磅。

#include <iostream>
int main()
{
	using namespace std;
	const int Lbs_per_stn=14;
	int lbs;

	cout<<"Enter your weight in pounds:";
	cin>>lbs;
	int stone=lbs/Lbs_per_stn;
	int pounds=lbs%Lbs_per_stn;
	cout<<lbs<<"pounds are"<<stone<<"stone,"<<pounds<<" pounds(s).\n";
	return 0;
}

运行结果

3.4.4 类型转换
C++拥有丰富的类型，允许根据需求选择不同的类型，这也使计算机的操作更复杂。由于拥有11种整型和3种浮点类型，因此计算机需要处理大量不同的情况，尤其是对不同类型进行运算时。为处理这种潜在的混乱，C++自动执行很多类型转换：
*将一种算术类型的值赋给另一种算术类型时，C++将对值进行转换。
*表达式中包含不同的类型时，C++将对值进行转换
*将参数传递给函数时，C++将对值进行转换
如果不知道进行这些自行转换时将发生的情况，将无法理解一些程序的结果。
C++自行转换规则：
1、初始化和赋值进行的转换
C++允许将一种类型的值赋给另一种类型的变量。这样做时，值将被转换为接受变量的类型。例如，假设so_long的类型时long，thirty的类型为short，而程序中包含这样的语句：

so_long=thirty;    //assigning a short to a long

则进行赋值时，程序将thirty 的值（通常是16位）扩展为long值（通常是32位）。扩展后将得到一个新值，这个值被存储在so_long中，而thirty的内容不变。
将 一个值赋给值取值范围更大的类型通常不会导致什么问题。例如，将short的值赋给long变量并不会改变这个值，只是占用的字节更多而已。然而，将一个很大的long值赋给float变量将降低精度。因为float只有6位有效数字，因此这个值将被四舍五入。故而有些转换时安全的，有些则会带来麻烦。

#include <iostream>
int main()
{
	using namespace std;
	cout.setf(ios_base::fixed,ios_base::floatfield);
	float tree =3;
	int guess(3.9832);
	int debt=7.2E12;
	cout<<"tree="<<tree<<endl;
	cout<<"guess="<<guess<<endl;
	cout<<"debt="<<debt<<endl;
	return 0;
}

运行结果
3.5 总结
C++的基本类型分为两组：一组由存储为整数的值组成，另一组由存储为浮点格式的值组成。
整型从小到大依次是：bool、char、signed char、unsigned char、short、unsigned short、int、unsigned int、long、unsigned long、long long、unsigned long long。
浮点类型有：float、double、long double
C++运用算术运算符来提供数字类型的算术运算：加减乘除和求模

3.6 复习题
1、为什么C++有多种整型？
答：有多种整型类型，可以根据特定需求选择最合适的类型。例如，可以使用short来存储空格，使用long来确保存储容量，也可以寻找可提高特定计算的速度的类型。
2、声明与下述描述相符的变量
a.short整数，值为80
答：short i=80;
b.unsigned int 整数，值为42110
答：unsigned int i=42110
c.值为3000000000的整数
答：unsigned long i=3000000000
3、C++提供了什么措施来防止超出整型的范围？
答：C++没有提供自动防止超出整型限制的功能，可以使用头文件climits来确定限制情况
4、33L与33之间有什么区别？
答：常量33L的类型是long，常量33的类型是int
5、下面两条C++语句是否等价？
char grade=65;
char grade=‘A’;
答：这两条语句并不真正等价，虽然对于某些系统来说，他们是等效的。最重要的是，只有在使用ASCII码的系统上，第一条语句才将得分设置为字母A，而第二条语句还可用于使用其他编码的系统。其次，65是一个int常量，而‘A’是一个char常量。
6、如何使用C++来找出编码88表示的字符？指出至少两种方法。
答：第一种： char c=88;
cout<<c<<endl;
第二种： cout.put(char(88));
第三种: cout<<char(88)<<endl;
第四种： cout<<(char)88<<endl;
7、将long值赋给float变量会导致舍入误差，将long值赋给double变量呢？将long long值赋给double变量呢？
答：这个问题取决于这两个类型的长度，如果long为4个字节，则没有损失。因为最大的long值将是20亿，即有10位数。由于double提供了至少13位有效数字，因而不需要进行任何的舍入。long long类型可提供19位有效数字，超过了double保证的13位有效数字，故会导致舍入误差。
8、下列C++表达式的结果分别是多少？
a.89+2 答：72+2=74
b.63/4 答：18/4=4
c.3/46 答：06=0
d.6.0*3/4 答：18.0/4=4.5
e.15%4 答：3
9、假设x1和x2是两个double变量，你要将它们作为整数相加，再将结果赋给一个整型变量。请编写一条完成这项任务的C++语句。如果要将它们作为double值相加并转换为int呢？
答：第一项任务：

int pos =int(x1)+int(x2);

第二项任务：

int pos=int(x1+x2);

10、下面每条语句声明的变量都是什么类型？
a.auto cars=15; //int
b.auto iou=150.37f; //float
c.auto level=‘B’; //char
d.auto crat=U/‘U00002155’; //char32_t
e.auto fract=8.25f/2.5; //double

hdnsjskksnsbd

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第三章——处理数据

1、C++变量的命名规则2、C++内置的整型——unsigned long、long、unsigned int、int、unsigned short、short、char、unsigned char、signed char和bool。3、C++11新增的整型：unsigned long long和long long。4、表示各种整型的系统限制的climits文件。5、各种整型的数字字面值（常量）6、使用const限定符来创建符号常量7、C++内置的浮点类型：float、double和long d
复制链接

扫一扫