C++入门04—数组与函数

news2024/11/15 4:47:28

1. 概述

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

特点1：数组中的每个数据元素都是相同的数据类型

特点2：数组是由连续的内存位置组成的

2. 一维数组

2.1 一维数组定义方式

一维数组定义的三种方式：

  1. 数据类型 数组名[ 数组长度(常量表达式) ];

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

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

示例：

int main() {

	//定义方式1
	//数据类型 数组名[元素个数];
	int score[10];  // 这个整型数组中含有10个元素

	//利用下标赋值
	score[0] = 100;
	score[1] = 99;
	score[2] = 85;

	//利用下标输出
	cout << score[0] << endl;
	cout << score[1] << endl;
	cout << score[2] << endl;


	//第二种定义方式：聚合方式赋值
	//数据类型 数组名[元素个数] =  {值1，值2 ，值3 ...};
	//如果{}内不足10个数据，剩余数据用0补全
	int score2[10] = { 100, 90,80,70,60,50,40,30,20,10 };
	
	//逐个输出
	//cout << score2[0] << endl;
	//cout << score2[1] << endl;

	//一个一个输出太麻烦，因此可以利用循环进行输出
	for (int i = 0; i < 10; i++)
	{
		cout << score2[i] << endl;
	}

	//定义方式3
	//数据类型 数组名[] =  {值1，值2 ，值3 ...};
	int score3[] = { 100,90,80,70,60,50,40,30,20,10 };

	for (int i = 0; i < 10; i++)
	{
		cout << score3[i] << endl;
	}

	system("pause");

	return 0;
}

总结1：数组名的命名规范与变量名命名规范一致，不要和变量重名

总结2：数组中下标是从0开始索引

2.2 一维数组数组名

一维数组名称的用途：

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

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

 示例：

int main() {

	//数组名用途
	//1、可以获取整个数组占用内存空间大小
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };

	cout << "整个数组所占内存空间为： " << sizeof(arr) << endl;
	cout << "每个元素所占内存空间为： " << sizeof(arr[0]) << endl;
	cout << "数组的元素个数为： " << sizeof(arr) / sizeof(arr[0]) << endl;

	//2、可以通过数组名获取到数组首地址
	cout << "数组首地址为： " << (int)arr << endl;
	cout << "数组中第一个元素地址为： " << (int)&arr[0] << endl;
	cout << "数组中第二个元素地址为： " << (int)&arr[1] << endl;

	//arr = 100; 错误，数组名是常量，因此不可以赋值


	system("pause");

	return 0;
}

注意：数组名是常量，不可以赋值

总结1：直接打印数组名，可以查看数组所占内存的首地址

总结2：对数组名进行sizeof，可以获取整个数组占内存空间的大小

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

案例描述：

在一个数组中记录了五只小猪的体重，如：int arr[5] = {300,350,200,400,250};

找出并打印最重的小猪体重。

#include <iostream>
using namespace std;
int main() {

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

	for (int i = 0; i < 5; i++) {

		for (int j = 0; j < 5 - i; j++) {
			
			if (pig[j] < pig[j + 1]) {
				int a = 0;
				a = pig[j];
				pig[j] = pig[j + 1];
				pig[j + 1] = a;
			}
		}
	}

	for (int i = 0; i < 5; i++)
	{
		cout << pig[i] << endl;
	}
	system("pause");

	return 0;
}

练习案例2：数组元素逆置

案例描述：请声明一个5个元素的数组，并且将元素逆置.

(如原数组元素为：1,3,2,5,4;逆置后输出结果为:4,5,2,3,1);

#include <iostream>
using namespace std;
int main() {

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

	// 逆向排列数组
	for (int i = 0; i < 5 / 2; ++i) {
		int temp = pig[i];
		pig[i] = pig[5 - 1 - i];
		pig[5 - 1 - i] = temp;
	}

	for (int i = 0; i < 5; i++)
	{
		cout << pig[i] << endl;
	}
	system("pause");

	return 0;
}

2.3 冒泡排序

