c++学习笔记3

最新推荐文章于 2024-09-15 11:40:06 发布

面如激雷而心有平湖

最新推荐文章于 2024-09-15 11:40:06 发布

阅读量695

点赞数

文章标签： c++ 开发语言后端

本文链接：https://blog.csdn.net/Ponnny/article/details/121275251

版权

5、数组

数组：就是一个集合，里面存放了相同类型的数据元素；

数组特点：放在一块连续的内存空间中，且数组中每个元素都是相同的数据类型；

可以通过下标访问数组中的元素

定义数组时不要跟变量重名

定义方法：

1.数据类型数组名 [ 数组长度 ]；

int arr [5] ;

而数组元素内容的范围是从0到4，按照上述方式定义之后，可以按照如下方式赋值：

arr[0]=10;

arr[1]=20;

arr[2]=30;

arr[3]=40;

arr[4]=50;

（如果初始化数据时，没有全部赋值，会用0自动填补剩余的数据）

2.数据类型数组名 [ 数组长度 ] = { 数据1，数据2，……}；

int arr [5] = {10，20，30，40，50} ;

3.数据类型数组名 [ ] = { 数据1，数据2，……}；

int arr [] = {10，20，30，40，50} ;

（使用此法定义数组时，必须当场给出数据值）

一维数组中，数组名的有趣用法：

1.可以统计整个数组在内存中的长度：

sizeof(arr);

也可以借此计算数组的大小：

sizeof(arr[0]);

sizeof(arr)/sizeof(arr[0])——————很强的小技巧

2.可以获取数组在内存中的首地址；

cout<<"数组首地址为："<<arr<<endl;

cout<<"数组中第一个元素的地址为："<<&arr[]<<endl;

练习案例：五只小猪称体重：

描述：一个数组定义如下：

int arr[5] = {300,350,200,400,250};

存储内容含义为5只小猪的体重值，找出并打印最终的小猪的体重；

#include<iostream>
using namespace std;
int main() {
	int wei[] = { 300,350,200,400,250 };
	int weim = 0,j = 0;
	for (int i = 0; i < 5; i++)
	{
		
		if (wei[i]>weim)
		{
			weim = wei[i];
			j = i;
		}
	}
	cout << "五只小猪中体重最大为:\t" << j+1 << "\t号小猪" << endl;
	cout << "五只小猪中体重最大重:\t" << weim << "\tkg" << endl;



	system("pause");
	return 0;
}

注意这里定义weim和j要在循环之外；

案例二：数组元素逆置

描述：声明一个五个元素的数组，并将其逆置（力图，原数组元素为1，3，2，5，4；逆置以后新数组为4，5，2，3，1；）

编写代码如下：

#include<iostream>
using namespace std;
int main() {
	int Niz[] = { 1,3,2,5,4 };
	int Zin[5];
	for (int i = 0, j = 4; i < 5; i++, j--)
	{
		Zin[j] = Niz[i];
	}
	cout << Zin << endl;

	system("pause");
	return 0;
}

但是最终输出结果为：

000000716318F508
请按任意键继续. . .

并非我想要的整个数组的值，而是数组的第一个地址；

搜索后发现，字符型的数组可以按照上述代码使用数组名直接输出；

而int型的数组不能直接用数组名输出。按照上述代码系统会将数组名理解为输出第一个位置的地址。

要写在循环中逐个输出：

#include<iostream>
using namespace std;
int main() {
	int Niz[] = { 1,3,2,5,4 };
	int Zin[5];


//这里j的取值有个技巧：  当不知道数组具体长度时，使用
//j = sizeof(Niz)/sizeof(Niz[]) - 1   计算j的数值


	for (int i = 0, j = sizeof(Niz) / sizeof(Niz[0]) - 1; i < sizeof(Niz) / sizeof(Niz[0]); i++, j--)
	{
		Zin[i] = Niz[j];
		cout << Zin[i] << endl;
	}
	

	system("pause");
	return 0;
}

排序案例：冒泡排序

作用：最常用的排序方法，对数组内元素进行排序，下面分为三部列写其方法：

