/
C++基础
一、初学C++
1、第一个程序
// 头文件
#include <iostream>
//命名空间
using namespace std ;
// 主函数
int main () {
cout << "HEllO" << endl ;
return 0 ;
}
2、注释
单行注释
// 这是一行注释
多行注释
/*
这是一行注释
这也是一行注释
这又是一行注释
*/
3、变量
会变的量
变量的定义
数据类型 变量名 = 初始值
4、常量
不会变的量
#define
// 将代码中所有的 x 替换成 "你好" 以此类推
#define x "你好"
易错点
#define x 1+2
int main () {
cout << x * x ;
}
/* 输出结果为 5
而非 9
原因：
将 cout << x*x ; 中的 x 替换为 1+2
等价为 cout << 1+2*1+2 ;
而非 cout << 3*3 ; 或cout << (1+2)*(1+2) ;
*/
const 修饰符
// 定义 x 为不可修改的量
const int x = 1 ;
5、关键字
不能用作标识符
6、标识符
变量或常量的名字
由 下划线（ _ ) 、英文字母（ a ~ z 、A ~ Z ）、数字组成
严格区分大小写
例如：
a3_
_Sa89
不能是：
2ds_
二、数据类型
1、整型
| 字节数 | 表示大小 | 表示范围 | |
|---|---|---|---|
| short | 2字节 | 2^16 | -2^15 ~ 2^15-1 |
| int | 4字节 | 2^32 | -2^31 ~ 2^31-1 |
| long | 4字节 | 2^32 | -2^31 ~ 2^31-1 |
| long long | 8字节 | 2^64 | -2^63 ~ 2^63-1 |
数值溢出
short a = 32768 ; // 输出结果为 -32768
2、sizeof 关键字
获取一个数据类型或者一个量所占字节数
int a;
sizeof(short) ; // 输出2
sizeof(a) ; // 输出4
3、浮点型（实型）
| 字节数 | 精度 | |
|---|---|---|
| float | 4字节 | 低 |
| double | 8字节 | 高 |
浮点数判断相等
因为浮点数有误差,所以不能直接用 ==来判相等
例如: x == 1
#include <cmath>
#define eps 1e-7
double x ;
if (fabs(x-1) < eps) { // fsbs 取绝对值
}
4、字符型
char a = 'x' ; // 字符用单引号括起来
占用字节数为 1
ASCLL码
字符以整型存储在内存中，本质上是一个数值，每一个字符对应一个 ASCLL码
转义字符
简单来说就是在一些字符前加 “ \ ” 使它具有其他意义
5、字符串
// c风格
char 变量名[] = "字符串常量" ; // 实际为 "字符串常量\0"
char a[] = "hello" ; // 输出为 hello
sizeof(a) ; // 输出为 6
// c++风格
#include <cstring>
string b = "world" ; // 输出为 world
cout << b + ";" ; // 输出为 world;
6、布尔类型
bool flag1 = true ; // 1
bool flag2 = false ; // 0
cout << flag1 ; // 输出为 整数1
占用字节数 1
7、数据的输入
整型的输入
int a ;
cin >> a ;
浮点型的输入
double b ;
cin >> b ;
字符型的输入
char c ;
cin >> c ;
字符串的输入
#include <string>
string d ;
cin >> d ;
布尔型的输入
bool e ;
cin >> e;
三、运算符
1、加减乘除运算符
int a = 1 , b = 1 ;
a + b ; // 2
a - b ; // 0
a * b ; // 1
a / b ; // 1
2、取模运算符（取余）
取模符号与被除数一致
int a = 100 , b = 9 ;
a % b ; // 1
3、递增递减运算符
int i = 1 ;
i++ ; // i = i + 1 ;
++i ; // i = i + 1 ;
int x = i++ ; // 1 先把值给到x,再递增
int y = ++i ; // 2 先递增，再把值给到y（效率稍高）
4、赋值运算符
int x = 1 ;
int y = 2 ;
x = y ; // 将 y 的值赋值给 x
x += y ; // x = x + y （加减乘除取模都适用）
5、比较运算符
输出为布尔值
| 符号 | 意义 |
|---|---|
| == | 等于 |
| != | 不等于 |
| > | 大于 |
| < | 小于 |
| >= | 大于等于 |
| <= | 小于等于 |
int a = 1 ;
int b = 2 ;
cout << (a == b) ; //输出为 0
6、逻辑运算符
输出为布尔值
| 符号 | 意义 |
|---|---|
| && | 逻辑与（有假必假） |
| || | 逻辑或（有真必真） |
| ! | 逻辑非 |
7、逗号运算符
输出值为逗号表达式最右边的值
注意：逗号运算符优先级非常低
int a(1), b(2), c(3);
cout << (a, b, c); // 3
8、位运算符
| 符号 | 意义 |
|---|---|
| & | 位与（有0必0） |
| | | 位或（有1必1） |
| ^ | 异或 |
| ~ | 按位取反 |
| << | 左移运算 |
| >> | 右移运算 |
位与
int a = 0b1010; // 10 二进制数前加 0b 表示二进制
int b = 0b0110; // 6
// 0b0010 // 2
cout << (a & b); // 2
位或
int a = 0b1010; // 10
int b = 0b0110; // 6
// 0b1110 // 14
cout << (a | b) // 14
异或
相同为0，不同为1
int a = 0b1010; // 10
int b = 0b0110; // 6
// 0b1100 //12
cout << (a ^ b)； //12
按位取反
int a = 0b1;
/*
int类型占四个字节，也就是32位,即
a = 0b00000000000000000000000000000001
*/
int b = (~a);
/*
a = 0b00000000000000000000000000000001
b = 0b11111111111111111111111111111110
*/
左移运算
int a = 0b11; // 3
a = (a << 1); // 将a左移一位，
// 0b110 // 6
cout << a； // 6
x << y; // 将x左移y位
数值计算：
x << y
x = x * 2 ^ y
右移运算
// 1、正数的右移
int a = 0b111; // 7
a = (a >> 1); // 将a右移一位，
// 0b011 // 3
cout << a； // 3
x >> y; // 将x右移y位
数值计算：
x >> y
x = x / 2 ^ y
四、程序控制流程结构
1、if else语句
if (表达式) // 如果表达式成立，执行语句1
语句1
else // 如果表达式不成立，执行语句2
语句2
2、else if语句
if (表达式1) // 哪个表达式成立就执行那个语句，都不成立则执行语句4
语句1
else if (表达式2)
语句2
else if (表达式3)
语句3
......
else
语句4
3、条件运算符
表达式1 ？表达式2 ：表达式3；
// 如果表达式1为真，则执行表达式2，返回值为表达式2的值
// 如果表达式1为假，则执行表达式3，返回值为表达式3的值
4、switch语句
switch (表达式) {
case 整型常量1：
语句1
break；
case 整型常量2：
语句2
break；
case 整型常量3：
语句3
break；
default:
语句4
}
语句中必须加 break，若不加 break ，发生以下情况
int n = 1;
switch (n) {
case 0:
cout << "零"；
case 1:
cout << "一"；
case 2:
cout << "二"；
default:
cout << "不知道"；
}
//运行结果为：一二不知道
5、while语句
while(表达式){ //如果表达式为真，则执行语句1
语句1
}
6、do…while语句
do{ // 至少执行一次语句1
语句1
}while (表达式)；
7、for循环
for (表达式1 ；表达式2 ；表达式3) {
语句1
}
8、break
跳出循环
while (表达式1) {
语句1；
break；
}
9、continue
跳出本次循环
while (表达式1) {
语句1；
continue；
语句2;
}
五、数组
1、 一维数组
一维数组的定义
数据类型 数组名[数字/常量表达式]
数组内所有元素类型相同
数组名为变量名，不能同名，且满足标识符规则
数组下标是从 [0] 开始
括号内不能为变量，如 int a = 10;
int b[n];
一维数组的初始化
int a[10] = {0};
// 0 0 0 0 0 0 0 0 0 0
int a[10] = {1,2,3,4,5};
// 1 2 3 4 5 0 0 0 0 0
##### 数组的访问
数组名[下标] // 下标从 0 开始
2、二维数组
##### 二维数组的定义
数据类型 数组名[行][列]
二维数组的初始化
int a[3][3] = {0};
/* 0 0 0
0 0 0
0 0 0 */
int a [3][3] = {{1,2},{0},{3}};
/* 1 2 0
0 0 0
3 0 0 */
数组名代表数组元素的首地址
六、函数
1、函数的定义
返回值类型 函数名 (参数列表) {
函数体
return 表达式； // 返回值
}
// 定义一个加法函数
int add (int a , int b) {
int c = a + b;
return c;
}
2、函数的调用
#include <iostream>
using namespace std;
// add函数的定义
int add (int a , int b) {
int c = a + b;
return c;
}
int main () {
int a = 1;
int b = 2;
int c = add (a , b); // 调用add函数
cout << c << endl;
return 0;
}
3、函数的值传递
#include <iostream>
using namespace std;
// 定义一个函数
void function (int num) {
//改变num的值
num = 100;
}
int main () {
int number;
number = 1;
function (number); // 将number的值传递给num
cout << number << endl; // 1 number的值未改变
return 0;
}
这样的值传递只能把一个函数中的值传递给另一个函数，当该值在被调函数中发生改变时，在原来的函数中并不会发生改变。
4、 函数的声明
#include <iostream>
using namespace std;
int add (int a , int b); // 函数的声明
//int add (int ,int); // 也可以这样写
int main () {
int a = 1;
int b = 2;
int c = add (a , b); // 调用add函数
cout << c << endl;
return 0;
}
int add (int a , int b) { // add函数的定义
int c = a + b;
return c;
}
七、指针
1、指针和地址
一般数据类型
int a = 1;
int b = 2;
int c = 3;
| 内存地址 | 0x00000000 | 0x00000001 | 0x00000002 |
|---|---|---|---|
| 变量值 | 1 | 2 | 3 |
| 变量名 | a | b | c |
指针数据类型
int *Pa = &a;
int *Pb = &b;
int *Pc = &c;
| 内存地址 | 0x00000003 | 0x00000004 | 0x00000005 |
|---|---|---|---|
| 变量值 | 0x00000000 | 0x00000001 | 0x00000002 |
| 变量名 | pa | pb | pc |
2、指针的定义
数据类型 *指针变量名;
int *p;
*p = &a; // &a 对a取地址
*p = &b; // 指针可多次赋值
3、解引用
*指针变量名 = 数值;
*pa = 7 // 等同于 a = 7
4、 * 和 & 的关系
* 与 & 互逆
*&a = *(&a) = *pa = a
&*pa = &(*pa) = &a = pa
5、指针的内存
只跟操作系统有关：
在32位操作习题中占用4个字节
在64位操作习题中占用8个字节
6、空指针和野指针
空指针不指向任何实际的对象或者函数
int *p = NULL; // 空指针 无法解应用
野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）
int *p = (int *)0x1232423 // 指向一个垃圾内存
八、结构体
1、结构体的定义
struct 结构体名 { 结构体成员变量列表 }；
// 定义一个结构体
struct Book {
string name;
double price;
}；
// 1、创建结构体
Book c;
c.name = "c语言程序设计"；
c.price = 39.99;
cout << c.name << ' ' << C.price << endl; // c语言程序设计 39.99
// 2、通过初始化列表创建结构体
Book c = {"c语言程序设计" , 39.99};
cout << c.name << ' ' << C.price << endl; // c语言程序设计 39.99
// 3、在定义时直接创建
struct Book {
string name;
double price;
}c；
c.name = "c语言程序设计"；
c.price = 39.99;
cout << c.name << ' ' << C.price << endl; // c语言程序设计 39.99
2、结构体数组
结构体名 结构体变量名[元素个数] = { {} , {} , {} , ...}
//创建一个结构体数组
Book books[3] = {
{"c语言程序设计" , 39.99},
{"Python程序设计" ，9.99}，
{"C++程序设计" ， 99.99}
}；
3、结构体指针
Book c = {"c语言程序设计" , 39.99};
Book *p = &c;
p -> name = "c++"; // 指针访问用 "->" 代替 "."
cout << c.name << ' ' << C.price << endl; // c++ 39.99
77
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
