C++学习 第二 三章

1.C++的cout函数

# include <iostream>
using namespace std; // 命名空间
int main()
{
cout << "Hello World !" << endl;
/*
endl 作用：1.表示摁下回车键 2.确保代码内容立即输出
/n   作用：单纯的按下回车键 
/t   作用：空格
*/
}

在Linux系统中,C++文件的执行是要使用g++的编译器进行，具体的步骤是：
第一步：书写C++代码，将写好的C++代码保存为"xx.cpp"格式的文件
第二步：在终端中，进入到存放该文件的文件夹
第三步：使用代码 g++ 文件名 -o 文件名.cpp 生成可执行文件
第四步：执行可执行文件

cd windows/workspace
g++ test1 -o HelloWorld.cpp 
//生成可执行文件
./test1
//执行该文件

2.main函数的一些规则
1.C++可以使用以下两种主函数头：

• 第一种 int main(void)
• 第二种 int main()

这两种都是可以使用并且不会出现什么问题的。
在主函数中，可以省略return语句，系统会在默认加上一条return 0;
但是需要注意的是，只有主函数有这个特权。

3.c++的注释
单行注释：// （建议使用）
多行注释：/* */

4.namespace 名称空间的作用简述
为了方便代码的组合，方便组织程序，避免两个来自不同产品的相同名称函数使用的时候造成混乱。
例如：Neu::show() 和 Hust::show()

5.C++代码风格

1. 每个语句占一行
2. 每个函数有开始和结束两个花括号，他们都各占一行
3. 函数中的语句都相对于花括号进行缩进
4. 与函数名称相关的圆括号周围没有空白

6.变量的声明

#include <iostream>
using namespace std;

int main()
{
	int apples;
	apples = 25;
	cout << "I have ";
	cout << apples;
	cout << " apples.";
	cout << endl;
	apples = apples-1;
	cout << "Now I have " << apples << " apples." << endl;
    return 0;
}

为什么要声明：指出要存储的数据类型和程序对存储在该位置的数据使用的名称。
声明分为定义声明和引用声明，定义声明会导致计算机为变量划分内存空间，引用声明不会。
注意：尽可能在首次使用前进行声明。

7.C++的cin函数

#include <iostream>
using namespace std;

int main()
{
	int apples;
	cout << "How many apples do you have?" << endl;
	cin >> apples;
	cout << "Here are two more.";
	cout << endl;
	apples = apples+2;
	cout << "Now You have " << apples << " apples." << endl;
    return 0;
}

cin代表的是将键盘中读入的值送入变量中。

8.类的概念（简介）
类：用户定义的一种数据类型。
类描述了一种数据类型的全部属性，而对象表示类的一个实体。

9.函数（简介）
使用函数之前，编译器必须对于函数的参数类型和返回值类型进行了解，不然编译器不知道如何解释返回值，提供这些信息的就是函数原型。

函数原型

double sqrt(double); //加分号表示这个是一个函数原型而非函数头
//第一个double 表示sqrt()函数将返回一个类型为double型的函数
//第二个double 表示sqrt()函数将接收一个类型为double型的参数

无论是没有返回值还是没有形参的函数变体，在C++中都统称为函数。

函数格式

#include <iostream>
void simon(int); // 提供函数原型 放在main()函数前

int main()
{
	using namespace std;
	simon(3); //调用simon函数
	cout << "Pick an integer: ";
	int count;
	cin >> count;
	simon(count);
	cout << endl;
	cout << "Done!" << endl;
	return 0;
}
void simon(int n)
{
	using namespace std;
	cout << "Simon syas touch your toes" << n << " times." << endl;
	//注意 函数返回值类型为void 则不需要有return语句
}

一个完整的函数格式需要包含函数头和函数体，头中包含返回值类型和形参列表，函数体为函数的实现逻辑和内容。

10.c++中的变量
变量命名规则：