1.比较相邻的元素，如果第一个比第二个大，就交换它们的顺序；

2.对每一对相邻元素做相同的工作，执行完毕后，找到第一个最大值（把最大值放在最后一位）。

3.重复上述步骤，每次比较次数-1（最大值已在最后一位），直到不需要比较

例题：将数组{4，2，8，0，5，7，1，3，9}进行冒泡排序：

#include<iostream>
using namespace std;

int main() {

	int Mao[] = { 4,2,8,0,5,7,1,3,9 };


	cout << "原始数组为：";
	for (int j = 0; j < sizeof(Mao) / sizeof(Mao[0]); j++)
	{
		cout << Mao[j] <<" ";
	}
	cout << endl;


//-------------------------此处赘余多算一轮-----------------------------
	for (int j = 0; j < sizeof(Mao) / sizeof(Mao[0]); j++)
	{
//-------------------------此处赘余，多算很多---------------------------
		for (int i = 0; i < sizeof(Mao) / sizeof(Mao[0])-1; i++)
		{
//----------------------此处可以只int一个变量temp解决问题---------------
			int a = Mao[i], b = Mao[i + 1];
			if (a > b)
			{
				Mao[i + 1] = a;
				Mao[i] = b;
			}
		}
	}


	cout << "冒泡排序之后数组为：";
	for (int j = 0; j < sizeof(Mao) / sizeof(Mao[0]); j++)
	{
		cout << Mao[j] <<" ";
	}
	cout << endl;


	system("pause");
	return 0;
}

实际代码中比我手写优质在于：
1.一轮轮数-1：

一轮总轮数应为元素个数-1

2.二轮轮数- j：

二轮总轮数应为：元素个数-1-当前轮数

3.没有int a 和 b

而是用一个 int temp 进行交换

写法为：

if（Mao[i]<Mao[i+1]）

{

int temp = Mao[i+1];

Mao[i+1]=Mao[i];

Mao[i]=temp;

}

5.3二维数组

定义方式：

注意使用 string 数据类型时要包含头文件 #include<string>

1.数据类型数组名[行数][列数]；

int arr[2][3];

arr[0][0]=1;

arr[0][1]=2;

arr[0][2]=3;

arr[1][0]=4;

arr[1][1]=5;

arr[1][2]=6;

2.数据类型数组名[行数][列数] = {{数据1，数据2}，{数据3，数据4}}；

int arr2[2][3] = {{1,2,3},{4,5,6}};

3.数据类型数组名[行数][列数] = {数据1，数据2，数据3，数据4}

int arr3[2][3] = {1,2,3,4,5,6};

4.数据类型数组名[ ][列数] = {数据1，数据2，数据3，数据4}

省略行数（不可省略列数）

int arr4[ ][3] = {1,2,3,4,5,6};

二维数组数组名的用途：

1.查看占用的内存大小：

cout<<" 二维数组 占用的内存空间为："<<sizeof(arr)<<endl;
cout<<" 二维数组的一行 占用的内存空间为："<<sizeof(arr[0])<<endl;
cout<<" 二维数组的一个元素 占用的内存空间为："<<sizeof(arr[0][0])<<endl;


cout<<" 二维数组的 行数 为："<<sizeof(arr)/sizeof(arr[0])<<endl;
cout<<" 二维数组的 列数 为："<<sizeof(arr[0])/sizeof(arr[0][0])<<endl;

2.查看二维数组的首地址：

//-----------依然是cout数组名输出首地址-------------
cout<<"二维数组首地址为："<<arr<<endl;

6.函数

实现函数的五个步骤

1.返回值类型 int

2.函数名随便起

3.参数列表 (int num1,int num2)

4.函数体语句 int sum = num1+num2;

5.return语句 rerurn sum；

语法如下：

int add(int num1, int num2)
{
    int sum = num1 + num2;
    return sum;
}

其中num1和num2 称为形参

函数的调用

函数名称（参数）；

对上述函数进行调用：

int a = 10;
int b = 20;
int c = add(a,b)

其中的a和b称为实参；

形参中的数字的变化不会影响实参。举例如下：代码和结果

#include<iostream>
using namespace std;

