变量和基本类型

引言：

1、各种程序设计语言都具有许多各具特色的特征，这些特征决定了用每种语言适合开发哪些类型的应用程序。

2、大多数现代现代程序设计语言都采用两种方式扩充语言的基本特征集：允许程序员通过自定义数据类型扩充该语言；提供一组库例程，这些例程定义了一些并非内置在语言中的实用函数和数据类型。

3、C++是静态类型语言，支持在编译时执行类型检查。

4、包括C++在内的其他语言允许程序员定义的类型不仅有数据还包含操作！

5、掌握C++的第一步就是学习语言的基本知识和标准库！

6、类型可以告诉我们：数据代表什么意思；可以对数据执行哪些操作。

正文：

一、基本内置类型

1、算术类型的存储空间大小依机器而定。

2、wchar_t类型用于扩展字符集，如汉字，日文等。

3、 1字节=8位

1B = 8bit

1字/word= 32b/4B

P31的《内置类型和机器级表示》非常重要，值得细读！

一般的，short类型为半个机器字长，int为一个机器字长，而long为2个机器字长（在32位操作系统中int与long通常字长是相同的！）

4、虽然char有三种不同的类型，但是只有两种表示方式。

5、一般，float类型用一个字长表示，double用两个字长表示，而long
double要用三个或四个字长来表示。

类型的取值范围决定了浮点数所含的有效数字位数。如果没有特殊要求，一般推荐使用double！

6、P33《建议：使用内置算术类型》值得一读！

二、字面值常量

只有内置类型存在字面值，没有类类型的字面值！

1、在char类型字面值前面加L就得到了wchar_t类型的宽字符字面值，如：

wchar_t A = L‘A‘;

2、转义字符可以通过‘\‘符号来表示，如：

\ooo             三个八进制数字表示字符的数字值

\xddd           十六进制数字表示字符的数字值

3、字符串字面值连接

[cpp] view plaincopyprint?

1. //正确:
2. std::cout << "A multi-line "
3. "string literal "
4. "using concatenation"
5. << std::endl;
6. std::cout << "Who goes with F\145rgus?\012"
7. << std::endl;
8. //错误:
9. std::cout << "A multi-line " L "string literal " "using concatenation" << std::endl;
10. std::cout << 3.14UL << std::endl;

//正确:
std::cout << "A multi-line "
              "string literal "
              "using concatenation"
              << std::endl;
std::cout << "Who goes with F\145rgus?\012"
            << std::endl;
//错误:
std::cout << "A multi-line " L "string literal " "using concatenation" << std::endl;
std::cout << 3.14UL << std::endl;

4、多行字面值

[cpp] view plaincopyprint?

1. std::cout << "A multi-line " "string \
2. literal " "using concatenation"
3. << std::endl;

std::cout << "A multi-line " "string literal " "using concatenation"
          << std::endl;

P37

[cpp] view plaincopyprint?

1. //习题2.10
2. #include <iostream>
3. int main()
4. {
5. std::cout << "\062\115\n"
6. << "\062\t\115\n"
7. << std::endl;
8. return 0;
9. }

//习题2.10
#include <iostream>

int main()
{
    std::cout << "\062\115\n"
              << "\062\t\115\n"
              << std::endl;
    return 0;
}

三、变量

P38

[cpp] view plaincopyprint?

1. //习题2.11
2. #include <iostream>
3. int main()
4. {
5. std::cout << "Please input the base and the exponent:" << std::endl;
6. int base,exponent;
7. std::cin >> base >> exponent;
8. int result = 1;
9. for (int i = 0;i < exponent; ++i)
10. {
11. result *= base;
12. }
13. std::cout << result << std::endl;
14. return 0;
15. }

//习题2.11
#include <iostream>

int main()
{
	std::cout << "Please input the base and the exponent:" << std::endl;
	int base,exponent;
	std::cin >> base >> exponent;

	int result = 1;
	for (int i = 0;i < exponent; ++i)
	{
		result *= base;
	}
	std::cout << result << std::endl;

    return 0;
}

1、C++是一门静态类型语言，在编译时会作类型检查；静态类型检查机制能够帮助我们更早的发现错误。

2、变量提供了程序可以操作的有名字的存储区。变量的类型决定了变量的内存大小和布局，能够存储在该内存中的值的取值范围以及可应用在该变量上的操作集。

3、什么是对象：对象就是内存中具有类型的区域。（P40）

4、标识符不能包含两个连续的下划线，也不能以下划线开头后跟一个大写字母。

5、变量命名习惯：

1）变量名一般小写。

2）标识符应使用帮助记忆的名字。

3）包含多个词的标识符书写在每个词之间添加一个下划线。

4）命名习惯最重要的是保持一致！

P41

[cpp] view plaincopyprint?

