1.变量名命名
2.运算符sizeof和头文件limits
1.sizeof对类型名（如int）使用应将名称放括号里，对变量名（如n_short）使用括号是可选的：
cout<<"int is"<<sizeof(int)<<"bytes.\n";
cout<<"short is"<<sizeof n_short<<"bytes.\n";
头文件climits定义了符合常量来表达类型的限制。
3.初始化
1.初始化将赋值与声明合并在一起。例如：下面的语句声明了变量n_int，并将int的最大取值赋给它：
int n_int = INT_MAX;
2.使用字面值常量来初始化。将变量初始化为另一个变量，条件是后者已经定义过。甚至可以使用表达式来初始化变量，条件是当程序执行到该声明时，表达式中所有的值都是已知的：
int unclass = 5;
int aunts = uncles;
int chairs = aunts+uncles+4;
前面的初始化都是C语言，C++还有独特的初始化语法:
int owls = 101;//C
int wrens(432);;//C++
注：如果不对函数内部定义的变量进行初始化，该变量的值是不确定的。这意味着该变量的值将是它被创建之前，相应内存单元保存的值。还有要在声明变量时进行初始化。
C++11初始化方式
用于数组和结构的初始化方式，但在c++98中，也可用于单值变量:
int hamburgers = {24};
将大括号初始化用于单值的很多，但C++11标准更多了。首先，采用这种方式时，可以使用等号（=），也不用：
int emus{7};
int rheas={12};
大括号可不包含如何值，变量默认为0：
int rocs={};
int psychics{};
这有助于更好防范类型错误。
无符号类型
前面介绍的整型都有一种不能存储负数值的无符号变体，其优点是可增大变量能够存储的最大值。仅当数值不会为负时才应使用无符号类型。如：人口、粒数等。要创建无符号版本的基本整型，只需使用关键字unsigned来修改声明：
unsigned short change;//unsigned short
unsigned int rovert;//unsigned int
unsigned quarterback;//unsigned int
unsigned long gone;//unsigned long
unsigned long long lang_lang;//unsigned long long
注：unsigned 本身是unsigned int 的缩写。
例：
#include<iostream>
#include<climits>//将INT_MAX定义为最大的int值
#define ZERO 0
using namespace std;
int main()
{
short sam = SHRT_MAX;//将变量初始化为最大值
unsigned short sue = sam;//ok,如果变量sam已经定义
cout<<"Sam has"<<sam<<"dollars and Sue has"<<sue;
cout<<"dollars deposited."<<endl
<<"Add $1 to each account."<<endl<<"Now";
sam=sam+1;
sue=sue+1;
cout<<"Sam has"<<sam<<"dollars and Sue has"<<sue;
cout<<"dollars deposited.\nPoor Sam!"<<endl;
sam=ZERO;
sue=ZERO;
cout<<"Sam has"<<sam<<"dollars and Sue has"<<sue;
cout<<"dollars depoited."<<endl;
cout<<"Take $1 from each account."<<endl<<"Now";
sam=sam-1;
sue=sue-1;
cout<<"Sam has"<<sam<<"dollars and Sue has"<<sue;
cout<<"dollars deposited."<<endl<<"Lucky Sue!"<<endl;
return 0;
}
1.如果在多个地方使用一个常量，只需要加一个符号定义：const 关键字
如：
const int a=100;
这样定义程序中a只能等于10，不能修改。
创建方式：
const type name = value;
1.有时，编程的过程中需要将值从一种数据类型转换为另一种数据类型。
1.将一种算术类型的值赋值给另一种算术类型，c++将进行强制转换；
2.不同类型之间转换，c++将进行值转换；
3.将参数传递给函数时，c++将对值进行转换；
#include <iostream>
using namespace std;
int main()
{
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;
}
2**.以{}方式初始化进行转换**
const int code=66;
int x=66;
char c1 {31325};
char c2={66};
char c3 {code};
char c4={x};
x=31325;
char c5=x;
3.表达式转换
short a=20;
short b=35;
short c=a+b;
执行第三行，程序将得到a,b的值，并将转换为int。将结果转换short类型。
4.强制转换
如：将变量a中的int值转换为long类型；
(long)a;
long (a);
强制转换格式：
(typename)value;
typeName (value);
5.强制转换运算符static_cast<>
如将arr转换long类型
static_cast<long> (arr);
格式：
static_cast(typename) (value);
6.c++11中的auto声明
1，auto是c语言关键字能让编译器根据初始值得类型推断变量类型。
2在初始化声明中，如果使用auto，而不指定变量类型，编译器将把变量的类型设置成与初始值相同：
auto n=100;//int
auto x=1.5;//double
auto y=1.3eL12L;//long double
然而，自动推断类型并非为这种简单情况而设计，如果为了简单，可能会误入歧途，如：将 x，y和z都指定double类型：
auto x=0.0;//ok
double y=0;//ok ，0.0
auto z=0;//oops,z is int because 0 is int
例：
#include <iostream>
#include<climits>
using namespace std;
int main()
{
int n_int=INT_MAX;
short n_short=SHRT_MAX;//将n_int初始化为最大int值
long n_long=LONG_MAX;//climits文件中定义的符合
long long n_llong=LLONG_MAX;
//sizeof运算符产生变量类型的大小
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<<"Maximum int value"<<INT_MAX<<endl;
cout<<"Bits per byte"<<CHAR_BIT<<endl;
return 0;
}
选择整型类型
c++提供了大量的整数，应如何使用？
整型字面值
整型字面值是显示地书写的常量，如212或1776。c++能够以三种不同的计算方式书写整数:基数10、基数8和基数16。介绍c++表示法。c++使用前一位来标识数字常量的基数。如果第一位为1-9，则基数为10（十进制）;因此93是以10位为基数的。如果第一位为0，第二位为1-7，则基数为8（八进制）；因此042的基数是8，它相当于十进制数34。如果前两位为0x或0X,则基数为16（十六进制）；因此0x42为十六进制数，相当于十进制数66。对于十六进制数，字符af和AF表示十六进制位，对应于10~15。0xF为15,0xA5为165（10个16加5个1）。
例：
#include<iostream>
using namespace std;
int main()
{
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;
}
注：这些方法仅仅为了表达方便，例如，如果CGA视频内存段为十六进制B000,则不必在程序中使用之前将它转换为十进制数45056，而只需使用0xB000即可。但，不管把值书写为10、012还是0xA，都是以二进制数存储在计算机内。
如果要以十六进制或八进制显示值，则可以使用cout的一些特殊特性。头文件提供了dec、hex和oct，分别用于cout指示cout以十进制、十六进制和八进制格式显示整数。
例：
#include<iostream>
using namespace std;
int main()
{
int chest = 42;
int waist = 42;
int inseam = 42;
cout<<"Monsieur cuts a striking figure!\n";
cout<<"chest = "<<chest<<"(decimal for 42)\n";
cout<<hex;
cout<<"waist = "<<waist<<"(hexadecimal for 42)\n";
cout<<oct;
cout<<"inseam = "<<inseam<<"(octal for 42)\n";
return 0;
}
c++如何确定常量的类型
首先考虑后缀。后缀是放在数字常量后面的字母。用于表示类型。下面考虑长度。
char类型是为了专门为存储字符而设计的。char类型是另一种整形。足够长，能表示目标计算机系统中的所有基本类型：所有的字母、数字、标点符号等。虽然char最常用来处理字符，但也可以将它用作比short更小的整型。
#include<iostream>
using namespace std;
int main()
{
char ch;
cout<<"Enter a character:"<<endl;
cin>>ch;
cout<<"Hola!";
cout<<"Thank you for the"<<ch<<"character"<<endl;
return 0;
}
注：输入的是M，而不是对应的字符编码77。另外程序打印M，而不是77。在内存中，77是存储在遍历ch中的值。这种转转换来自于cin和cout而不是char类型。输入时，cin将键盘输入的M转换为77；输出时，cout将77转换为字符M。如果77存储在int变量中，则cout将把它显示为77.
函数cout.put()是个重要的c++OOP概念-成员函数。类定义了如何表示和控制数据，=。成员函数的特定对象来使用成员函数。要通过对象（如cout）使用成员函数。必须用句点将对象名和函数名（put())连接起来。句点被称为成员运算符。cout.put()的意思，通过对象cout来使用函数put()。
cout.put()成员函数提供了另一种显示字符的方法，可以替代<<运算符。
例：演示如何在c++中书写字符字面值：将字符用单引号括起。使用cout.put()函数，显示一个字符。
#include<iostream>
using namespace std;
int main()
{
char ch='M';
int i = ch;//存储在int中
cout<<"The ASCII code for "<<ch<<"is"<<i<<endl;
cout<<"Add one to the characteer code:"<<endl;
ch= ch+1;
i=ch;
cout<<"The ASCII code for"<<ch<<"is"<<i<<endl;
cout<<"Displaying char using cout.put(ch):";
cout.put(ch);
cout.put('!');
cout<<endl<<"Done"<<endl;
return 0;
}
char字面值
在c++中，书写字符常量的方式有很多。对于常规字符，最简单的方法是将字符用单引号括起。这种表示法代表得是字符的数值编码。例如：ASCII系统中的对应情况如下：
有些字符不能直接通过键盘输入到程序中。例如：按回车键并不能使字符串包含一个换行符；但编辑器将解释为开始下一行。其他一些字符也无法从键盘输入，因为c++语言赋予了它们特殊的含义。对于这些字符，c++提供了转义序列。
注意，应该像处理常规字符那样处理转义序列。应用单引号括起；但将它们放入字符串中时不能使用单引号。
也可以基于字符的八进制和十六进制编码来使用转义序列。例如，Ctr+Z的ASCII码为26，对应的八进制编码为32，十六进制编码为0xla。十六进制编码为0xla。可以用下面的转义序列来表示该字符：\032或\xla。将这些编码用单引号括起。
#include<iostream>
using namespace std;
int main()
{
cout<<"\aOperation \"HyperHype\" is now activated!\n";
cout<<"Enter your agent code:_\b\b\b\b\b\b";
long code;
cin>>code;
cout<<"\aYou entered "<<code<<"...\n";
cout<<"\Code verified! Proceed with Plan Z3!\n";
return 0;
}
注：在可以使用数字转义序列或转义序列（如\0x8和\b）时，应使用符号序列。数字表示特定的编码方式相关，而符号表示适用于任何编码方式，其可读性更强。
c++实现支持一个基本的源字符集，即可用来编写源代码的字符集。是由标准美国键盘上的字符和数字、C语言中使用的符合(如{}、=）以及其他一些字符(如换行符、空格)组成，还有一个基本的执行字符集。
与int不同的是，char在默认情况下即不是没有符合，也不是有符合。是否有符合由c++实现决定，这样编译器开发人员可以最大限度地将这种类型与硬件匹配起来。如果char有某种特定的行为对你非常重要，则可以显示地将类型设置为signed char或unsigned char;
char fodo;
unsigned char bar;
signed char snark;
如果char用作数值类型，则unsigned char和signed char之间的差异将非常重要。unsigned char类型的表示范围为0~255,而signed char的表示范围为-128到127。假设要使用一个char变量来存储像200这样大的值，有些系统不可以。但使用unsigned char 可以在如何系统实现。用char变量来存储标准ASCII字符，则char有没有符合都可以，这时，可以使用char。
wchar_t类型是一种整型类型，它有足够的空间，可以表示系统使用的最大的扩展字符集。这种类型与另一种类型的长度和符合属性相同。对底层类型的选择取决于实现，因此在一个系统中，它可能是unsigend short，而在另一个系统中,则可能是int。
cin和cout将输入和输出看作是char流，因此不适合处理wchar_t类型。iostream头文件的最新版本提供了作用相似的工具：wcin和wcout，可用于处理wchar_t流，可以通过加上前缀L来指示宽字符常量和宽字符。例：
将P的wchar_t版本存储到变量bob中，并显示单词tall的wchar_t版本：
wchar_t bob = L'P';
wcout<<L"tall"<<endl;
c++11新曾增类型：char16_t和char32_t
进行字符串编码时，如果有特定长度和符合特征的类型，很有帮助，而类型wchar_t的长度和符合特征随实现而已。因此c++11新增了类型char16_t和char32_t，前者是无符号，长16位，后者也是无符号，长32位。c++11使用前缀u表示char16_t字符常量和字符串常量如u‘C’和u"be good";并使用前缀U表示char32_t常量，如U’R’和U“dirtyrat";类型char16_t与/u00F6形式的通用字符名匹配，而类型char32_t与/U0000222B形式的通用字符名匹配。：
char16_t ch1 = u 'q';
char32_t ch2 = U'U0000222B';
与wchar_t一样，char16_t和char32_t也都有底层类型——一种内置的整型，但底层类型可能随系统而已。
1.书写浮动数：
书写浮动数有两种方式：
1.使用常用的标准小数点表示法：
12.34
8.0
0.00023
2.第二种：E表示法
3.45E6(表示3.45与1000000相乘）；E6(10的6次方）；
2.浮点类型
有三种浮点类型：
float、double和long double。这些类型是按它们可以表示的有效数位和允许的指数最小范围来描述。通常,float:32位；double:63位；long double:80、96或128位。另外，三种类型指数范围至少是-37到37。可从头文件cfloat或float.h中找到系统的限制。
3.浮点常量
在程序中书写浮点常量的时候，程序将把它存储位那种浮点类型呢？在默认情况下，像8.24和2.4E8这样的浮点常量都属于double类型。如果希望为flaot类型：使用f或F后缀。对于long double类型，使用l或L后缀：
1.234f
2.45E20F
2.345324F26
2.2L
4.浮点数的优缺点
与整数相比，浮点数有两大优点。首先，可以表示整数之间的值，其次，由于有缩放因子，可以表示范围大得多。另一方面，浮点运算的速度通常比整数运算符慢，且精度降低。
c++标准添加了一种名为bool的新类型。在计算中，布尔变量的值可以是true和false。例：可以编写下面代码
bool is_ready = true;
字面值true和false都可以通过提升转换为int类型，true被转为1，false被转为0：
int ans = true;//1
int promise = false;//0
另外，任何数字值或指针都可以被隐式转换为bool值，任何非零都被转换为true，而零被转为false:
bool start = -100;//true
bool stop = 0;//false
c++可以使用运算符来运算。它提供了加减乘除以及求模算术运算。例：
#include<iostream>
using namespace std;
int main()
{
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;
return 0;
}
注：float只能表示6位有效位数。需要更高精度double和long double。
使用c++来完成算术运算，很多表达式包含多个运算符。要考虑运算符的优先级。当多个运算符可用于同个操作数时，算术运算符遵循通常的代数优先级，先乘除，后加减。但可以使用括号来决定自定义的优先级。当两个运算符的优先级相同时，c++将看操作数的结合性是从左到右，还是从右到左。从左到右的则先应用左侧的运算符。从右到左应用右侧的运算符。
例：
float logs = 120/4*5;//乘除都是从左到右结合，所以对4使用左侧运算符
除法运算符（/）的行为取决于操作数的类型，如果两个操作数都是整数，则c++将执行整数除法。这意味着结果的小数部分被丢弃，使得最后的结果是个整数。如果其中有一个（或两个）操作数是浮点值，则小数部分将保留，结果为浮点数·。例：
下面的程序演示除法如何处理不同类型的值。
#include<iostream>
using namespace std;
int main()
{
cout.setf(ios_base::fixed,ios_base::floatfield);//修改结果的显示方式
cout<<"Integer divisoion: 9/5"<<9/5<<endl;
cout<<"Floating-point division:9.0/5.0=";
cout<<9.0/5.0<<endl;
cout<<"Mixed division:9.0/5="<<9.0/5<<endl;
cout<<"double constants:le7/9.0=";
cout<<1.e7/9.0<< endl;
cout<<"float constsnts:1e7f/9.0f=";
cout<<1.e7f/9.0f<<endl;
return 0;
}
整：对于不同类型进行运算时，c++将把转换为同一类型。浮点数常量在默认的情况下为double。
求模运算符返回整数除法的余数。
例：将磅转换为英石:
#include<iostream>
using namespace std;
int main()
{
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<<"pound(s).\n";
return 0;
}
c++丰富的类型允许根据需求选择不同的类型，由于11种整型和3种浮点类型，在对不同的类型进行运算很麻烦，为处理这种情况，c++自动执行很多类型转换：
1.初始化和赋值进行的转换
c++允许将一种类型的值赋给另一种类型的变量。这样做时，值将被转换为接收变量的类型。例如：so_long类型为：long,thirty类型为：short：
so_long = thirty;//将short分配long
将short值赋给long变量并不会改变这个值，只是占用的字节更多而已。
但有些转换会带来问题：
将浮点数值赋给整型将导致两个问题，将浮点数值转换为整型会将数字截断（去掉小数部分）。其次，float值对于int变量来说可能太大了。这时，c++并没有定义结果是什么；这意味着不同的实现的反应可能不同。例：
#include <iostream>
using namespace std;
int main()
{
cout.setf(ios_base::fixed,ios_base::floatfield);
float tree = 3;//int ->float
int guess(3.9832);//doube ->int
int debt = 7.2E12;//c++没定义
cout<<"true="<<tree<<endl;
cout<<"guess="<<guess<<endl;
cout<<"debt="<<debt<<endl;
return 0;
}
2.以{}方式初始化时进行的转换（c++11）
c++将使用大括号的初始化称为列表初始化。因为这种初始化常用给复杂的数据类型提供值列表。这种方式更严格。不允许缩窄，即变量的类型可能无法表示赋给它的值。
例如：不允许将浮点数转换整数。在不同的整数之间转换或将整数转换为浮点数可能被允许，条件是编译器知道目标变量能够正确地存储赋给它的值。
例如：可将long变量初始化为int值，因为long总是至少与int一样长；相反方向的转换也可能被允许，只要int能存储给它的long常量：
const int code = 66;
int x= 66;
char c1{31325};//缩小，不允许
char c2={66};//允许
char c3{code};//缩小，不允许
char c4={x};//不允许，x不是常数；编译器看x是个变量，其值很大
x=31325;
char c5 = x;//允许这种初始化形式
3.表达式中的转换
当两个表达式中包含两种不同的算术类型时，c++将执行两种自动转换：首先，一些类型在出现时便会自动转换；其次，有些类型在与其他类型同时出现在表达式中时也将被转换。
自动转换在计算表达式时，c++将bool、char、unsigned char、signed char和short值转换为int。具体说，true被转换为1，fakse被转换为0,这些转换被称为整型提升。例如：
short a = 20;
short b = 35;
short c = a+b;
为计算c的值，取a和b的值，将转换为int。然后将结果转换为short类型。
还有一些整型提升：如果short比int短,则unsigned short类型被转换为int；如果长度相同，则unsigned short类型将被转换为unsigned int。这种规则确保了对unsigned short进行提升时不会损失数据。
将不同类型进行算术运算时，也会进行转换，例如将int和float相加时。小的类型被转换为大的类型。
编译器通过校验表来确定在算术表达式中执行的转换：
整型级别：
有符号整型级别从高到低：long long、long、int、short和signed char。无符号整型的排列顺序与有符号整型级别相同。类型char、signed char和unsigned char的级别相同。类型bool的级别最低。wchar_t、char16_t和char32_t的级别与其底层类型相同。
4.传递参数时的转换
传递参数时的类型转换通常由函数原型控制。然而，也可以取消原型对参数传递的控制，尽管这样做不好。在这种情况下，c+将对char和short类型（signed和unsigned）应用整型提升。另外，为了保持与C语言中大量代码的兼容性，在将参数传递给取消原型对参数传递控制的函数,c++将float参数提升为double。
5.强制类型转换
强制格式：
(typeName)value//c
typeName(value)//c++
c++还允许通过强制类型转换机制显示地进行类型转换。强制类型转换的格式有两种。例如：为将存储在变量thorn中的int值转换为long类型，可以使用下面的一种：
(long)thorn;
long (thorn);
强制类型转换不会修改thorn变量本身，而是创建一个新的、指定类型的值，可以在表达式中使用这个值。
cout<<int('Q');
c++还引入4个强制类型转换运算符，使用要求更严格。后面将介绍。4个运算符中，static_cast<>可用与将一种数值类型转换为另一种数值类型。例如：
static_cast<long>(thorn);
例：演示两种基本的强制转换类型和static_cast。
#include <iostream>
using namespace std;
int main()
{
int auks,bats,coots;
//值为双精度转换int
auks=19.99+11.99;
bats=(int)19.99+(int)11.99;
coots=int(19.99)+int(11.99);
cout<<"auks="<<auks<<",bats="<<bats;
cout<<",coots="<<coots<<endl;
char ch = 'Z';
cout<<"The code for"<<ch<<"is";
cout<<int(ch)<<endl;
cout<<"Yes.the code is";
cout<<static_cast<int>(ch)<<endl;
return 0;
}