int main() {

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

	for (int i = 0; i < 9 - 1; i++)
	{
		for (int j = 0; j < 9 - 1 - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}

	for (int i = 0; i < 9; i++)
	{
		cout << arr[i] << endl;
	}
    
	system("pause");

	return 0;
}

3. 二维数组

二维数组就是在一维数组上，多加一个维度。

3.1 二维数组定义方式

二维数组定义的四种方式：

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

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

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

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

建议：以上4种定义方式，利用第二种更加直观，提高代码的可读性

示例：

int main() {

	//方式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;

    // 打印数据
	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			cout << arr[i][j] << " ";
		}
		cout << endl;
	}

	//方式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 };
	
	system("pause");

	return 0;
}
#include <iostream>
using namespace std;
int main() {

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

	cout << arr2[0][0] << endl; // 输出打印 1
	cout << arr2[0][1] << endl; // 输出打印 2
	cout << arr2[0][2] << endl; // 输出打印 3
	cout << arr2[1][2] << endl; // 输出打印 6



	system("pause");

	return 0;
}

总结：在定义二维数组时，如果初始化了数据，可以省略行数

3.2 二维数组数组名

  • 查看二维数组所占内存空间

  • 获取二维数组首地址

示例：

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;

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

	//地址
	cout << "二维数组首地址：" << arr << endl;
	cout << "二维数组第一行地址：" << arr[0] << endl;
	cout << "二维数组第二行地址：" << arr[1] << endl;

	cout << "二维数组第一个元素地址：" << &arr[0][0] << endl;
	cout << "二维数组第二个元素地址：" << &arr[0][1] << endl;

	system("pause");

	return 0;
}

总结1：二维数组名就是这个数组的首地址

总结2：对二维数组名进行sizeof时，可以获取整个二维数组占用的内存空间大小

3.3 二维数组应用案例

考试成绩统计：

案例描述：有三名同学（张三，李四，王五），在一次考试中的成绩分别如下表，请分别输出三名同学的总成绩

语文数学英语
张三100100100
李四9050100
王五607080

 参考答案：

int main() {

	int scores[3][3] =
	{
		{100,100,100},
		{90,50,100},
		{60,70,80},
	};

	string names[3] = { "张三","李四","王五" };

	for (int i = 0; i < 3; i++)
	{
		int sum = 0;
		for (int j = 0; j < 3; j++)
		{
			sum += scores[i][j];
		}
		cout << names[i] << "同学总成绩为： " << sum << endl;
	}

	system("pause");

	return 0;
}

4.函数 

4.1 概述

作用：将一段经常使用的代码封装起来，减少重复代码

一个较大的程序，一般分为若干个程序块，每个模块实现特定的功能。

4.2 函数的定义

函数的定义一般主要有5个步骤：

1、返回值类型

2、函数名

3、参数表列

4、函数体语句

5、return 表达式

语法：

返回值类型 函数名 （参数列表）
{ 
 
       变量的声明  // 函数体内部
       函数体语句  // 函数体内部

       return表达式

}

4.3 函数的调用

功能：使用定义好的函数

语法：函数名（参数）

示例：

//函数定义
int add(int num1, int num2) //定义中的num1,num2称为形式参数，简称形参
{
    int sum = num1 + num2;
    return sum;
}
​
int main() {
​
    int a = 10;
    int b = 10;
    //调用add函数
    int sum = add(a, b);//调用时的a，b称为实际参数，简称实参
    cout << "sum = " << sum << endl;
​
    a = 100;
    b = 100;
​
    sum = add(a, b);
    cout << "sum = " << sum << endl;
​
    system("pause");
​
    return 0;
}

总结：函数定义里小括号内称为形参，函数调用时传入的参数称为实参

4.4 值传递

  • 所谓值传递，就是函数调用时实参将数值传入给形参

  • 值传递时，如果形参发生，并不会影响实参

