C++在线学习笔记
第一阶段:基础
一、环境配置
1.1.第一个程序(基本格式)
#include <iosteam>
using namespace std;
int main(){
cout<<"hello world"<<endl;
system("pause");
}
模板
#include <iosteam>
using namespace std;
#include <string.h>
int main(){
//主要功能代码区
system("pause");
}
1.2注释
1.3变量
意义:方便管理内存空间
方法:数据类型 变量名 = 数字;
#include <iosteam>
using namespace std;
int main(){
int a = 10;
cout<<"a = "<<a<<endl;
system("pause");
}
1.4常量
#include <iosteam>
using namespace std;
#def Day 7
int main(){
cout<<"一周一共有"<<Day<<endl;
system("pause");
}
1.5关键字
1.6变量命名规则
二、数据类型
目的:给数据存分配合适的空间大小;避免资源浪费
2.1整形
2.2 sizeof
int main(){
cout<<"short类型内存为:"<<sizeof(short)<<endl;
}
2.3浮点型
float占用四个字节
double占用八个字节
科学计数法
2.4字符型
注意事项:单引号;单引号里面只能放一个;ASCII值;int(char);A65;a97.
2.5转义字符
2.6字符串型
#include string
string a = “你好世界” //C++中的变量
char str[] =“Hello world” //C中的
2.7布尔数据类型
2.8数据的输入
#include <iosteam>
using namespace std;
#include <string>
int main(){
int a =0;
cout<<"请给a赋值 = "<<endl;
cin>>a;把输入的值赋值给a
cout<<"a = "<<a<<endl;
char b ='a';
cout<<"请给b赋值 = "<<endl;
cin>>a;把输入的值赋值给a
cout<<"b = "<<a<<endl;
system("pause");
}
三、运算符
3.1 算术运算符号
#include <iostream>
using namespace std;
int main() {
int num1, num2;
cout << "请输入两个整数:" << endl;
cin >> num1 >> num2;
// 加法
int sum = num1 + num2;
cout << "加法结果:" << sum << endl;
// 减法
int difference = num1 - num2;
cout << "减法结果:" << difference << endl;
// 乘法
int product = num1 * num2;
cout << "乘法结果:" << product << endl;
// 除法
if (num2 != 0) {
double quotient = static_cast<double>(num1) / static_cast<double>(num2);
cout << "除法结果:" << quotient << endl;
} else {
cout << "除数不能为0" << endl;
}
return 0;
}
3.2赋值运算符
#include <iostream>
using namespace std;
int main() {
int a = 10; // 直接赋值
cout << "a = " << a << endl;
a += 5; // 加法赋值
cout << "a = " << a << endl;
a -= 3; // 减法赋值
cout << "a = " << a << endl;
a *= 2; // 乘法赋值
cout << "a = " << a << endl;
a /= 4; // 除法赋值
cout << "a = " << a << endl;
a %= 6; // 取模赋值
cout << "a = " << a << endl;
int v = 10;
++v ;
cout<<"v = "<<v<<endl;
return 0;
}
3.3比较运算符
#include <iostream>
using namespace std;
int main() {
int a = 10, b = 20;
// 等于运算符
if (a == b) {
cout << "a等于b" << endl;
} else {
cout << "a不等于b" << endl;
}
// 不等于运算符
if (a != b) {
cout << "a不等于b" << endl;
} else {
cout << "a等于b" << endl;
}
// 大于运算符
if (a > b) {
cout << "a大于b" << endl;
} else {
cout << "a不大于b" << endl;
}
// 小于运算符
if (a < b) {
cout << "a小于b" << endl;
} else {
cout << "a不小于b" << endl;
}
// 大于等于运算符
if (a >= b) {
cout << "a大于等于b" << endl;
} else {
cout << "a小于b" << endl;
}
// 小于等于运算符
if (a <= b) {
cout << "a小于等于b" << endl;
} else {
cout << "a大于b" << endl;
}
system("pause");
return 0;
}
3.4逻辑运算
#include <iostream>
using namespace std;
int main() {
bool a = true, b = false;
// 与运算符
if (a && b) {
cout << "a和b都为真" << endl;
} else {
cout << "a和b不都为真" << endl;
}
// 或运算符
if (a || b) {
cout << "a和b至少有一个为真" << endl;
} else {
cout << "a和b都不为真" << endl;
}
// 非运算符
if (!a) {
cout << "a为假" << endl;
} else {
cout << "a为真" << endl;
}
system("pause");
return 0;
}
四、 程序流程结构
4.1顺序结构
#include <iostream>
using namespace std;
int main() {
int num = 0;
// if语句
if (num > 0) {
cout << "num大于0" << endl;
} else if (num < 0) {
cout << "num小于0" << endl;
} else {
cout << "num等于0" << endl;
}
return 0;
}
if (条件表达式) {
// 当条件表达式为真时执行的代码块
} else if (条件表达式) {
// 当第一个条件表达式为假,且当前条件表达式为真时执行的代码块
} else {
// 当所有条件表达式都为假时执行的代码块
}
别加分号
4.2选择顺序结构
#include <iostream>
using namespace std;
int main() {
int score = 0;
cout << "输入分数" << endl;
cin >> score;
cout << "您的分数为:" << score << endl;
if (score > 600) {
cout << "恭喜你考上了一本大学" << endl;
}
else if (500 < score < 600) {
cout << "恭喜你考上了二本大学" << endl;
}
else if (400 < score < 500) {
cout << "恭喜你考上了二本大学" << endl;
}
system("pause");
return 0;
}
4.2嵌套语句
案例一需求
代码实现
#include <iostream>
using namespace std;
int main() {
int score;
cout << "请输入高考考试分数: ";
cin >> score;
if (score > 600) {
cout << "考上一本" << endl;
if (score > 700) {
cout << "考入北大" << endl;
} else if (score > 650) {
cout << "考入清华" << endl;
} else if (score > 600) {
cout << "考入人大" << endl;
}
} else if (score > 500) {
cout << "考上二本" << endl;
} else if (score > 400) {
cout << "考上三本" << endl;
} else {
cout << "未考上本科" << endl;
}
return 0;
}
案例二需求----三只小猪称体重
代码实现:
#include <iostream>
using namespace std;
int main() {
int weightA, weightB, weightC;
cout << "请输入小猪A的体重:";
cin >> weightA;
cout << "请输入小猪B的体重:";
cin >> weightB;
cout << "请输入小猪C的体重:";
cin >> weightC;
if (weightA >= weightB && weightA >= weightC) {
cout << "小猪A最重" << endl;
} else if (weightB >= weightA && weightB >= weightC) {
cout << "小猪B最重" << endl;
} else {
cout << "小猪C最重" << endl;
}
return 0;
}
4.3 三目运算符:
要求
代码实现:
#include <iostream>
using namespace std;
int main() {
int weightA, weightB, weightC;
cout << "请输入小猪A的体重:";
cin >> weightA;
cout << "请输入小猪B的体重:";
cin >> weightB;
cout << "请输入小猪C的体重:";
cin >> weightC;
string heaviest = (weightA >= weightB && weightA >= weightC) ? "小猪A" : (weightB >= weightA && weightB >= weightC) ? "小猪B" : "小猪C";
cout << heaviest << "最重" << endl;
return 0;
}
注意:?是判断的意思
就是":"就是否则就的意思
4.4 switch语句
#include <iostream>
using namespace std;
int main() {
int weightA, weightB, weightC;
cout << "请输入小猪A的体重:";
cin >> weightA;
cout << "请输入小猪B的体重:";
cin >> weightB;
cout << "请输入小猪C的体重:";
cin >> weightC;
string heaviest;
if (weightA >= weightB && weightA >= weightC) {
heaviest = "小猪A";
} else if (weightB >= weightA && weightB >= weightC) {
heaviest = "小猪B";
} else {
heaviest = "小猪C";
}
switch (heaviest[0]) {
case '小':
cout << "最重的小猪是" << heaviest << endl;
break;
default:
cout << "没有找到最重的小猪" << endl;
break;
}
return 0;
}
4.5循环结构
4.5.1结构浏览
4.5.2打印数字
int main(){
int num = 0;
cout<<num<<endl;
while(num<10){
cout<<num<<endl;
num++;
}
system("puase");
}
4.5.3猜数字案例
#include <iostream>
#include <ctime>
#include <cstdlib>
int main() {
srand(time(0));
int random_num = rand() % 100 + 1;//rand() % 100生成一个0--99的树
int guess;
std::cout << "欢迎来到猜数字游戏!系统已生成一个1到100之间的随机数,请开始猜测:" << std::endl;
while (true) {
std::cin >> guess;
if (guess > random_num) {
std::cout << "猜大了,请重新输入:" << std::endl;
} else if (guess < random_num) {
std::cout << "猜小了,请重新输入:" << std::endl;
} else {
std::cout << "恭喜你猜对了!游戏结束。" << std::endl;
break;
}
}
return 0;
}
4.5.4 do while 实现
#include <iostream>
#include <ctime>
#include <cstdlib>
int main() {
srand(time(0));
int random_num = rand() % 100 + 1;
int guess;
bool isCorrect = false;
std::cout << "欢迎来到猜数字游戏!系统已生成一个1到100之间的随机数,请开始猜测:" << std::endl;
do {
std::cin >> guess;
if (guess > random_num) {
std::cout << "猜大了,请重新输入:" << std::endl;
} else if (guess < random_num) {
std::cout << "猜小了,请重新输入:" << std::endl;
} else {
std::cout << "恭喜你猜对了!游戏结束。" << std::endl;
isCorrect = true;
}
} while (!isCorrect);
return 0;
}
4.5.5水仙花数的实现
解决办法:
#include <iostream>
#include <cmath>
bool is_narcissistic_number(int num) {
int sum = 0;
int temp = num;
int n = std::to_string(num).length();
while (temp > 0) {
int digit = temp % 10;
sum += std::pow(digit, n);
temp /= 10;
}
return sum == num;
}
int main() {
for (int i = 100; i <= 999; ++i) {
if (is_narcissistic_number(i)) {
std::cout << i << " 是水仙花数" << std::endl;
}
}
return 0;
}
4.6 for循环
int main(){
for(int i = 0;i<10;i++){
cout<<"i = "<<i<<endl;
}
system("pause");
}
案例:敲桌子
思路:
代码
#include <iostream>
using namespace std;
bool contains_seven(int num) {
while (num > 0) {
if (num % 10 == 7) {
return true;
}
num /= 10;
}
return false;
}
bool is_multiple_of_seven(int num) {
return num % 7 == 0;
}
int main() {
int num;
cout << "请输入一个数字: ";
cin >> num;
if (contains_seven(num) || is_multiple_of_seven(num)) {
cout << "敲桌子" << endl;
} else {
cout << "不敲桌子" << endl;
}
return 0;
}
嵌套循环
代码实现:
乘法口诀表
代码实现:
#include <iostream>
using namespace std;
int main() {
for (int i = 1; i <= 9; ++i) {
for (int j = 1; j <= i; ++j) {
cout << j << " * " << i << " = " << i * j << "\t";
}
cout << endl;
}
return 0;
}
结果:
4.7跳转语句
break
#include <iostream>
using namespace std;
int main() {
for (int i = 0; i < 10; ++i) {
if (i == 5) {
break; // 当i等于5时跳出循环
}
cout << i << " ";
}
cout << endl;
for (int i = 0; i < 10; ++i) {
if (i % 2 == 0) {
continue; // 当i是偶数时跳过本次循环
}
cout << i << " ";
}
cout << endl;
return 0;
}
continue代码
#include <iostream>
using namespace std;
int main() {
for (int i = 0; i < 10; ++i) {
if (i % 2 == 0) {
continue; // 当i是偶数时跳过本次循环
}
cout << i << " ";
}
cout << endl;
return 0;
}
break和continue的区别:
**break用于结束整个循环,而continue用于跳过当前迭代继续执行后续迭代**。
在编程中,break
和continue
都是控制流程的关键字,它们影响循环结构的行为。以下是两者的具体区别:
- 作用范围:当在循环内部遇到
break
时,会立即退出最内层的循环,并开始执行循环之后的代码。而continue
仅跳过当前的迭代,即本次循环剩余未执行的部分,然后继续进行下一次迭代。 - 使用场景:
break
通常用于在满足某个条件时要完全终止循环的情况。例如,你可能在一个搜索算法中找到目标值后使用break
来停止搜索。continue
则用于当某次迭代不满足特定条件时,希望略过此次迭代,直接进入下一次迭代的情况。比如,在遍历一个数组时,可能需要忽略某些特定的值。
总结来说,break
和continue
虽然都可以用来控制循环结构,但它们的主要区别在于break
用于结束整个循环,而continue
用于结束当前迭代并继续执行后续的迭代。
4.8 goto语句
C++中的goto语句是一种跳转语句,用于将程序的执行流程跳转到指定的标签位置。它的语法格式如下:
goto label;
...
label: statement;
其中,label是一个用户自定义的标签,可以是一个标识符或者一个数字。当程序执行到goto语句时,它会跳转到与该标签对应的位置,并从该位置开始执行后面的语句。需要注意的是,使用goto语句可能会导致代码结构混乱,不易于维护和调试,因此在实际编程中应尽量避免使用。
#include <iostream>
using namespace std;
int main() {
int num = 0;
start: // 标签
num++;
cout << "num: " << num << endl;
if (num < 5) {
goto start; // 跳转到start标签
}
return 0;
}
五、 数组
5.1 数组的定义
数组是一组具有相同数据类型的元素的集合,这些元素在内存中连续存放,并且每个元素都可以通过下标来访问。
数组的定义通常包括以下几个要素:
- 数据类型:数组中每个元素的类型,如int、float、char等。
- 数组名:用于标识数组的变量名。
- 数组大小:可以是声明时指定的常量表达式,也可以是后续动态分配的大小。
- 初始化:可以在声明时对数组进行初始化,也可以在声明后对数组的元素逐一赋值。
- 访问:通过数组名和下标来访问或修改数组中的元素。
此外,在C语言中,数组的下标是从0开始的,所以如果有一个数组a
,那么a[0]
表示第一个元素,a[n-1]
表示最后一个元素,其中n
是数组的大小。
总的来说,数组是编程中非常基础且重要的概念,它不仅用于存储数据,还常常用于处理大量数据的情况,如数值计算、数据处理等场景。
5.2数组的操作
数组的操作主要包括以下几个方面:
- 访问数组元素:通过下标来访问数组中的元素,例如
a[0]
表示第一个元素,a[n-1]
表示最后一个元素。 - 修改数组元素:通过下标来修改数组中的元素,例如
a[0] = 10
将第一个元素的值改为10。 - 遍历数组元素:使用循环结构来遍历数组中的所有元素,例如使用for循环或while循环。
- 数组排序:对数组进行排序,可以使用内置的排序函数或者自定义的排序算法。
- 查找数组元素:在数组中查找指定的元素,可以使用线性查找、二分查找等方法。
- 动态数组:根据需要动态地增加或减少数组的大小,可以使用C语言中的realloc函数或者C++中的vector容器。
5.3代码的实现
以下是使用C语言实现数组操作的示例代码:
#include <stdio.h>
int main() {
// 定义一个整型数组,大小为5
int a[5] = {1, 2, 3, 4, 5};
// 访问数组元素
printf("a[0] = %d", a[0]); // 输出第一个元素
printf("a[4] = %d", a[4]); // 输出最后一个元素
// 修改数组元素
a[0] = 10;
printf("a[0] = %d", a[0]); // 输出修改后的第一个元素
// 遍历数组元素
for (int i = 0; i < 5; i++) {
printf("a[%d] = %d", i, a[i]);
}
// 动态增加数组大小
int *b = (int *)realloc(a, 10 * sizeof(int));
if (b != NULL) {
a = b;
for (int i = 5; i < 10; i++) {
a[i] = i + 1;
}
printf("New array: ");
for (int i = 0; i < 10; i++) {
printf("%d ", a[i]);
}
printf("");
} else {
printf("Failed to resize the array.");
}
return 0;
}
以上代码演示了如何定义、访问、修改、遍历和动态调整数组的大小。其中,realloc
函数用于重新分配内存空间,如果分配成功则返回指向新内存空间的指针,否则返回NULL。
5.4 一维数组的作用
一维数组是编程中非常基础且重要的概念,它的作用主要有以下几个方面:
-
存储数据:一维数组可以用于存储一组相同类型的数据,例如整数、浮点数、字符等。通过下标访问和修改数组元素,可以实现对数据的快速存取和修改。
-
处理大量数据:在处理大量数据时,使用一维数组可以有效地减少内存占用和提高程序运行效率。例如,在数值计算、数据处理、图像处理等领域,一维数组被广泛应用。
-
实现算法:许多算法需要使用到数组,例如排序算法、查找算法、动态规划等。一维数组作为这些算法的基础数据结构,能够方便地实现各种算法。
-
简化代码:使用一维数组可以将复杂的数据结构和操作抽象化,从而简化代码的编写和维护。例如,在字符串处理、矩阵运算等领域,一维数组可以大大简化代码的复杂度。
-
统计数组的大小:
以下是使用C语言实现统计数组大小的示例代码:
#include <stdio.h> int main() { // 定义一个整型数组,大小为5 int a[5] = {1, 2, 3, 4, 5}; // 计算数组的大小 int size = sizeof(a) / sizeof(a[0]); printf("The size of the array is %d ", size); // 输出数组的大小 return 0; }
以上代码中,
sizeof(a)
可以获取整个数组的字节数,而sizeof(a[0])
可以获取数组中每个元素的字节数。将两者相除即可得到数组的大小。需要注意的是,这种方法只适用于在定义数组时已知数组大小的情况,如果数组是通过动态分配内存得到的,则需要使用其他方法来获取数组的大小。 -
案例一:
-
解析:首先需要遍历数组,找到最大值,然后打印出来。
代码如下:
#include <iostream> using namespace std; int main() { int arr[5] = {300, 350, 200, 400, 250}; int max_weight = arr[0]; for (int i = 1; i < 5; i++) { if (arr[i] > max_weight) { max_weight = arr[i]; } } cout << "最重的小猪体重为:" << max_weight << endl; return 0; }
案例二:
代码实现:
解析:首先需要声明一个5个元素的数组,然后通过循环将数组元素逆置。
代码如下:
#include <iostream>
using namespace std;
int main() {
int arr[5] = {1, 3, 2, 5, 4};
for (int i = 0; i < 5 / 2; i++) {
int temp = arr[i];
arr[i] = arr[4 - i];
arr[4 - i] = temp;
}
for (int i = 0; i < 5; i++) {
cout << arr[i] << " ";
}
cout << endl;
return 0;
}
案例三:冒泡排序
冒泡排序是一种简单直观的交换排序算法。
冒泡排序的基本思想是通过重复遍历要排序的数列,比较相邻两个元素的大小,如果顺序错误(例如,第一个元素比第二个大),则交换它们的位置。这个过程会不断重复,直到整个数列被排序完成。具体步骤如下:
- 比较相邻元素:从数列的第一个元素开始,依次比较相邻的两个元素,如果前一个元素大于后一个元素,则交换这两个元素的位置。
- 重复遍历:完成一轮遍历后,最大的元素会被移动到数列的末尾。然后再次从头开始遍历,重复上述比较和交换的过程。
- 确定元素归位:每完成一趟遍历,就能确定一个元素归位,即该元素移动到了它最终应该在的位置上。
- 判断排序完成:当进行一轮遍历后没有任何元素需要交换,说明数列已经完全有序,排序过程结束。
总的来说,冒泡排序的名称来源于较小的元素会逐渐“冒泡”到数列的顶端,就像水中的气泡一样向上浮动。尽管冒泡排序在最坏情况下的时间复杂度较高(O(n^2)),但由于其算法简单且易于实现,它仍然在某些教学场合和特定应用场景中得到使用。
图示
代码部分
#include <stdio.h>
#include <stdlib.h> // rand() srand()
#include <time.h> // time()
void display(int* array, int size); // 打印函数
int check(int* array, int size); // 检查函数
void swap(int* a, int* b); // 交换函数
/**
* @brief 冒泡排序:重的往下沉,从小到大
*
* @param array 数组首地址
* @param size 数组大小
*/
void bubble_sort(int* array, int size)
{
// 外循环为排序趟数,size 个数进行 size-1 趟
// 内循环为每趟比较的次数,第 i 趟比较 size-1-i 次
for (int i = 0; i < size - 1; i++) {
for (int j = 0; j < size - 1 - i; j++) {
if (array[j] > array[j + 1]) {
swap(&array[j], &array[j + 1]);
}
}
}
}
void bubble_sort_better(int* array, int size)
{
for (int i = 0; i < size - 1; i++) {
// 以 flag 作为标志,如果遍历完没有改变说明有序不再遍历排序
int flag = 1;
for (int j = 0; j < size - 1 - i; j++) {
if (array[j] > array[j + 1]) {
swap(&array[j], &array[j + 1]);
flag = 0;
}
}
if (flag) {
break;
}
}
}
int main()
{
// 测试用例
// int array[] = {49, 38, 65, 97, 76, 13, 27, 49, 10};
// int array_size = sizeof(array) / sizeof(array[0]);
// printf("%d \n", array_size);
// printf("排序前数组:");
// display(array, array_size);
// bubble_sort(array, array_size);
// printf("排序后数组:");
// display(array, array_size);
// 随机测试
int array_num = 20; // 数组数量
int array_size = 20; // 数组大小
int array[array_size]; // 数组初始化
srand((unsigned int)time(NULL)); // 随机数种子,保证每次不一样
for (int i = 0; i < array_num; i++) {
for (int j = 0; j < array_size; j++) {
array[j] = rand() % 1000; // 随机生成数大小 0~999
}
printf("原来的数组:");
display(array, array_size);
bubble_sort(array, array_size);
printf("排序后数组:");
display(array, array_size);
// 检测排序结果
if (check(array, array_size) != 0) {
exit(-1);
}
printf("\n");
}
return 0;
}
/**
* @brief 打印函数
*
* @param array 数组首指针
* @param size 数组大小
*/
void display(int* array, int size)
{
for (int i = 0; i < size; i++) {
printf("%d ", array[i]);
}
printf("\n");
}
/**
* @brief 检查函数,从小到大
*
* @param array 数组首指针
* @param size 数组大小
*/
int check(int* array, int size)
{
for (int i = 0; i < size - 1; i++) {
if (array[i] > array[i + 1]) {
printf("sort array fail...\n");
return -1;
}
}
printf("sort array success...\n");
return 0;
}
/**
* @brief 交换函数
*
* @param a 第一个交换地址
* @param b 第二个交换地址
*/
void swap(int* a, int* b)
{
int temp = *b;
*b = *a;
*a = temp;
}
总之,一维数组是编程中非常重要的数据结构之一,它不仅能够存储和处理大量数据,还能够实现各种算法和简化代码。
5.5 二维数组
5.5.1 数组的定义
在程序员的术语中,二维数组可以被理解为一个数据结构,它以行和列的形式组织数据,形成一个类似于表格或矩阵的结构。它是一维数组的一个扩展,而一维数组可以被视为一个线性序列。
具体来说,二维数组可以想象为一个由多个一维数组构成的数组,其中每个一维数组代表二维数组的一行。这些一维数组(行)具有相同的长度,这个长度定义了二维数组的列数。因此,二维数组通常通过其行数和列数来描述其大小。
在内存中,二维数组通常是连续存储的,即第一行的所有元素紧跟着第二行的元素,依此类推。这允许通过索引公式直接访问任何特定元素。例如,如果我们有一个名为array
的二维数组,要访问位于第i
行第j
列的元素,我们通常使用array[i][j]
的形式(在大多数编程语言中)。
在不同的编程语言中,二维数组的声明和初始化方式可能会有所不同。以下是几种不同语言中声明二维数组的例子:
-
C/C++:
int array[3][4]; // 一个有3行4列的整型二维数组
-
Java:
int[][] array = new int[3][4]; // 一个有3行4列的整型二维数组
-
Python (在Python中称为列表的列表):
array = [[0 for _ in range(4)] for _ in range(3)] # 一个有3行4列的整型二维数组
二维数组在各种编程任务中都非常有用,包括图像处理、地图表示、游戏开发中的网格系统等。通过它们,开发者能够方便地处理有着行列逻辑关系的数据集。
5.5.2 数组名的作用
-
查询数组的占内存的大小
-
查看二维数组的首地址
-
代码实现:
#include<stdio.h> using namespace std; int main(){ int arr[2][3] ={ {1,2,3}, {4,5,6} } cout<<"二维数组占用内存空间为:"<<sizeof(arr)<<endl; cout<<"二维数组第一行占用内存空间为:"<<sizeof(arr[0])<<endl; cout<<"二维数组第一个元素占用内存空间为:"<<sizeof(arr[0][0])<<endl; }
#include <iostream>
int main() {
int arr[] = {1, 2, 3, 4, 5};
int *p = arr;
std::cout << "数组首地址: " << &arr[0] << std::endl;
std::cout << "指针指向的首地址: " << p << std::endl;
return 0;
}
5.5.3二维数组的案例
方法和思想
-
创建二维数组
-
统计考试成绩,让每行数据相加,统计出总和
-
代码实现
#include <stdio.h> using namespce std; #include <string.h> int main(){ int scores =[3][3] = { {100,100,100}, {90,55,100}, {60,70,80} } //统计求和 for(int i = 0;i<3;i++){ sum = 0; for(int j = 0;j<3;j++){ sum = sum +score[i][j]; } cout<<"第"<<i+1<<"个人的成绩总和为"<<sum<<endl; } }
5.6函数
为了实现算术运算,我们可以创建一个C++函数,该函数接受两个参数(操作数)和一个字符(运算符),然后根据运算符执行相应的算术运算。以下是一个示例:
#include <iostream>
using namespace std;
double arithmeticOperation(double num1, double num2, char operation) {
double result;
switch (operation) {
case '+':
result = num1 + num2;
break;
case '-':
result = num1 - num2;
break;
case '*':
result = num1 * num2;
break;
case '/':
if (num2 != 0) {
result = num1 / num2;
} else {
cout << "除数不能为0" << endl;
exit(0);
}
break;
default:
cout << "无效的运算符" << endl;
exit(0);
}
return result;
}
int main() {
double num1, num2;
char operation;
cout << "请输入第一个操作数: ";
cin >> num1;
cout << "请输入第二个操作数: ";
cin >> num2;
cout << "请输入运算符(+, -, *, /): ";
cin >> operation;
double result = arithmeticOperation(num1, num2, operation);
cout << "结果: " << result << endl;
system("pause");
return 0;
}
这个程序首先定义了一个名为arithmeticOperation
的函数,该函数接受两个double
类型的参数(操作数)和一个char
类型的参数(运算符)。然后,它使用switch
语句根据运算符执行相应的算术运算,并返回结果。在main
函数中,我们从用户那里获取操作数和运算符,然后调用arithmeticOperation
函数并输出结果。
运行结果:
值传递
#include <iostream>
using namespace std;
//形参传递
void swap(int num1, int num2) {
int temp = num1;
num1 = num2;
num2 = temp;
cout << "swap中 num1 =" << num1 << "swap中 num2 =" << num2 << endl;
}
//值传递
void swap1(int &num1, int &num2) {
int temp = num1;
num1 = num2;
num2 = temp;
cout << "swap1中 num1 =" << num1 << "swap1中 num2 =" << num2 << endl;
}
int main() {
int a = 10;
int b = 20;
swap(a, b);
cout << "main中 num1 =" << a << "main中 num2 =" << b << endl;
swap1(a, b);
cout << "二次调用main中 num1 =" << a << "main中 num2 =" << b << endl;
system("pause");
return 0;
}
函数的常见样式
C++中函数的常见样式有以下几种:
- 无参数,无返回值的函数:
void functionName() {
// 函数体
}
- 有参数,无返回值的函数:
void functionName(parameterType parameterName) {
// 函数体
}
- 无参数,有返回值的函数:
returnType functionName() {
// 函数体
return returnValue;
}
- 有参数,有返回值的函数:
returnType functionName(parameterType parameterName) {
// 函数体
return returnValue;
}
其中,returnType
表示函数的返回值类型,functionName
表示函数名,parameterType
表示参数类型,parameterName
表示参数名。
函数的声明
C++函数的声明、定义和作用:
-
声明:函数声明是告诉编译器函数的名称、返回类型和参数列表。函数声明通常放在头文件中,以便在多个源文件中使用同一个函数时,编译器可以知道函数的存在。
-
定义:函数定义是实现函数的具体功能。函数定义包括函数体,即实现函数功能的代码块。
-
作用:函数的作用是将一段具有特定功能的代码封装起来,以便在程序中多次调用。通过使用函数,可以提高代码的复用性和可维护性。
相关案例实现:
#include <iostream>
using namespace std;
// 函数声明 不用具体的函数的实现 只是声明 int add(int a,int b);
int add(int a, int b);
int main() {
int num1, num2, sum;
cout << "请输入两个整数:" << endl;
cin >> num1 >> num2;
// 调用函数
sum = add(num1, num2);
cout << "两数之和为:" << sum << endl;
return 0;
}
// 函数定义
//pass 复习一下:a>b?a:b
int add(int a, int b) {
return a + b;
}
在这个案例中,我们定义了一个名为add
的函数,用于计算两个整数的和。首先,我们在main
函数中获取用户输入的两个整数,然后调用add
函数计算它们的和,并将结果输出到屏幕上。
函数的分文件编写
在C++中,实现函数的分文件编写通常需要将函数声明放在头文件中,而将函数定义放在源文件中。以下是一个简单的示例:
- 创建一个头文件(例如:functions.h):
#ifndef FUNCTIONS_H
#define FUNCTIONS_H
// 函数声明
int add(int a, int b);
#endif // FUNCTIONS_H
- 创建一个源文件(例如:functions.cpp):
#include "functions.h"
// 函数定义
int add(int a, int b) {
return a + b;
}
-
在头文件中剪切源文件中函数的声明
void swap(int num1, int num2); -
在源文件中声明函数的定义,并且引用头文件
-
在头文件导入标准的输入输出文件 标准的命名空间std和函数声明
-
在主程序中使用这些函数:
#include <iostream>
#include "functions.h"
int main() {
int num1, num2, sum;
std::cout << "请输入两个整数:" << std::endl;
std::cin >> num1 >> num2;
sum = add(num1, num2);
std::cout << "两数之和为:" << sum << std::endl;
return 0;
}
在这个示例中,我们将函数声明放在了头文件中,而将函数定义放在了源文件中。这样,我们可以在多个源文件中使用这个函数,而不需要重复编写函数的定义。
5.7指针
在C++中,指针是一种特殊的变量,它存储着另一个变量的内存地址。指针的基本概念、作用和使用方式具体如下:
-
基本概念:指针是一种变量,它存储的是另一变量的地址。这个地址是内存中的一个位置,而这个位置上存储的就是数据。通过指针,可以间接访问和修改这个地址上的数据。
-
作用:指针在C++编程中扮演着重要角色,它们允许程序员直接操作内存,这为程序的灵活性和效率带来了提升。指针的使用可以帮助实现动态内存分配、函数参数的传递、构建复杂的数据结构如链表和树等,以及支持多维数组和其他高级功能。
-
使用方式:
-
声明:使用星号(*)来声明一个指针变量。例如,
int *ptr;
声明了一个指向整型的指针变量ptr
。 -
初始化:指针可以通过获取变量的地址(&)来初始化,如
int val = 10; int *ptr = &val;
,此时ptr
指向val
的地址。 -
解引用:可以使用星号(*)来访问指针指向地址上的值,如
int value = *ptr;
,这样就将ptr
指向地址上的值赋给了value
。 -
指针运算:指针可以进行加减运算,以移动到连续内存块中的其他元素,也可以进行比较运算来确定两个指针的相对位置。
总的来说,掌握指针的使用对于编写高效和灵活的C++代码至关重要。通过深入理解指针的原理和常见操作,程序员能够更加熟练地使用指针来访问和操作内存中的数据。