1. //习题2.14
2. char _;         //错误
3. bool catch-22;      //错误
4. char 1_or_2 = ‘1‘;  //错误
5. float Float = 3.14; //正确

//习题2.14
char _;			//错误
bool catch-22;		//错误
char 1_or_2 = '1';	//错误
float Float = 3.14;	//正确

6、定义对象

[cpp] view plaincopyprint?

1. //可以以逗号分开的含有一个或者多个说明符列表
2. //类型决定了分配给变量的存储空间大小和可以在其上执行的操作集合。
3. double sales_price,avg_price;

	//可以以逗号分开的含有一个或者多个说明符列表
	//类型决定了分配给变量的存储空间大小和可以在其上执行的操作集合。
	double sales_price,avg_price;

1）初始化

C++支持两种格式的初始化：

a.复制初始化：int ival = 1024; //有多个初始化式时不能使用复制初始化！

b.直接初始化：int ival(1024); //直接初始化的方法更灵活且效率更高

【在C++中：初始化并不就是赋值：初始化是创建变量并给他赋值，赋值是擦除对象的当前值并且用新值代替】

2）初始化多个变量：

正确：double salary = 9999.99,wage(salary + 0.01);

P44

[cpp] view plaincopyprint?

1. //习题2.15
2. //该语句是错误的，既然指定mouth，day用八进制来初始化，就不要用数字‘9‘
3. int mouth = 09,day = 07;
4. //习题2.16
5. //该语句正确
6. double wage = 10;
7. double salary = wage = 15;

//习题2.15
//该语句是错误的，既然指定mouth，day用八进制来初始化，就不要用数字'9'
int mouth = 09,day = 07;

//习题2.16
//该语句正确
double wage = 10;
double salary = wage = 15;

3）变量初始化规则

a.内置类型的变量是否初始化取决于变量定义的位置：在函数体外定义的变量都初始化成0，在函数体内定义的内置类型变量不进行自动初始化。

【但是，未初始化的变量事实上都有一个值】

建议：每个内置类型的对象都要初始化。

b.类通过定义一个或多个构造函数来控制类对象的初始化。如果一个类有默认构造函数，则无论变量在哪儿定义，默认构造函数都会被调用。

4）声明和定义

C++通过extern关键字声明，向程序表明变量的类型和名字。因为extern是声明，所以不分配存储空间。

一个变量可以声明多次，但只能定义一次

如果声明有初始化式，那么它可以被当作是定义，即使有声明标记extern，如：

[cpp] view plaincopyprint?

1. extern double PI = 3.14;    //只有当extern声明位于函数外部时，才可以含有初始化式，但是有些编译器还是不能通过编译。

extern double PI = 3.14;	//只有当extern声明位于函数外部时，才可以含有初始化式，但是有些编译器还是不能通过编译。

5）名字的作用域

大多数的作用域是通过花括号来定界的。

C++作用域可嵌套：

[cpp] view plaincopyprint?

1. //在函数内定义一个与函数可能会用到的全局变量同名的局部变量总是不好的，局部变量最好使用不同的名字！
2. #include <iostream>
3. #include <string>
4. std::string s1 = "hello";  // s1 has global scope
5. int main()
6. {
7. std::string s2 = "world"; // s2 has local scope
8. // uses global s1; prints ``hello world‘‘
9. std::cout << s1 << " " << s2 << std::endl;
10. //int类型的s1将屏蔽掉std::string类型的s1
11. int s1 = 42; // s1 is local and hides global s1
12. // uses local s1; prints ``42 world‘‘
13. std::cout << s1 << " " <<  s2 << std::endl;
14. return 0;
15. }

//在函数内定义一个与函数可能会用到的全局变量同名的局部变量总是不好的，局部变量最好使用不同的名字！
#include <iostream>
#include <string> 

std::string s1 = "hello";  // s1 has global scope 

int main()
{
	std::string s2 = "world"; // s2 has local scope 

	// uses global s1; prints ``hello world''
	std::cout << s1 << " " << s2 << std::endl;   

	//int类型的s1将屏蔽掉std::string类型的s1
	int s1 = 42; // s1 is local and hides global s1 

	// uses local s1; prints ``42 world''
	std::cout << s1 << " " <<  s2 << std::endl;
	return 0;
}

6）在便零使用处定义变量

通常把一个对象定义在他首次使用的地方是一个很好的方法！

P48

[cpp] view plaincopyprint?

1. //习题2.20下列程序会输出什么？
2. #include <iostream>
3. int main()
4. {
5. int i = 100,sum = 0;
6. for (int i = 0;i != 10; ++i)
7. {
8. sum += i;
9. }
10. std::cout << "i = " << i << ", sum = " << sum << std::endl;
11. return 0;
12. }
13. //答案：i = 100, sum = 45