示例：

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 ; 当函数声明时候，不需要返回值，可以不写return
}
​
int main() {
​
    int a = 10;
    int b = 20;
​
    swap(a, b);
​
    cout << "mian中的 a = " << a << endl;
    cout << "mian中的 b = " << b << endl;
​
    system("pause");
​
    return 0;
}

总结： 值传递时，形参是修饰不了实参的

4.4.1 副本传递

如下swap函数是将两个变量的值对换：

#include<iostream>
using namespace std;

void swap(int a, int b)
{
	int temp = a;
	a = b;
	b = temp;

	cout << "cat = " << a << endl;
	cout << "dog = " << b << endl;
}

void main() {

	int cat = 11;
	int dog = 22;

	cout << "交换前的cat值：" << cat << endl;
	cout << "交换前的dog值：" << dog << endl;

	swap(cat, dog);
	cout << "交换后的cat值：" << cat << endl;
	cout << "交换后的dog值：" << dog << endl;

}

但是运行发现，变量cat和dog在交换前后的值并未发生变化。

原因：

问题出在我们的swap函数中。在这个函数中，传递了cat和dog的副本而不是它们的引用。这意味着函数内部的a和b只是cat和dog的副本，对它们的修改不会影响到cat和dog的值。在C++中，如果你要实现交换两个变量的值，你需要传递它们的引用或指针。

 要修复你的代码，你可以将swap函数修改如下：

void swap(int &a, int &b)
{
    int temp = a;
    a = b;
    b = temp;
}

注意函数参数现在使用了引用(&)，这将允许函数修改传递给它的实际变量的值。然后，我们的main函数可以保持不变。 

当你调用swap(cat, dog);时，cat和dog的值将在swap函数内部交换，然后它们的交换后的值将反映在main函数中。

以下是修复后的代码示例：

#include <iostream>
using namespace std;

void swap(int &a, int &b)
{
    int temp = a;
    a = b;
    b = temp;
}

int main()
{
    int cat = 11;
    int dog = 22;

    cout << "交换前的cat值：" << cat << endl;
    cout << "交换前的dog值：" << dog << endl;

    swap(cat, dog);

    cout << "交换后的cat值：" << cat << endl;
    cout << "交换后的dog值：" << dog << endl;

    return 0;
}

 效果：

4.5 函数的常见样式

常见的函数样式有4种

  1. 无参无返

  2. 有参无返

  3. 无参有返

  4. 有参有返

示例：

//函数常见样式
//1、 无参无返
void test01()
{
    //void a = 10; //无类型不可以创建变量,原因无法分配内存
    cout << "this is test01" << endl;
    //test01(); 函数调用
}
​
//2、 有参无返
void test02(int a)
{
    cout << "this is test02" << endl;
    cout << "a = " << a << endl;
}
​
//3、无参有返
int test03()
{
    cout << "this is test03 " << endl;
    return 10;
}
​
//4、有参有返
int test04(int a, int b)
{
    cout << "this is test04 " << endl;
    int sum = a + b;
    return sum;
}

4.6 函数的声明

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

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

  • 当把自定义函数写在main()函数之前时，不对函数进行申明也可以

  • 当把自定义函数写在main()函数之后时，需要在main函数之前对自定义的函数进行声明，否则会报错。

写在main()函数之前时：

#include <iostream>
using namespace std;
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 ; 当函数声明时候，不需要返回值，可以不写return
}

int main() {

	int a = 10;
	int b = 20;

	swap(a, b);

	cout << "mian中的 a = " << a << endl;
	cout << "mian中的 b = " << b << endl;

	system("pause");

	return 0;
}

写在main()函数之后时： 

#include <iostream>
using namespace std;

int main() {

	int a = 10;
	int b = 20;

	swap(a, b);

	cout << "mian中的 a = " << a << endl;
	cout << "mian中的 b = " << b << endl;

	system("pause");

	return 0;
}

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 ; 当函数声明时候，不需要返回值，可以不写return
}

 

对比发现：当自定义函数写在main函数之后时，按照原来的写法，在main函数中将无法调用自定义函数。

解决方式：函数声明

示例：