//-------------没有返回值时可以使用void定义----------
void swap(int num1, int num2)
{
//-----输出写在函数内，可以在函数被主程序调用时会直接输出----
	cout << "交换前：" << endl;
	cout << "num1 = " << num1 << endl;
	cout << "num2 = " << num2 << endl;

	int temp = num1;
	num1 = num2;
	num2 = temp;

	cout << "交换后：" << endl;
	cout << "num1 = " << num1 << endl;
	cout << "num2 = " << num2 << endl;

	return;
}
int main() {
	int a = 10, b = 20;

	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

	swap(a, b);

	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
//------------------↑输出前后实参不会变化↑-------------
	system("pause");
	return 0;
}

a = 10
b = 20
交换前：
num1 = 10
num2 = 20
交换后：
num1 = 20
num2 = 10
a = 10
b = 20
请按任意键继续. . .

也就是说，值传递时，形参是修饰不了实参的。

函数的常见样式

常见的函数样式有4种：

无参无返：

//-----函数---------
void test01()
{
    cout<<"test 01"<<endl;
}

//-----调用---------
test01();

//-----输出---------
test 01

有参无返

//-----函数---------
void test02(int a)
{
    cout<<"a="<<a<<endl;
}

//-----调用---------
test02(100);

//-----输出---------
a=100

无参有返

//-----函数---------
int test03()
{
    cout<<"test03"<<endl;
    return 1000;
}

//-----调用---------
int num1 = test03();
cout<< "num1 = "<<num1<<endl;

//-----输出---------
test03
num1 = 1000

有参有返

//-----函数---------
int test04(int a)
{
    cout<<"a="<<a<<endl;
    return a;
}

//-----调用---------
int num2 = test04(10000);
cout<< "num2=" << num2 <<endl;

//-----输出---------
a=10000
num2 = 10000

函数的声明：

作用：告诉编译器函数名称和如何调用函数。函数的实际主体可以单独定义。

·函数的声明可以多次，但是函数的定义只能有一次。

声明的作用：

当函数定义出现在主函数之后时，例如：

//-----无声明，主函数开头---
int main(){
    
//---主函数中调用函数---
    MMie(a, b)

}
//----函数定义在主函数之后---

int MMie(int a, int b)
{
    cout<<"asdf"<<endl;
    return a>b?a:b;
}

上述函数没有声明，且子函数写在主程序之后，运行之后报错：

错误    C3861    “MMie”: 找不到标识符

而如果在主程序之前加上声明，如下所示：

//----加声明，声明后主函数---
int MMie(int a, int b);
int main(){
    
//---主函数中调用函数---
    MMie(a, b)

}
//----函数定义在主函数之后---

int MMie(int a, int b)
{
    cout<<"asdf"<<endl;
    return a>b?a:b;
}

再次运行输出时，显示函数中的输出asdf，也能显示返回值20，这就是声明的用法；

函数的分文件编写：

作用：让代码结构更加清晰

函数分文件编写一般有四个步骤：

1.创建后缀名为.h的头文件

左边栏中找到头文件文件夹，右键头文件文件夹，点击添加-新建项-创建.h后缀的文件（例如hhhhhead.h）

//------新建hhhhhead.h中写上函数声明-----
#include<iostream>
void swappp(int a, int b);

2.创建后缀名为.cpp的源文件

右键源文件文件夹，添加-新建项-新建 yuan.cpp

//-------新建yuan.cpp中列写函数定义-------
#include "hhhhhead.h"
#include <iostream>
using namespace std;
void swappp(int a, int b)
{
	int temp = a;
	a = b;
	b = temp;
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	return;
}

3.在头文件中写函数的声明

.h 文件中，写void swap(int a, int b); (声明)

4.在源文件中写函数的定义

源文件开头 #include "swap.h" （双引号代表头文件是自己写的）

然后下面写定义即可

调用实例：

//--------直接在其他函数中，头部添加include之后直接使用函数即可
#include<iostream>
#include"hhhhhead.h"
using namespace std;

int main() {
    int a = 10;
    int b = 20;
    swappp(a, b);

}