目录
1.10.1 \和某些字符 结合 产生新的字符 就叫转义字符
1.1开始进入C++
1.1.1C++的hello world
#include <iostream>
using namespace std;
int main(int argc, char *argv[])
{
cout << "Hello World!" << endl;
return 0;
}#include 头文件包含
每一个C++程序有且仅有一个main函数，这是整个程序的开始位置
C++中的（）、[]、{}、、”“、‘’、都必须成对出现，必须都是英文符号
C++中语句要以分号结束
1.1.2C++的注释语句
C++注释语句不参与程序的编译，在程序的预处理阶段就被编译器删除
C++注释语句一般分为行注释//和块注释/* */
行注释：//表示仅能注释一行
块注释：/* */可以注释多行，注释不能嵌套
1.2关键字
1.2.1关键字一览表
| asm | do | if | return | typedef |
| auto | double | inline | short | typeid |
| bool | dynamic_cast | int | signed | typename |
| break | else | long | sizeof | union |
| case | enum | mutable | static | unsigned |
| catch | explicit | namespace | static_cast | using |
| char | export | new | struct | virtual |
| class | extern | operator | switch | void |
| const | false | private | template | volatile |
| const_cast | float | protected | this | wchar_t |
| continue | for | public | throw | while |
| default | friend | register | true | |
| dalete | goto | reinterpret_cast | try |
1.2.2数据类型相关的关键字
char
、
short
、
int
、
long
、
float
、
double
、
struct
、
union
、
enum
、
signed
、
unsigned
、
void
1.2.3存储相关的关键字
register
、
static
、
const
、
auto
、
extern
1.2.4控制语句相关的关键字
if
、
else
、
break
、
continue
、
for
、
while
、
do
、
switch case
、
goto
、
default
1.3整型变量
1.3.1常量和变量
常量：在程序运行过程中，其值不可以改变的量
例：100 ‘a’ “hello”
整型 100，125，-100，0
实型 3.14 ， 0.125f，-3.789
字符型 ‘a’,‘b’,‘2’
字符串 “a”,“ab”，“1232”变量：其值可以改变的量被称为变量
int a=100;
a=101;1.3.2整型常量
二进制：是以
0b
开头，如
0b00001010
十进制：
以正常数字
1-9
开头，如
457 789
八进制：
以数字
0
开头，如
0123
十六进制：以
0x
开头，如
0x1e
a=10
，
b=11,c=12, d=13,e=14,f=15
注意：
c++
不直接支持二进制的输入输出
,bitset<8>(0b00001010)
cout<<0b00001010<<endl;//结果为10 cout默认输出为十进制
cout<<bitset<8>(0b00001010)<<endl;//结果为二进制形式00001010
注意:需要包含头文件#include<bitset>才能使用bitset
cout
默认是将数据以十进制输出，如果需要将数据以八进制、十六进制输出需要加上
oct
、
hex
cout<<0123<<endl;//结果为83 默认以十进制输出
cout<<oct<<0123<<endl;//结果为八进制0123
cout<<0xab<<endl;//结果为171 默认以十进制输出
cout<<hex<<0xab<<endl;//结果为十六进制0xab1.3.3整型变量的定义
变量的定义形式：类型名 变量名
;
int data;
data
为变量名
它的类型为
int
类型
在
32
位平台占
4
字节空间
变量名的命名规则
：由字母、数值、下划线
(_)
组成，不能由数值开头，不可以是关键字，区分大小写。
C++
对于名称的长度没有限制，名称中所有的字符都有意义，但有些平台有长度限制。
注意：
定义变量的时候 系统会为变量开辟空间，空间大小为该变量类型的大小
变量名代表空间的内容（对变量名的操作等价于对空间的操作）
如果定义短整型变量 就是
short data; //data
占
2
字节
如果定义长整型变量 就是
long data;//32
位平台
data
占
4
字节
1.3.4整型变量的初始化
变量的初始化：在变量定义的时候，给变量赋值 叫初始化
int num = 10;//是初始化
int data;
data=10;//不是初始化 仅仅是给data赋值
全部变量如果不初始化内容为
0
局部变量如果不初始化内容为不确定（随机）
int data=0;变量一般建议初始化为0
1.3.5整型变量的使用
变量的使用：读（取值）
写（赋值）
int num = 0;
num=100;//写操作
int data = 0;
data = num;//num读 data写
cout<<data<<endl;//读操作
data++;//data = data+1; 等号右边的data读 等号左边的data写
变量的声明：对变量名以及类型 提前说明，不会为该变量开辟空间。
场景：先使用变量
后定义变量
必须事先对该变量进行声明
//提前：变量声明 需要加extern修饰
extern int data;
void test03()
{
//先使用
cout<<"data="<<data<<endl;
}
//后定义
int data = 0;
变量的定义、变量的声明、变量的使用 三者关系
变量的定义：创建变量名 系统会为变量开辟空间
变量的声明：对变量的类型和名称 事先说明，不会为变量创建空间
变量的使用：对已经存在的变量的读写操作
1.3.6键盘给变量赋值
使用关键字cin给变量获取键输入，cin代表的输入设备
int data = 0;
cin>>data;//data获取键盘输入
注意：cin与>>结合 而 cout与<<结合
同时给多个变量获取键盘输入
(
每个变量的值 以空格隔开
)
int data = 0;
int num = 0;
cin>>data>>num;
cin
可以自动跳过空格以及回车。
1.4字符类型
另一种整型：
char
类型。顾名思义，
char
类型是专为存储字符（ 如字母和数字）而 设计的。现在，存储数字对于计算机来说算不 什么，但 存储字母则是另一回事。编程语言通过使用字母的数值编码解决了这个问题。因此，char
类型是另一种整型。它足够长，能够表示目标 计算机系统中的所有基本符号
—
所有的字母、数字、标点符号等。实际上，很多系统支持的字符都不超过128
个，因此用一个字节就可以表示所有的符号。因此，虽然 char
最常被用来处理字符，但也可以将它用做比
short
更小的整型。
下图为：
ASCII
表
1.4.1字符常量
字符常量：用单引号括起来，如：
'a'
、
'b'
、
’0’
等。注意单引号只能作用于一个字符（转义字符除外）
输出字符和字符的
ASCII
值的方式：
cout<<'a'<<endl;//输出的是字符
cout<<(int)'a'<<endl;//输出的是字符的ASCII值1.4.2字符变量
用
char
定义，每个字符变量被分配一个字节的内存空间字符值以
ASCII
码的形式存放在变量的内存单元中。
char ch;
注：
ch= 'x';
ch
变量中存放的是字符
'x'
的
ASCII :120,
即
ch=120
跟
ch='x'
在本质上是一致的
.
字符变量的初始化
char ch='\0';
注意：
'\0'
和
‘0’
、数值
0
的区别
‘\0’
字符常量（
char
）
ASCII
为
0
数值
0
是整型常量
(int)
内存的存储值
0
'0'
字符常量（
char
）
ASCII
为
48
1.4.3键盘给字符变量赋值
char ch='\0';
cin>>ch;
//cin会判断ch的类型为char 一次只能获取一个字符
//cin会跳过起始的空格和回车1.4.4字符案例—大小写转换
需求：键盘输入一个字符 如果是大写就改成小写 如果是小写就改成大写 其他字符不转换
'a' 97 'b' 98 'c' 99 ...... 'z' 122
'A' 65 'B' 66 'c' 67 ...... 'Z' 90
char ch = 'a';
ch = ch-('a'-'A');
char ch = 'A';
ch = ch+('a'-'A');2.4.5 字符常量和字符串常量的区别
字符串常量
是由双引号括起来的字符序列，如
“CHINA”
、
”
哈哈哈
”
“C program”
，
“$12.5”
等都是合法的字符串常量
.
字符串常量与字符常量的不同
‘a’
为字符常量，
”a”
为字符串常量
每个字符串的结尾，编译器会自动的添加一个结束标志位
'\0'
，
即
“a”
包含两个字符
‘a’
和
’\0’
1.5 实型（浮点数）
浮点数能够表示带小数部分的数值，如：
2.5 3.14 122.22.
计算机将这样的值分成两部分存储。一部分表示值，另一 部分用于对值进行放大或缩小。如数值
34.1245
可以看成
0.341245
（基准值）和
100
（缩放因子）。缩放因子的作用是移动小数点 的位置，术语浮点因此而得名。
C++
内部表示浮点数的方法与此相同，只不过它基于的是二进制数，因此缩放因子是
2
的幂，不是
10
的幂。幸运的是，程序员不必详细 了解内部表示。重要的是，浮点数能够表示小数值、非常大和非常小的
值，它们的内部表示方法与整数有天壤之别。
实型分为：单精度浮点数（
float 4
字节） 是双精度浮点数（
double 8
字节）
1.5.1 实型常量
不以
f
结尾的实型常量为
double
类型 如：
3.14
以
f
结尾的实型常量为
float
类型 如：
3.14f
指数形式：
123e3
代表
123*10
的三次方
123e-3
1.5.2 实型变量
单精度实型变量：
float f;
占
4
字节
以
f
结尾的实型常量初始化
float f=0.0f;
双精度实型变量：
double d;
占
8
字节 不以
f
结尾的实型常量初始化
double d=0.0;1.6 有符号数和无符号数
1.6.1 有符号数
数据二进制的最高位为符号位
其他位为数据位。
最高位为
1
表示负数
最高位为
0
表示正数
以一字节为例：
xddd dddd
1111 1111~1000 0000~0000 0000~0111 1111
-127 ~-0 ~+0 ~+127
将
-0
看成
-128
-128~127
1.6.2 无符号数
没有符号位 所有二进制位都是数据位
0000 0000 ~1111 1111
0 ~ 255
1.6.3 定义有符号变量
//方式一：默认方式(推荐)
int num;//num为有符号数
//方式二：使用关键字signed显示说明
signed int num;1.6.4定义无符号变量
unsigned int num;1.7进制间的转换
1.7.1 进制的概述
二进制：
0~1
以
0b
开头
bitset<8>
输出
八进制：
0~7
以
0
开头
0123 oct
输出
十进制：
0~9 123 cout
默认输出十进制
十六进制：
0~9 a~f
以
0x
开头
0x12 hex
输出
不区分正负数
n
进制：
0~n-1
1.7.2 十进制转二进制、八进制、十六进制（短除法）
案例
1
：
123
转成二进制
0b0111 1011
案例
2
：
123
转成八进制
0173
案例
3
：
123
转成十六进制
0x7b
1.7.3 二进制、八进制、十六进制转十进制（位次幂）
案例
1
：将二进制数
1100 0011
转换成十进制
1
2^7+1
2^6+1
2^1+1
2^0=195
案例
2
：将
0123
转换成十进制
--->83
案例
3
：将
0x12
转换成十进制
--->18
1.7.4 二进制转八进制
从右往左：每
3
位二进制 对应
1
位八进制
1101 1010 ---->0332
11 011 010
3 3 2
1.7.5 二进制转十六进制
从右往左：每
4
位二进制 对应
1
位十六进制
1101 1010 ---->0xda
1101 1010
d a
0x123456-->
占
3
字节
1.7.6 八进制 转 二进制
1
位八进制
对应
3
位二进制
0123---> 001 010 011
1.7.7 十六进制 转 二进制
1
位十六进制
对应
4
位二进制
0x1d3c--->0001 1101 0011 1100
1.7.8 八进制 转 十六进制（没有直接方式）
八进制
---->
二进制
---->
十六进制
1.7.9 十六进制 转 八进制（没有直接方式）
十六进制
---->
二进制
---->
八进制
案例：
0x123---->(
八进制
)0443
注意：不同的进制 仅仅是数据的不同表现形式而已
1.8 原码、反码、补码
1.8.1 原码、反码、补码的概述
计算机存储的是数据的补码。
原码：计算机中对数字的二进制定点表示方法
123:
原码
0111 1011
无符号数：
补码
==
反码
==
原码
123
原码：
0111 1011
123
反码：
0111 1011
123
补码：
0111 1011
有符号数：
正数：
补码
==
反码
==
原码
+123
原码：
0111 1011
+123
反码：
0111 1011
+123
补码：
0111 1011
负数：
反码
==
原码符号位不变 其他位按位取反。
补码
==
反码
+1
-123
原码：
1111 1011
-123
反码：
1000 0100
-123
补码：
1000 0101
负数在计算机以
补码
的方式存储
非负数在计算机以
原码
的方式存储
1.8.2 补码的意义
1
、统一了
0
的编码
+0补码：0000 0000
-0补码：0000 0000
2
、将减法运算变加法运算
假如：没有补码
10-6
10: 0000 1010
-6：1000 0110
-------------------
1001 0000---->-16结果有问题
有补码
10-6
10: 0000 1010
-6：1111 1010
-------------------
0000 0100---->41.8.3 对数据的存
负数在计算机以补码的方式存储
非负数在计算机以原码的方式存储
八进制数 以原码存储
十六进制 以原码存储
short data1 = -10;//补码存储
cout<<bitset<16>(data1)<<endl;//1111111111110110
short data2 = 6;//原码存储
cout<<bitset<16>(data2)<<endl;//0000000000000110
short data3 = 0x8080;//原码存储
cout<<bitset<16>(data3)<<endl;//10000000100000001.8.4 对数据的取
如果是对 无符号变量 进行取值，输出内存的原样数据。
//先将-10转成无符号数（-10的补码）
unsigned short data = -10;//原码1000 0000 0000 1010 补码1111 1111 1111 0110
cout<<bitset<16>(data)<<endl;//1111 1111 1111 0110
cout<<"data="<<data<<endl;//65526==1111 1111 1111 0110
如果是对 有符号变量 进行取值，系统会去看内存的最高位，如果最高位为
0
表明正数， 内存原样 输出。
short data = 10;//原码0000 0000 0000 1010
cout<<bitset<16>(data)<<endl;//0000 0000 0000 1010
cout<<"data="<<data<<endl;//10
系统会去看内存的最高位，如果最高位为
1
表明负数， 将内存数据求补码（得到原码） 输出
short data=0x8080;//1000 0000 1000 0000
cout<<bitset<16>(data)<<endl;//1000 0000 1000 0000
cout<<"data="<<data<<endl;//-32640 =1111 1111 1000 00001.9 其他关键字
1.9.1 const修饰普通变量
//const修饰data为只读变量 data的本质是变量
//只读变量 只能被初始化 不能被赋值
const int data=100;
data = 10;//err
如果以
常量
初始化
const
修饰的只读变量那么只读变量的值事先存放在
“
符号常量表中
”
不会立即给
data开辟空间
当对
data
取地址
时
系统才会为
data
开辟空间
const int data=100;
int *p = (int *)&data;
*p = 2000;
cout<<"*p = "<<*p<<endl;//2000
cout<<"data = "<<data<<endl;//100
如果以
变量
初始化
const
修饰的只读只读变量
那么只读变量会立即开辟空间（没有符号常量表）
int a = 10;
const int data = a;//以变量初始化data
int *p = (int *)&data;
*p = 2000;
cout<<"*p = "<<*p<<endl;//2000
cout<<"data = "<<data<<endl;//2000
const
修饰
自定义类型变量
立即开辟空间 （没有符号常量表）
1.9.2 register修饰寄存器变量
如果变量 别高频繁使用
会自动将变量存储在寄存器中
目的：提高访问效率
如果用户想将变量 直接放入寄存器中 可以加
register
修饰
register int data=0;//data将放入寄存器中
//尽量不要对寄存器变量取地址
&data;
//register修饰的变量 只是尽量放入寄存器中1.9.3 volatile 关键字
强制访问内存
volatile int data=0;//对data的访问 必须冲内存访问
防止编译器优化
1.9.4 sizeof测量类型的大小
cout<<sizeof('a')<<endl;//1B
cout<<sizeof(10)<<endl;//4B
cout<<sizeof(short)<<endl;//2B
cout<<sizeof(long)<<endl;//32位平台 4B
cout<<sizeof(float)<<endl;//4B
cout<<sizeof(double)<<endl;//8B1.9.5 typedef给已有的类型重新取个别名
不能创建新类型。
将长且复杂的类型名 取一个短小的名称。
typedef
作用的步骤：
1
、先用 已有的类型 定义一个普通的变量
2
、用别名 替换 变量名
3
、在整个表达式最前方 加
typedef
//INT32就是int类型的别名
typedef int INT32;
INT32 data;
int num;//已有的类型任然有效1.10 转义字符
1.10.1 \和某些字符 结合 产生新的字符 就叫转义字符
'\0' == ASCII 为0
'\n' == 换行符
'\t' == tab缩进符
'\r' ==回到行首符号
'\a' ==发出警报1.10.2 八进制转义
'\ddd'
每个
d
的范围必须是
0~7 3
个
d
表示最多识别
3
位八进制数据
1.10.3 十六进制转义
'\xhh'
每个
h
的范围
0~9 a~f 2
个
h
表示最多识别
2
位十六进制
1.11 类型转换
数据有不同的类型，不同类型数据之间进行混合运算时必然涉及到类型的转换问题。
转换的方法有两种：
自动转换
:
遵循一定的规则
,
由编译系统自动完成
.
强制类型转换：
把表达式的运算结果强制转换成所需的数据类型
1.11.1 自动类型转换原则
1
、占用内存字节数少
(
值域小
)
的类型，向占用内存字节数多
(
值域大
)
的类型转换
,
以保证精度不降低。
2
、转换方向
无符号和有符号 参加运算 需要将有符号 转换成无符号
int data1 = -10;
unsigned int data2 = 6;
if(data1+data2>0)
{
cout<<">0"<<endl;//结果输出
}
else
{
cout<<"<=0"<<endl;
}
int
和
double
参加运算 会将
int
转成从
double
类型
int data1 = 0;
double data2 = 0.0;
cout<<sizeof(data1+data2)<<endl;//8
char
和
short
类型 只要参加运算 都会将自己转换成
int
类型
char ch='a';
short sh=0;
cout<<sizeof(ch+ch)<<endl;//4
cout<<sizeof(sh+sh)<<endl;//4
cout<<sizeof(ch+sh)<<endl;//41.11.2 强制类型转换
类型说明符
) (
表达式
)
功能：
把表达式的运算结果强制转换成类型说明符所表示的类型
例如：
(int)p+1 对p强转成int类型 然后再+1
(int)(p+1)对p+1强转成int类型
不管是自动类型转换 还是强制类型转换 都是临时。
float f=3.14f;
int x = 0;
x = (int)f;
cout<<"x ="<<x<<", f="<<f<<endl;//x =3, f=3.14
4278
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