//声明可以多次，定义只能一次
//声明
int max(int a, int b);
int max(int a, int b);
//定义
int max(int a, int b)
{
    return a > b ? a : b;
}
​
int main() {
​
    int a = 100;
    int b = 200;
​
    cout << max(a, b) << endl;
​
    system("pause");
​
    return 0;
}

4.7 函数的分文件编写

作用：当代码量非常大的时候， 将代码写在同一个文件里会显得代码杂乱，分文件编写会让代码结构更加清晰

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

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

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

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

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

示例：

将代码写在同一个文件中的时候：

//声明可以多次，定义只能一次
//声明
int max(int a, int b);
int max(int a, int b);
//定义
int max(int a, int b)
{
    return a > b ? a : b;
}
​
int main() {
​
    int a = 100;
    int b = 200;
​
    cout << max(a, b) << endl;
​
    system("pause");
​
    return 0;
}

 分文件编写：

//swap.h文件
#include<iostream>
using namespace std;
​
// 函数声明
void swap(int a, int b);
​
//swap.cpp文件
#include "swap.h"
​
// 函数的定义
void swap(int a, int b)
{
    int temp = a;
    a = b;
    b = temp;
​
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
}
//main函数文件
#include "swap.h"
int main() {
​
    int a = 100;
    int b = 200;
    swap(a, b);
​
    system("pause");
​
    return 0;
}

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

 

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

4.7.3 在头文件中写函数的声明

4.7.4 在源文件中写函数的定义 

4.7.5 在任意代码中使用分写于头文件和源文件中的自定义函数 

4.7.6 这样做的好处 

把一种自定义函数先后分写于头文件和源文件中，这样可以将该自定义函数做成一个工具，以方便日后任意代码中能够直接应用该自定义函数。

要注意的就是，在程序中引用该函数时，需要先引入其头文件。

4.8 重载函数

C++中的函数重载是一种允许你定义多个具有相同名称但不同参数列表的函数的机制。这允许你使用相同的函数名来执行不同的操作，具体操作取决于函数调用时提供的参数。函数重载有助于编写更具表现力和灵活性的代码。

以下是关于C++函数重载的重要概念和规则：

  1. 函数名相同，参数列表不同：函数重载要求函数名称相同，但参数列表必须不同，要么通过参数的数量不同，要么通过参数的类型不同来区分。返回值类型通常不用于函数重载的区分。

  2. 重载解析：当你调用一个重载函数时，C++编译器将根据提供的参数来确定要调用哪个函数。这个过程称为重载解析。编译器会尽力匹配与提供的参数最匹配的函数。

  3. 举例：下面是一个简单的示例，展示了函数重载的用法：

int add(int a, int b) {
    return a + b;
}

double add(double a, double b) {
    return a + b;
}

在这里，我们定义了两个名为add的函数，一个接受两个整数参数，另一个接受两个双精度浮点数参数。根据传递的参数类型，编译器会选择适当的函数进行调用。 

     4.函数重载与默认参数：函数重载可以与默认参数一起使用。如果函数重载中的某些版本具有默认参数，那么调用时可以根据需要省略这些参数。

    5.函数模板：C++还引入了函数模板，它允许你编写一种通用形式的函数，可以用于多种不同的数据类型。函数模板是函数重载的扩展，允许你编写具有参数类型的参数化模板。

函数重载提供了一种强大的方式来编写清晰、一致和易于理解的代码，因为你可以使用相同的名称来描述不同版本的函数功能，而无需为每个功能选择不同的名称。这有助于提高代码的可读性和可维护性。

以下是一个完整的C++代码示例，演示了如何使用函数重载来实现不同类型数据的加法操作： 

#include <iostream>

int add(int a, int b) {
    return a + b;
}

double add(double a, double b) {
    return a + b;
}

std::string add(const std::string& a, const std::string& b) {
    return a + b;
}