• 首位可以为下划线以及字母，其他位置可以为下划线，字母，以及数字。
• 区分大写字母和小写字母
• 不能使用C++的关键字作为名称
• 不要用两个下划线和一个下划线以及大写字母进行开头
• 可以使用下划线或者大小写分开两个单词 例如： my_name , myName

变量的含义：一块特定的内存单元。

变量的类型：数值型和非数值型。
数值型：
1.整型

• 字符型 （char）
• 短整型（short）
• 整型（int ）
• 长整型 （long）
• 长长整型（ long long）

在C++中，在不同的系统环境之中，每种数据类型的宽度也会有差异，C++使用了一种灵活的标准，它确保了最小的长度。

• short 最少是16位
• int至少和short一样长
• long至少32位，且至少和int一样长
• long long至少64位，且至少和long一样长

目前很多系统都使用的最小长度，即为short是16位，long为32位，而int有着多种选择，它既可以是16位也可以是24位还可以是32位，它甚至可以是64位，在IBM的老式机器之中，int定义位16位与short一致，在window 7 以及后续的系统中，定义为32位，和long相同。

//确定你的PC机中整型的位数
#include<iostream>
// 头文件limit
// 编译器厂商提供了climits文件，其中定义了许多符号常量
// 来表示类型的限制
#include<climits>

using namespace std;

int main()
{
	int n_int = INT_MAX; //INT_MAX是int的最大取值
	short n_short = SHRT_MAX; //SHRT_MAX是short的最大取值
	long n_long = LONG_MAX; //LONG_MAX是long的最大取值
	long long n_llong = LLONG_MAX; //LLONG_MAX表示long long类型的最大取值
	
	//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 << "llong 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 << "llong : " << n_llong << endl;
	cout << endl;

	return 0;
}

变量的初始化
变量的初始化就是将声明和赋值操作合二为一。

int n_int = INT_MAX; //这就是对于n_int的初始化
//C++还有一种独立于C的初始化方式
int score(432);
//C++11的初始化方式---花括号
//方式一
int humbergers = {24};
//方式二 可以省略等号
int humbergers{24};
// 对于0的表示
// 第一种
int humbergers{};
//第二种
int humbergers{0};
//二者均表示将变量初始化为0

无符号整型
short,int,long,long long四种整型类型都是可以存储正数也可以存储复数的，而这四种类型均变体类型，可以存放非负数，在一些无法出现负数的地方通常会使用这种方式

有符号类型	无符号类型
short	unsigned short
int	unsigned int
long	unsigned long
long long	unsigned long long

溢出问题

#include<iostream>
#include<climits>
using namespace std;
int main()
{
	short bob = SHRT_MAX;
	unsigned short tom = bob;
	cout << bob + 1 << endl; // 输出-32768
	cout << tom + 1 << endl; // 输出32768
	
	bob = 0;
	tom = 0;
	
	cout << bob - 1 << endl; // 输出-1
	cout << tom - 1 << endl; // 输出65535

	return 0 ;
}

上述代码证明的就是C++变量的溢出问题，C++并不能保证符号整型超越限制时不出错，如果超越了限制，这些数就将从另一端

整数的表示类型

#include<iostream>
int main()
{
	using namespace std;
	int tom = 42; //十进制表示方式
	int bob = 042; // 8进制表示方式
	int jerry = 0x42; //16进制表示方式

	cout << tom << endl; //十进制输出，默认情况
	cout << hex ; //表示接下来使用十六进制进行输出
	cout << jerry << endl; //十六进制输出结果
	cout << oct ; //表示接下来使用八进制进行输出
	cout << bob ; //使用八进制输出结果
	// cout << hex 这种表示方式不会在屏幕上做任何输出，只是修改了cout显示整数的方式
	// 因此hex是一个控制符，一条消息，告诉cout应该采取何种行为进行输出
}

注意：C++中使用单引号 ’ ’ 来表示字符。使用双引号" " 来表示字符串。

一些常用的转义字符：

字符名称	C++代码
换行符	\n
水平制表符	\t
垂直制表符	\v

