C++基础入门
1、变量和常量
变量和常量
变量：数据类型 变量名 = 值
常量：
-
宏常量：#define 常量名 值，通常定义在文件上方
#define Day 7 -
const关键字修饰的变量：const 数据类型 常量名 = 值
const int mouth = 12
变量和常量命名规则
- 不能是关键字
- 只能由字母，数字，下划线组成
- 第一个字符必须为字母或下划线
- 命名中字母区分大小写
2、关键字
关键字
3、数据类型
整数类型：short，int，long，long long，区别在于占用内存空间不同
sizeof关键字：统计数据类型或变量占内存的大小（多少字节）
endl：end of line缩写
long a = 100;
cout << sizeof(a) << endl; // 4
cout << sizeof(long) << endl; // 4
浮点型：单精度 float，双精度 double，区别在于有效数字范围不同，默认情况下都显示6位
float f1 = 3.14f; // 不写f默认为double
double d1 = 3.14;
# 科学计数法
float e1 = 3e2; // 3 * 10^2
float e2 = 3e-2; // 3 * 10^-2
字符型：char（一个字节）
- 字符用单引号括起来
- 单引号内只能有一个字符
- 字符型变量存储在内存中的不是字符本身，是字符对应的ASCll编码
char ch = 'a';
转义字符：
\n：换行\\：反斜杠\t：制表符，整齐输出制表符后面的数据
int main()
{
cout << "hello \nworld" << endl;
cout << "\\" << endl;
cout << "aaaa\tbbbbb" << endl;
cout << "aa\tbbbbb" << endl;
cout << "aaaaaa\tbbbbb" << endl;
//system("pause"): 让程序暂停一下，然后按任意键继续，初学时最多见于程序的末尾处，用于看运行结果，避免程序一闪而过
system("pause");
return 0;
}
字符串型：string
//c 写法
char str[] = "hello world";
// c++ 写法
string str1 = "hello world";
布尔类型：True（1），False（0），占一字节内存
bool flag = false;
bool flag1 = true;
数据的输入输出
cin表示标准输入、cout表示标准输出
使用输入输出时，需要包含头文件iostream
int a = 0;
cin >> a;
cout << "a =" << a << endl;
运算符
算术运算符：
赋值运算符：
比较运算符：
逻辑运算符：
4、流程控制
选择结构
单行 if：
int age = 10;
if (age < 18)
{
cout << "未成年，请在家长的陪同下观看！" << endl;
}
多行 if：
int age = 10;
if (age < 18)
{
cout << "未成年，请在家长的陪同下观看！" << endl;
}
else
{
cout << "点击播放" << endl;
}
多条件 if：
int age = 0;
cout << "请输入年龄：" << endl;
cin >> age;
if (age < 18 && age > 0)
{
cout << "未成年" << endl;
}
else if(age >= 18 && age < 35)
{
cout << "年轻人" << endl;
}
else if (age >= 35 && age < 50)
{
cout << "中年人" << endl;
}
else if (age >= 50 && age < 120)
{
cout << "老年人" << endl;
}
else
{
cout << "不是人" << endl;
}
嵌套 if：
int a = 100;
int b = 200;
// 如果条件为真，则进入判断
if (a == 100)
{
// 如果条件为真，则输出下面的语句
if (b == 200)
{
cout << "a 的值是 100，且 b 的值是 200" << endl;
}
}
三目运算符：
int a = 10;
int b = 20;
int c = 0;
c = a > b ? a : b;
// 20
cout << c << endl;
switch 判断语句：
char level = NULL;
cout << "请输入等级：" << endl;
cin >> level;
switch (level)
{
case 'D':
cout << "等级D" << endl;
break;
case 'C':
cout << "等级C" << endl;
break;
case 'B':
cout << "等级B" << endl;
break;
case 'A':
cout << "等级A" << endl;
break;
case 'S':
cout << "等级S" << endl;
break;
// default：在case 都不匹配时执行
default:
cout << "无等级" << endl;
}
while 循环：
int a = 10;
while (a < 16)
{
cout << "a = " << a << endl;
a++;
}
do while 循环：输出所有的“水仙花数
水仙花数：一个三位数其各位数字的立方和等于该数本身，例如153是“水仙花数”，因为：153 = 1^3 + 5^3 + 3^3
#include<iostream>
using namespace std;
#include<cmath>
int main()
{
int num = 100;
do
{
int a = pow(num % 10, 3); //num对10取余拿到num的个位数
int b = pow(num / 10 % 10, 3);//num除10再对10取余拿到num的十位数
int c = pow(num / 100, 3);//num除100拿到num的百位数
if (a + b + c == num)
{
cout << num << endl;
}
num++;
} while (num < 1000);
system("pause");
return 0;
}
运行结果：153 370 371 407
for 循环
敲桌子：在一个1-100循环报数中，当数字是7的倍数或个位是7或十位是7，输出敲桌子来替代数字原有的值输出
#include<iostream>
using namespace std;
int main()
{
for (int a = 1;a<=100;a++)
{
if (a % 7 == 0 || a % 10 == 7 || a / 10 == 7) {
cout << a << "敲桌子" << endl;
}
}
system("pause");
return 0;
}
嵌套循环
乘法口诀表：
#include<iostream>
using namespace std;
int main()
{
//九九乘法表
for (int i = 1;i<10;i++)
{
for (int j = 1; j <= i; j++)
{
cout << j << "*" << i <<"="<< i * j << " ";
}
cout << "\n";
}
system("pause");
return 0;
}
break和continue的区别
break退出整个循环，
continue退出本次循环，执行下一次循环
5、数组
一维数组
定义一维数组：
int arr1[] = { 1,2,3,4,5,6 }
int arr1[] = { 1,2,3,4,5 };
cout << sizeof(arr1) << endl;// 数组内存 20
cout << arr1 << endl;//数组首地址
冒泡排序：
int arr[] = { 24,3,156,34,324,256,76,87 };
int temp = 0;
for (int i = size(arr)-1; i >0 ; i--)
{
for (int j = 0; j < i; j++)
{
if (arr[j]< arr[j + 1]) {
temp = arr[j + 1];
arr[j + 1] = arr[j];
arr[j] = temp;
}
}
}
二维数组
//定义
int arr[3][4] = {
{10,10,10,10},
{60,70,80,80},
{50,90,10,10}
};
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 4; j++)
{
cout << arr[i][j] << " ";
}
cout << endl;
}
6、函数
函数定义和调用
#include<iostream>
using namespace std;
// 函数声明
int maxNum(int num1, int num2);
// 函数定义，形参num1，num2
int maxNum(int num1, int num2)
{
return num1 > num2 ? num1 : num2;
}
int main()
{
//调用函数，实参10，20
int num = maxNum(10, 20);//值传递
cout << num << endl;
system("pause");
return 0;
}
函数的声明：
-
由于编译器是一条一条执行的，如果自定义函数在main()函数之后，我们又不加上声明，则会报错，无法找到自定义函数。
-
如果把自定义函数写在调用它的函数之后，则需在调用之前，声明一下自定义函数。
-
声明可以多次，而定义只能一次。
函数的分文件书写，让代码结构更清晰
创建后缀名为.h的头文件，用来写函数的声明；
创建后缀名为.cpp的源文件，用来定义函数。
7、指针
指针是一个变量，其值为另一个变量的地址
定义指针
数据类型 * 指针变量名
int a = 10;
//定义指针
int * p;
//让指针p指向a，记录变量a的地址，
p = &a;
cout << &a << endl;
cout << p << endl;
00000096B58FF924
00000096B58FF924
使用指针
通过使用解引用的方式找到指针指向的内存，然后操作内存中的值
int a = 10;
//定义指针
int * p;
//让指针p指向a，记录变量a的地址，
p = &a;
//解引用 *p,获得内存中的值
cout << *p << endl;
//修改指针指向的内存中的值
*p = 100;
cout << *p << endl;
cout << a << endl;
10
100
100
指针占用的内存
在32位操作系统中，指针占4个字节，不论什么类型
在64位操作系统中，指针占8个字节，不论什么类型
空指针，野指针
空指针：
-
空指针指向内存中编号为0的空间
-
用途：初始化指针变量
-
注意：空指针是不可以访问的
野指针：
- 指针变量指向非法的内存空间
- 不可操作，操作会报错
const修饰
常量指针：const修饰指针 const int * p = &a;
-
指针的指向可以修改
-
指针指向的内存值不可修改
int a = 10;
int b = 30;
//定义指针
int * p;
//常量指针
const int * p = &a;
//修改指向的内存值为30，不允许
*p = 30;
//修改为指向变量b的地址，允许
p = &b;
指针常量：const修饰常量 int * const p = &a;
-
指针的指向不可以修改
-
指针指向的内存值可修改
int a = 10;
int b = 30;
//定义指针
int * p;
// 指针常量
int * const p = &a;
//修改指针指向的内存值，允许
*p = 30;
//修改指针指向变量b，不允许
p = &b;
const既修饰指针，又修饰常量：
const int * const p = &a;
- 指针的指向和指针指向的内存值都不可以修改
指针访问数组元素
int arr[] = { 1,2,3,4,5,6,7,8,9 };
int* p = arr;//指针指向数组首地址
//利用指针遍历数组
for (int i = 0; i < size(arr); i++)
{
cout << *p << endl;
p++;
}
地址传递
#include<iostream>
using namespace std;
void swap(int * p1, int * p2)
{
int temp = * p1;
* p1 = * p2;
* p2 = temp;
}
int main()
{
int a = 10;
int b = 20;
//把变量a和b的地址交换
swap(&a, &b);
cout << a << endl;
cout << b << endl;
system("pause");
return 0;
}
指针，数组，函数使用实例：
#include<iostream>
using namespace std;
/*
参数1 数组的首地址
参数2 数组的长度
*/
void bubbleSort(int * arr, int len)
{
for (int i = 0; i < len-1; i++)
{
for (int j = 0; j < len-i-1; j++)
{
if (arr[j]>arr[j+1])
{
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
/*
参数1 数组
参数2 数组的长度
*/
void bubbleSort1(int arr[], int len)
{
for (int i = 0; i < len - 1; i++)
{
for (int j = 0; j < len - i - 1; j++)
{
if (arr[j] > arr[j + 1])
{
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
int main()
{
int arr[] = { 2,1,6,9,3,5,0,8 };
//bubbleSort(arr, size(arr));
bubbleSort1(arr, size(arr));
for (int i = 0; i < len; i++)
{
cout << arr[i] << endl;
}
system("pause");
return 0;
}
8、结构体
结构体属于用户自定义的数据类型，允许用户存储不同的数据类型。
结构体定义
struct 结构体名{ 结构体成员列表 }
//定义结构体
struct Studrnt
{
string name;
int age;
string sex;
};
创建结构体对象
#include<iostream>
using namespace std;
//定义结构体
struct Student
{
string name;
int age;
string sex;
}s3;//方式三：定义结构体时创建
int main()
{
//方式一：创建结构体对象时struct可以省略
Student s1;
s1.name = "方唐镜";
s1.age = 18;
s1.sex = "男";
//方式二：
struct Student s2 = { "王五",23,"男"};
s3.name = "神明";
s3.age = 28;
s3.sex = "男";
cout << "学生姓名:" << s1.name << " 年龄：" << s1.age << " 性别：" << s1.sex << endl;
cout << "学生姓名:" << s2.name << " 年龄：" << s2.age << " 性别：" << s2.sex << endl;
cout << "学生姓名:" << s3.name << " 年龄：" << s3.age << " 性别：" << s3.sex << endl;
system("pause");
return 0;
}
结构体数组
将结构体放在数组中，便于管理
//定义结构体
struct Student
{
string name;
int age;
string sex;
};
int main()
{
//创建结构体数组
struct Student stuArr[3] = {
{"张三",24,"男"},
{"李四",23,"男"} ,
{"王五",84,"男"}
};
//改结构体数组的元素
stuArr[2].name = "赵六";
stuArr[2].age = 30;
stuArr[2].sex = "男";
for (int i = 0; i < 3; i++)
{
cout << "姓名：" << stuArr[i].name << "年龄:" << stuArr[i].age << "性别:" << stuArr[i].sex << endl;
}
system("pause");
return 0;
}
结构体指针
通过结构体指针访问结构体属性，需要利用->
//定义结构体
struct Student
{
string name;
int age;
int score;
};
int main()
{
Student stu = { "王五",84,100 };
//通过指针指向结构体对象
Student * p = &stu;
//通过结构体指针访问结构体属性
cout << "姓名：" << p->name << " 年龄 " << p->age << " 分数 " << p->score << endl;
system("pause");
return 0;
}
结构体嵌套
结构体里的属性包含一个或多个结构体
//定义结构体
struct Student
{
string name;
int age;
int score;
};
struct Teacher {
int id;
string name;
int age;
struct Student stu;
};
int main()
{
Teacher t;
t.id = 10000;
t.name = "老王";
t.age = 60;
Student s1 = { "王五",84,100 };
t.stu = s1;
cout << "老师id " << t.id << " 老师姓名 " << t.name << " 老师年龄 " << t.age <<
" 学生姓名: " << t.stu.name << " 学生年龄 " << t.stu.age
<< " 学生成绩 " << t.stu.score << endl;
system("pause");
return 0;
}
结构体做函数参数
值传递，地址传递
//定义结构体
struct Student
{
string name;
int age;
int score;
};
//打印学生信息的函数1
void printlnStu1(struct Student s1) {
s1.score = 100;
cout << " printlnStu1学生姓名: " << s1.name << " 学生年龄 " << s1.age
<< " 学生成绩 " << s1.score << endl;
}
//打印学生信息的函数2
void printlnStu2(struct Student * p) {
p->score = 100;
cout << " printlnStu2学生姓名: " << p->name << " 学生年龄 " << p->age
<< " 学生成绩 " << p->score << endl;
}
int main()
{
//创建结构体
Student s2 = { "王五",24,88 };
//值传递，形参(s1)的值改变了（s1.score = 100;），实参(s2)的值不会变
printlnStu1(s2);
cout << " 学生姓名: " << s2.name << " 学生年龄 " << s2.age
<< " 学生成绩 " << s2.score << endl;
//地址传递，形参的值改变了（s1.score = 100;），实参的值也变
printlnStu2(&s2);
cout << " 学生姓名: " << s2.name << " 学生年龄 " << s2.age
<< " 学生成绩 " << s2.score << endl;
system("pause");
return 0;
}
结构体const使用场景
在将指针作为函数的参数时，可以添加const修饰，只可以读取地址的值，不能改数据，防止误操作。
//定义结构体
struct Student
{
string name;
int age;
int score;
};
//打印学生信息
void printlnStu(const struct Student s1) {
//s1.score = 100; 不能改数据，防止误操作
cout << " 学生姓名: " << s1.name << " 学生年龄 " << s1.age
<< " 学生成绩 " << s1.score << endl;
}
int main()
{
//创建结构体
Student s1 = { "王五",24,88 };
//地址传递,将函数中的参数改为指针，可以减少内存空间
printlnStu2(&s1);
system("pause");
return 0;
}