int main() {
    int intResult = add(5, 3);
    double doubleResult = add(2.5, 3.7);
    std::string stringResult = add("Hello, ", "world!");

    std::cout << "Integer addition result: " << intResult << std::endl;
    std::cout << "Double addition result: " << doubleResult << std::endl;
    std::cout << "String concatenation result: " << stringResult << std::endl;

    return 0;
}

在这个示例中，我们定义了三个不同版本的add函数，每个版本接受不同类型的参数。一个版本用于整数相加，一个版本用于双精度浮点数相加，还有一个版本用于字符串连接。在main函数中，我们演示了如何调用这些不同版本的add函数来执行不同类型的加法操作，分别得到整数相加、双精度浮点数相加和字符串连接的结果。 

4.9 变量的作用域

变量的声明位置以及存储方式都影响着函数对变量的调用。

变量的作用域（scope）指的是变量在程序中可见和可访问的部分。作用域规定了变量的生存期和可访问性，以及变量在不同部分的程序中如何引用。

在C++和许多其他编程语言中，有以下主要的作用域类型：

局部作用域（Local Scope）：局部作用域是在一个代码块内部定义的变量的作用域。这些变量只在该代码块内部可见和可访问。一旦代码块执行完毕，局部变量通常会被销毁。例如，函数内部定义的变量就具有局部作用域。

void myFunction() {
    int x = 10;  // x 具有局部作用域
    // 只能在 myFunction 函数内访问 x
}

全局作用域（Global Scope）：全局作用域中定义的变量在整个程序中都可见和可访问。这些变量通常在程序的最顶层定义，超出任何函数或代码块之外。

int globalVar = 20;  // globalVar 具有全局作用域
// 可以在整个程序中的任何地方访问 globalVar

命名空间作用域（Namespace Scope）：C++支持命名空间，其中变量可以具有命名空间作用域。这些变量可以在特定命名空间中访问，避免命名冲突。 

namespace MyNamespace {
    int x = 30;  // x 具有命名空间作用域
    // 可以在 MyNamespace 中访问 x
}

类作用域（Class Scope）：在类定义中声明的成员变量具有类作用域，它们可以在类的方法中访问。 

class MyClass {
public:
    int memberVar = 40;  // memberVar 具有类作用域
    // 可以在 MyClass 的方法中访问 memberVar
};

4.10 变量的生存周期

变量的存储方式不同，变量的生存期也会不同，生存期表示了变量存在的时间。

C++定义4中变量存储类别，分别是：
auto变量

static变量

register变量

extern变量

 

​

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1143370.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

全域数据连接器解决运营痛点问题，助力海尔节省200万+

全域数据连接器解决运营痛点问题，助力海尔节省200万+

随着电商渠道增多和数字技术发展&#xff0c;商家在全域运营和数字化建设方面的应用系统越来越多&#xff0c;诸如以天猫、京东等电商平台区分的店铺后台&#xff0c;以CRM、ERP、SCM等服务区分的应用软件。 这些系统数据各有侧重&#xff0c;但又独立运行&#xff0c;导致很多…
阅读更多...
批量发送邮件时怎么使用蜂邮EDM与Outlook？

批量发送邮件时怎么使用蜂邮EDM与Outlook？

批量发送邮件时使用蜂邮EDM和Outlook的方法&#xff1f;群发电子邮件的技巧有哪些&#xff1f; 电子邮件仍然是最常用的沟通工具之一&#xff0c;无论是企业还是个人用户&#xff0c;都希望能够高效地一次性将邮件发送给多个收件人。在本文中&#xff0c;将深入探讨蜂邮EDM和O…
阅读更多...
【耗时半年，实地调研！泣血2万字，破除你的人工智能焦虑！《2023最全AI商业落地调研报告》】发现一个不错的视频。

【耗时半年，实地调研！泣血2万字，破除你的人工智能焦虑！《2023最全AI商业落地调研报告》】发现一个不错的视频。

视频地址 学习视频地址&#xff1a; https://www.bilibili.com/video/BV1YB4y1f7GE/ 基金报告生成工具&#xff1a; https://www.anthropic.com/app-unavailable-in-region?utm_sourcecountry 国内不支持。 数据分析师要被淘汰 https://www.bilibili.com/video/BV17N41127P…
阅读更多...
21、Python -- 如何定义类