一些被C++使用而拥有特殊含义的字符，也需要使用转义字符进行表示，例如 ？ ， " " , ’ ’ , \ 四种符号。

2.布尔类型
C++已经支持了布尔类型的变量（bool）

//任何数字值或者指针值都可以被隐式转换成布尔类型的变量
//其中零值被转化成false 非零值被转化成true
bool start = -100; //true
bool stop = 0 ; //false

const 限定符
const限定符是一种处理符号常量的方式

//定义一个常量来表示月份，需要注意的是该常量无法再被修改，因为使用const进行限定
const int Months = 12;

3.浮点型

• 单精度浮点型（float）
• 双精度浮点型（double）
• 双精度长浮点型（long double）

浮点型的长度要求是：

• float类型不少于32位
• double类型不少于48位，且不少于float类型
• long double类型不少于double类型

通常来说，float位32位， double为64位，long double 为80，96，或者128位。并且这三种类型的指数范围至少是-37到+37

值得注意的是float和double的精度有所不同，double的精度要高于float。对于float,C++只能够保证6位的精度，而double可以至少保证15位的精度。

常量的书写方式

1. 整型常量

• int : 默认类型就是int
• short : 不使用short类型作为常量存储
• long : 后缀为L或者l的是long类型
• long long ： 后缀为LL或ll的是long long类型
• unsigned int ：后缀为u或者U的是unsigned int类型
• unsigned short ：不使用 unsigned short 为常量存储
• unsigned long ：后缀为UL，ul 或者LU，lu为unsigned long类型
• unsigned long long ：后缀为ULL，ull 或者 uLL，Ull为unsigned long long类型

2. 浮点常量

• float : 后缀为f或者F为float类型
• double : 后缀为L或者l的为double类型

算术运算符：

#include<iostream>
using namespace std;
int main()
{
	float hats = 100.0;
	float heads = 30.0;
	//加法运算符 + 
	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;
}

类型转换问题：

• 从取值范围小的数据类型（比如short）转化成取值范围比较大的数据类型（比如long）不会改变这个值，只是它占用的字节更多而已。
• 从取值范围大的整型（比如long）转化位取值范围小的数据类型（比如short）可能会导致原来的值超出目标类型的取值返回，这是会出错，只会复制右侧的值。
• 将较大的浮点类型（double）转换为较小的浮点类型（float）可能会导致精度降低，甚至值可能超出目标类型的取值范围，导致结果的不确定
• 将浮点型数据转化为整型数据，小数部分会丢失，原来的值可能超出目标类型的转化范围，导致结果的不确定。

//C++11中初始化时进行的转化 {}
//C++11中采用花括号进行初始化的方式叫做列表初始化
//列表初始化要比一般的初始化对类型转化更加严格，它不允许缩窄
//也就是不允许出现变量的类型无法表示赋给它的值的情况
//例如：不允许将浮点型转化成整型变量
const int code = 66;
int x = 66;
char c1 = {66} ; //允许
char c2 = {3125} ; //超出范围 不允许
char c3 = {code} ; //允许
char c4 {x} ; //不允许，因为x变量的值可能很大
char c5 = x ; //允许 不过这种赋值的结果是不确定的

表达式的自动转换：

• 如果有一个操作数为long double，则将另一个也转化为long double
• 否则，如果有一个操作数为double，则将另一个也转化为double
• 否则，如果有一个操作数为float，则将另一个也转化为float
• 否则，如果都是整型，则进行整型提升，也就是将bool，char，unsigned char，signed char，short全部转化为int类型
• 在这种情况下，如果两个操作数都是有符号或无符号的，其中一个操作数的级别比另一个低则转化为级别高的类型
• 如果一个操作数是有符号的，另一个是无符号的，且无符号的操作数级别比较高，则将有符号操作数转化为无符号操作数所属的类型。
• 否则，如果有符号操作数可以包含无符号操作数的所有可能取值，则将无符号数转换为有符号数所属的类型。
• 否则，将两个操作数都转化为有符号类型的无符号版本。