21、Python -- 如何定义类

目录 类和对象语法语法说明Python是动态语言类变量实例变量 实例方法 了解类与对象 掌握定义类的语法 理解Python的动态性 实例方法 类和对象 两个重要概念&#xff1a;类&#xff08;class&#xff09;和对象&#xff08;object&#xff0c;也被称为实例&#xff0c;instance…
阅读更多...
浅谈安科瑞EMS能源管控平台建设的意义-安科瑞 蒋静

浅谈安科瑞EMS能源管控平台建设的意义-安科瑞 蒋静

摘 要&#xff1a;能源消耗量大、能源运输供给不足、环境压力日趋增加、能耗双控等一系列问题一直困扰着钢铁冶金行业&#xff0c;制约着企业快速稳定健康发展。本文介绍的安科瑞EMS能源管控平台&#xff0c;采用自动化、信息化技术&#xff0c;实现从能源数据采集、过程监控、…
阅读更多...
Spring Web MVC入门

Spring Web MVC入门

一&#xff1a;了解Spring Web MVC (1)关于Java开发 &#x1f31f;Java开发大多数场景是业务开发 比如说京东的业务就是电商卖货、今日头条的业务就推送新闻&#xff1b;快手的业务就是短视频推荐 (2)Spring Web MVC的简单理解 &#x1f497;Spring Web MVC&#xff1a;如何使…
阅读更多...
leetCode 76. 最小覆盖子串 + 滑动窗口 + Hash + 图解（详细）

leetCode 76. 最小覆盖子串 + 滑动窗口 + Hash + 图解（详细）

76. 最小覆盖子串 - 力扣&#xff08;LeetCode&#xff09; 给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串&#xff0c;则返回空字符串 "" 注意&#xff1a; 对于 t 中重复字符&#xff0c;我们寻…
阅读更多...
分布估计算法（Estimation of distribution algorithm，EDA）

分布估计算法（Estimation of distribution algorithm，EDA）

概论 分布估计算法&#xff08;Estimation of distribution algorithm&#xff0c;EDA&#xff09;是一种新兴的基于统计学原理的随机优化算法。 为什么要叫这个名字呢&#xff1f; 首先&#xff0c;“分布”指的就是概率分布。 其次&#xff0c;“估计”指的是这个概率分布…
阅读更多...
2023年【河北省安全员B证】新版试题及河北省安全员B证试题及解析

2023年【河北省安全员B证】新版试题及河北省安全员B证试题及解析

题库来源&#xff1a;安全生产模拟考试一点通公众号小程序 河北省安全员B证新版试题根据新河北省安全员B证考试大纲要求&#xff0c;安全生产模拟考试一点通将河北省安全员B证模拟考试试题进行汇编&#xff0c;组成一套河北省安全员B证全真模拟考试试题&#xff0c;学员可通过…
阅读更多...
C++STL----list的模拟实现

C++STL----list的模拟实现

文章目录 list模拟实现的大致框架节点类的模拟实现迭代器类的模拟实现迭代器类存在的意义迭代器类的模板参数说明运算符的重载--运算符的重载&#xff01;与运算符的重载*运算符的重载->运算符的重载 list的模拟实现默认成员函数迭代器相关函数元素修改相关函数front和backi…
阅读更多...
“KeyarchOS：国产Linux新星的崛起与创新之路“

“KeyarchOS：国产Linux新星的崛起与创新之路“

简介 KOS&#xff0c;也就是KeyarchOS&#xff0c;是一款由国内团队开发的服务器操作系统。它因为几个特点而受到我的青睐和一些用户的关注。 首先&#xff0c;KOS注重安全性和稳定性。它有一些防护和隔离功能&#xff0c;来帮助系统稳定运行&#xff0c;而且是中文语言更接地…
阅读更多...
从零开始的LINUX（三）

从零开始的LINUX（三）

bc&#xff1a;进行浮点数运算 uname&#xff1a;查看当前的操作系统 ctrlc&#xff1a;中止当前正在执行的程序 ctrld&#xff1a;退出xshell shutdown&#xff1a;关机 reboot&#xff1a;重启 shell外壳&#xff1a; 作用&#xff1a;1、命令解释&#xff08;将输入的程序…
阅读更多...
QSS 自定义QLineEdit

QSS 自定义QLineEdit

QSS 自定义QLineEdit Chapter1 QSS 自定义QLineEdit简述常用属性和伪状态效果图QSS源码参考 Chapter1 QSS 自定义QLineEdit 原文链接&#xff1a;https://blog.csdn.net/Staranywhere/article/details/107306276 简述 本文将通过简单示例介绍QLineEdit样式如何自定义。 常用…
阅读更多...
Linux高性能服务器编程——ch9笔记

Linux高性能服务器编程——ch9笔记

第9章 I/O复用 同时监听多个文件描述符&#xff0c;但本身是阻塞的。 9.1 select系统调用 在一段指定时间内&#xff0c;监听用户感兴趣的文件描述符上的可读、可写和异常等事件是否就绪。 :::tips int select(int nfds, fd_set* readfds, fd_set* writefds, fd_set* except…
阅读更多...
掌握 JavaScript：从初学者到高级开发者的完整指南之JavaScript对象（二）

掌握 JavaScript：从初学者到高级开发者的完整指南之JavaScript对象（二）

JavaScript基础知识 1. JavaScript对象1.1.1 基本对象1.1.1.1 Array对象语法格式特点属性和方法 1.1.1.2 String对象语法格式属性和方法 1.1.1.3 JSON对象自定义对象json对象 1. JavaScript对象 可以大体分页3大类&#xff1a; 第一类&#xff1a;基本对象,我们主要学习Array…
阅读更多...
【java学习—九】面向对象内容总结（8）

【java学习—九】面向对象内容总结（8）

文章目录
阅读更多...
Python---小海龟会画画---利用turtle（海龟）模块

Python---小海龟会画画---利用turtle（海龟）模块

1、小海龟模块 在Python3版本中&#xff0c;新增加了一个模块叫做turtle&#xff08;海龟&#xff09;&#xff0c;专门用于绘制图形图像 2、模块如何使用 ① 导入模块 import turtle② 使用turtle模块中已经定义好的方法 turtle.forward(数值) # 从左向右&#xff0c;绘制一…
阅读更多...
docker 部署 若依 Ruoyi springboot+vue分离版 dockerCompose

docker 部署 若依 Ruoyi springboot+vue分离版 dockerCompose

本篇从已有虚拟机/服务器 安装好dokcer为基础开始讲解 1.部署mysql 创建conf data init三个文件夹 conf目录存放在mysql配置文件 init目录存放着若依数据库sql文件&#xff08;从navicat导出的并非若依框架自带sql&#xff09; 创建一个属于本次若依部署的网段&#xff08;只…
阅读更多...
python：使用Scikit-image对遥感影像进行梯度特征提取（gradient）

python：使用Scikit-image对遥感影像进行梯度特征提取（gradient）

作者：CSDN @ _养乐多_ 在本博客中，我们将介绍如何使用Scikit-Image来进行梯度特征提取（gradient），并且提供一个示例代码，演示了如何在单波段遥感图像上应用这些方法。 梯度特征是指用于表示图像中亮度或颜色变化的特征。它包括两个关键成分：梯度幅值和梯度方向。梯度幅…
阅读更多...
吴恩达《机器学习》1-3:监督学习

吴恩达《机器学习》1-3:监督学习

一、监督学习 例如房屋价格的数据集。在监督学习中&#xff0c;我们将已知的房价作为"正确答案"&#xff0c;并将这些价格与房屋的特征数据一起提供给学习算法。学习算法使用这些已知答案的数据来学习模式和关系&#xff0c;以便在未知情况下预测其他房屋的价格。这就…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023