C++进阶（2）-函数

目录

一、函数提高

1.1函数默认参数

 1.2函数占位参数

1.3函数重载

1.3.1函数重载概述

 1.3.2函数重载注意事项

 二、类和对象

2.1封装

2.1.1封装的意义

2.1.2struct和class区别

 2.1.3成员属性设置为私有

2.1.4封装案例

 2.2对象的初始化和清理

2.2.1构造函数和析构函数

2.2.2构造函数的分类及调用

 2.2.3拷贝构造函数调用时机

2.2.4构造函数调用规则

 2.2.5深拷贝和浅拷贝

2.2.6初始化列表

2.2.7类对象作为类成员

2.2.8静态成员

2.3C++对象模型和this指针

2.3.1成员变量和成员函数分开存储

2.3.2this指针

未完待续。。。

一、函数提高

1.1函数默认参数

在C++中，函数的形参列表中的形参是可以有默认值的。

语法：返回值类型 函数名（参数 = 默认值）{ }

注意事项：

1、如果某个位置已经有了默认参数，那么从这个位置往后，从左到右都必须有默认值

2、如果函数声明有默认参数，函数实现就不能有默认参数（声明和实现只能有一个有默认参数）

#include<iostream>
using namespace std;//函数的默认参数
int func(int a, int b = 20, int c = 30) {return a + b + c;
}int main() {cout << func(10,30) << endl;//70system("pause");return 0;
}

 1.2函数占位参数

C++中函数的形参列表里可以有占位参数，用来做占位，调用函数时必须填补该位置

语法：返回值类型 函数名（数据类型）{ }

#include<iostream>
using namespace std;//占位参数
void func(int a, int) {cout << "this is func" << endl;
}int main() {func(10, 10);system("pause");return 0;
}

1.3函数重载

1.3.1函数重载概述

作用：函数名可以相同，提高复用性

函数重载满足条件：

①同一个作用域下②函数名称相同③函数参数类型不同或者个数不同或者顺序不同

注意：函数的返回值不可以作为函数重载的条件

#include<iostream>
using namespace std;//函数重载
void func() {cout << "调用func" << endl;
}void func(int a) {cout << "调用func(int a)" << endl;
}void func(double b) {cout << "调用func(double b)" << endl;
}void func(int a,double b) {cout << "调用func(int a,double b)" << endl;
}void func(double b,int a) {cout << "调用func(double b,int a)" << endl;
}int main() {func();func(10);func(3.14);func(3, 3.14);func(3.14, 3);system("pause");return 0;
}

 1.3.2函数重载注意事项

引用作为重载条件

函数重载碰到函数默认参数

#include<iostream>
using namespace std;//函数重载注意事项
//1、引用作为重载条件
void func(int& a) {cout << "调用func(int &a)" << endl;
}
void func(const int& a) {cout << "调用func(const int &a)" << endl;
}//2、函数重载碰到默认参数
void func2(int a,int b = 10) {cout << "调用func2(int a,int b = 10)" << endl;
}
void func2(int a) {cout << "调用func2(int a)" << endl;
}int main() {int a = 10;func(a);func(10);func2(10);//当函数重载碰到默认参数，报错system("pause");return 0;
}

 二、类和对象

C++面向对象三大特性：封装、继承、多态

C++认为万事万物皆为对象，对象上有其属性和行为

2.1封装

2.1.1封装的意义

①将属性和行为作为一个整体，表现生活中的事物

②将属性和行为加以权限控制

封装意义1：

在设计类的时候，属性和行为写在一起，表现事物

语法：class 类名{ 访问权限：属性/行为}

示例1：设计一个圆类，求圆的周长

#include<iostream>
using namespace std;const double PI = 3.14;class Circle {
public://属性int m_r;//行为double calculateZC() {return 2 * PI * m_r;}};int main() {//创建具体的对象Circle c1;c1.m_r = 10;cout << "圆的周长：" << c1.calculateZC() << endl;system("pause");return 0;
}

示例2：

设计一个学生类，属性有姓名和学号，可以给姓名和学号赋值，可以显示学生的姓名和学号

#include<iostream>
#include<string>
using namespace std;class Student {
public://属性string Name;int ID;//行为//打印姓名和学号void showNameID() {cout << "姓名：" << Name << "学号：" << ID << endl; }//设置姓名void setName(string name) {Name = name;}//设置学号void setID(int id) {ID = id;}};int main() {//创建具体的对象Student s1;s1.Name = "Jake";s1.ID = 1;s1.showNameID();Student s2;s2.setName("Marry");s2.setID(2);s2.showNameID();system("pause");return 0;
}

 封装意义2：

类在设计时，可以把属性和行为放在不同权限下，加以控制

访问权限有三种：

public        公共权限类内可以访问，类外可以访问
protected保护权限类内可以访问，类外不可以访问（儿子可以访问父亲中的保护内容）
private       私有权限类内可以访问，类外不可以访问（儿子不可以访问父亲中的保护内容）
#include<iostream>
#include<string>
using namespace std;class Person {
public:string Name;
protected:string Car;
private:int Password;public:void func() {Name = "张三";Car = "VWPOLO";Password = 123456;}};int main() {//创建具体的对象Person p1;p1.Name = "李四";//以下访问不到/*p1.Car = "YYC";p1.Password = 786808;*/system("pause");return 0;
}

2.1.2struct和class区别

默认的访问权限不同

struct默认权限为公共public

class默认权限为私有private 

#include<iostream>
#include<string>
using namespace std;class C1 {int m_A;//默认权限，私有
};struct C2 {int m_A;//默认权限，公共
};int main() {C1 c1;//c1.m_A = 100;//默认私有，不可访问C2 c2;c2.m_A = 100; //默认公共，可以访问system("pause");return 0;
}

 2.1.3成员属性设置为私有

优点1：将所有成员属性设置为私有，可以自己控制读写权限

优点2：对于写权限，可以检测数据的有效性

#include<iostream>
#include<string>
using namespace std;class Person {
private:string m_name;//姓名，可读可写int m_age;//年龄，可读可写string m_pet;//宠物，只写
public://设置姓名void setName(string name) {m_name = name;}//获取姓名string getName() {return m_name;}//设置年龄void setAge(int age) {if (age < 0 || age > 150) {m_age = 0;cout << "输入错误！" << endl;return;}m_age = age;}//获取年龄int getAge() {//m_age = 0;return m_age;}//设置宠物void setPet(string pet) {m_pet = pet;}
};int main() {Person p1;p1.setName("张三");p1.setPet("哈哈");p1.setAge(10);cout <<"姓名为："<< p1.getName() << endl;cout <<"年龄为："<< p1.getAge() << endl;system("pause");return 0;
}

2.1.4封装案例

案例一：设计立方体类（Cube），求出立方体的面积和体积，分别用全局函数和成员函数判断两个立方体是否相等。

#include<iostream>
#include<string>
using namespace std;class Cube {
private:int m_L;//长int m_W;//宽int m_H;//高
public://设置长宽高void setL(int L) {m_L = L;}void setW(int W) {m_W = W;}void setH(int H) {m_H = H;}//获取长宽高int getL() {return m_L;}int getW() {return m_W;}int getH() {return m_H;}//获取立方体表面积double getS() {return ((m_L * m_W) + (m_L * m_H) + (m_W * m_H)) * 2;}//获取立方体体积double getV() {return m_L * m_W * m_H;}//通过成员函数，判断两个立方体是否相等bool isSameByClass(Cube &c) {if (m_L == c.getL() && m_W == c.getW() && m_H == c.getH()) {return true;}return false;}
};//通过全局函数，判断两个立方体是否相等
bool isSame(Cube& c1, Cube& c2) {if (c1.getL() == c2.getL() && c1.getW() == c2.getW() && c1.getH() == c2.getH()) {return true;}return false;
}int main() {Cube c1;c1.setL(2);c1.setW(2);c1.setH(2);cout <<"表面积为："<< c1.getS() << endl;cout << "体积为：" << c1.getV() << endl;cout << "==============================" << endl;Cube c2;c2.setL(2);c2.setW(2);c2.setH(2);//全局函数判断bool ret1 = isSame(c1, c2);//成员函数判断bool ret2 = c1.isSameByClass(c2);if (ret1 && ret2) {cout << "c1与c2相等" << endl;}else {  cout << "c1与c2不相等" << endl;}system("pause");return 0;
}

案例二：点和圆 的关系 ，设计一个圆类（Circle），和一个点类（Point），计算点和圆的关系。

分文件编写

point.h

#pragma once
#include <iostream>
using namespace std;//点类
class Point {
private:int m_X;//x坐标int m_Y;//y坐标
public://设置获取X坐标void setX(int x);int getX();//设置获取Y坐标void setY(int y);int getY();
};

point.cpp

#include "point.h"//设置获取X坐标
void Point::setX(int x) {m_X = x;
}
int Point::getX() {return m_X;
}
//设置获取Y坐标
void Point::setY(int y) {m_Y = y;
}
int Point::getY() {return m_Y;
}

circle.h

#pragma once
#include <iostream>
#include "point.h"
using namespace std;//圆类
class Circle {
private:int m_R;//半径Point m_Center;//圆心public://设置获取半径void setR(int r);int getR();//设置获取圆心void setCenter(Point center);Point getCenter();};

circle.cpp

#include "circle.h"//设置获取半径
void Circle::setR(int r) {m_R = r;
}
int Circle::getR() {return m_R;
}
//设置获取圆心
void Circle::setCenter(Point center) {m_Center = center;
}
Point Circle::getCenter() {return m_Center;
}

main.cpp

 #include<iostream>
#include<string>
#include "point.h"
#include "circle.h"
using namespace std;点类
//class Point {
//private:
//	int m_X;//x坐标
//	int m_Y;//y坐标
//public:
//	//设置获取X坐标
//	void setX(int x) {
//		m_X = x;
//	}
//	int getX() {
//		return m_X;
//	}
//	//设置获取Y坐标
//	void setY(int y) {
//		m_Y = y;
//	}
//	int getY() {
//		return m_Y;
//	}
//};
//
圆类
//class Circle {
//private:
//	int m_R;//半径
//	Point m_Center;//圆心
//
//public:
//	//设置获取半径
//	void setR(int r) {
//		m_R = r;
//	}
//	int getR() {
//		return m_R;
//	}
//	//设置获取圆心
//	void setCenter(Point center) {
//		m_Center= center;
//	}
//	Point getCenter() {
//		return m_Center;
//	}
//
//};//判断圆和点的关系
void isInCircle(Circle& c, Point& p) {//计算两点之间距离的平方int distance = (c.getCenter().getX() - p.getX())* (c.getCenter().getX() - p.getX()) + (c.getCenter().getY() - p.getY()) * (c.getCenter().getY() - p.getY());//计算半径的平方int rDistance = c.getR() * c.getR();//判断if (distance == rDistance) {cout << "点在圆上" << endl;}else if (distance < rDistance) {cout << "点在圆内" << endl;}else {cout << "点在圆外" << endl;}
}int main() {//创建圆Circle c1;c1.setR(10);Point center;center.setX(10);center.setY(0);c1.setCenter(center);//创建点Point p1;p1.setX(10);p1.setY(9);isInCircle(c1, p1);system("pause");return 0;
}

 2.2对象的初始化和清理

2.2.1构造函数和析构函数

对象的初始化和清理是两个非常重要的安全问题

一个对象或者变量没有初始状态，其使用后果未知

使用完一个对象和变量，没有及时清理，也会造成安全问题

c++使用构造函数和析构函数解决上述问题，这两个函数被编译器自动调用，完成对象的初始化和清理工作

构造函数：主要作用于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用

析构函数：主要作用于对象销毁前系统自动调用，执行一些清理工作

构造函数语法：

类名（）{}

1、构造函数没有返回值也不写void

2、函数名称与类名相同

3、构造函数可以有参数，因此可以发生重载

4、程序在调用对象时候会自动调用构造，无需手动调用，且只调用一次

析构函数语法：

~类名（）{}

1、析构函数没有返回值也不写void

2、函数名称与类名相同，且在名称前加上符号~

3、析构函数不可以有参数，因此不可以发生重载

4、程序在对象销毁前会自动调用析构，无需手动调用，且只调用一次

#include<iostream>
#include<string>
using namespace std;class Person {
public://1、构造函数 进行初始化操作Person() {cout << "Person构造函数的调用" << endl;}//2、析构函数 进行清理操作~Person(){cout << "Person析构函数的调用" << endl;}
};//构造和析构都是必须要有的实现，如果自己不提供，编译器会提供一个空实现的构造和析构
void test01() {Person p;//栈上的数据，test01执行之后会释放这个对象
}int main() {test01();system("pause");return 0;
}

2.2.2构造函数的分类及调用

两种分类方式：

-按参数分为：有参构造和无参构造

-按类型分为：普通构造和拷贝构造

三种调用方式：

-括号法

-显示法

-隐式转换法

#include<iostream>
#include<string>
using namespace std;class Person {
public:int age;//1、构造函数 //按照参数分类：有参构造  无参构造（默认构造）//按类型分为：普通构造  拷贝构造//普通构造函数Person() {cout << "Person无参构造函数的调用" << endl;}Person(int a) {age = a;cout << "Person有参构造函数的调用" << endl;}//拷贝构造函数//将传入的对象身上的属性全部拷贝到自身上Person(const Person &p) {age = p.age;cout << "Person拷贝构造函数的调用" << endl;}//2、析构函数 进行清理操作~Person(){cout << "Person析构函数的调用" << endl;}
};//调用
void test01() {//1、括号法//Person p1;//无参调用//Person p2(10);//有参调用//Person p3(p2);//拷贝构造函数调用//cout << "p2的年龄为：" << p2.age << endl;//cout << "p3的年龄为：" << p3.age << endl;//注意事项：调用默认构造函数时不要加()//Person p1();//编译器会以为是函数的声明//2、显示法//Person p1;//无参调用//Person p2 = Person(10);//有参调用//Person p3 = Person(p2);//拷贝构造函数调用//Person(10);//匿名对象，当前执行结束后，系统立即回收匿名对象//注意事项：不要用拷贝构造函数初始化匿名对象//Person(p3);//编译器会转换为Person p3;对象的声明//3、隐式转换法Person p4 = 10;//相当于写了Person p4 = Person(10);Person p5 = p4;//拷贝构造函数}int main() {test01();system("pause");return 0;
}

 2.2.3拷贝构造函数调用时机

①使用一个已经创建完毕的对象来初始化一个新对象

②值传递的方式给函数参数传值

③以值方式返回局部对象

#include<iostream>
#include<string>
using namespace std;class Person {
public:int age;Person() {cout << "Person无参构造函数的调用" << endl;}Person(int a) {age = a;cout << "Person有参构造函数的调用" << endl;}//拷贝构造函数Person(const Person &p) {age = p.age;cout << "Person拷贝构造函数的调用" << endl;}//析构函数 进行清理操作~Person(){cout << "Person析构函数的调用" << endl;}
};//①使用一个已经创建完毕的对象来初始化一个新对象
void test01() {Person p1(10);Person p2(p1);cout << "p2的年龄：" << p2.age << endl;
}//②值传递的方式给函数参数传值
void doWork(Person p) {}
void test02() {Person p;doWork(p);
}//③以值方式返回局部对象
Person doWork2() {Person p1;return p1;
}
void test03() {Person p = doWork2();
}int main() {//test01();//test02();test03();system("pause");return 0;
}

2.2.4构造函数调用规则

默认情况下，c++编译器会至少给一个类添加3个函数

1.默认构造函数（无参，函数体为空）

2.默认析构函数（无参，函数体为空）

3.默认拷贝析构函数，对属性进行值拷贝

构造函数调用规则如下：

1、如果用户定义有参构造函数，则编译器不提供默认无参构造函数，但是会提供默认拷贝构造

2、如果用户定义拷贝构造函数，则编译器不提供其他构造函数

 2.2.5深拷贝和浅拷贝

浅拷贝：简单的赋值拷贝操作

深拷贝：在堆区重新申请空间，进行拷贝操作

浅拷贝的问题：堆区的数据被两次释放，非法 

解决方法：在堆区重新开辟一块空间，也就是深拷贝 

总结：如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝的问题

#include<iostream>
#include<string>
using namespace std;class Person {
public:int age;//年龄int* height;//身高Person() {cout << "Person无参构造函数的调用" << endl;}Person(int a,int h) {age = a;height = new int(h);cout << "Person有参构造函数的调用" << endl;}//自己实现拷贝构造函数，解决浅拷贝的问题Person(const Person& p) {cout << "Person拷贝构造函数的调用" << endl;age = p.age;//height = p.height;//编译器默认实现height = new int(*p.height);//深拷贝}//析构函数~Person() {//将堆区数据释放if (height != NULL) {delete height;height = NULL;}cout << "Person析构函数的调用" << endl;}
};void test01() {Person p1(18,183);cout << "p1的年龄为：" << p1.age << endl;cout << "p1的身高为：" << *p1.height << endl;Person p2(p1);cout << "p2的年龄为：" << p2.age << endl;cout << "p2的身高为：" << *p2.height << endl;}int main() {test01();system("pause");return 0;
}

2.2.6初始化列表

作用：C++提供了初始化列表语法，用来初始化属性

语法：构造函数():属性1(值1),属性2(值2),...{}

#include<iostream>
#include<string>
using namespace std;class Person {
public:int m_A;int m_B;int m_C;//传统初始化/*Person(int a,int b,int c) {m_A = a;m_B = b;m_C = c;cout << "Person有参构造函数的调用" << endl;}*///初始化列表/*Person() :m_A(10), m_B(20), m_C(30) {}*/Person(int a,int b,int c) :m_A(a), m_B(b), m_C(c) {}
};void test01() {//Person p1(1,3,2);//Person p1;Person p1(2,3,4);cout << "m_A为：" << p1.m_A << endl;cout << "m_B为：" << p1.m_B << endl;cout << "m_C为：" << p1.m_C << endl;}int main() {test01();system("pause");return 0;
}

2.2.7类对象作为类成员

C++类中的成员可以是另一个类的对象，此成员称为对象成员

#include<iostream>
#include<string>
using namespace std;class Phone {
public:string m_Pname;//品牌Phone(string pname){m_Pname = pname;}
};class Person {
public:string m_Name;//姓名Phone m_Phone;//手机//隐式 Person m_Phone = pName;Person(string name, string pname) :m_Name(name), m_Phone(pname) {}};void test01() {Person p("张三", "苹果15PROMAX");cout << p.m_Name << "拿着" << p.m_Phone.m_Pname << endl;
}int main() {test01();system("pause");return 0;
}

先有手机的构造，再有人的构造

先有人的析构，再有手机的析构

2.2.8静态成员

静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员。

静态成员分为：

①静态成员变量
-所有对象共享同一份数据

-在编译阶段分配内存

-类内声明，类外初始化

#include<iostream>
#include<string>
using namespace std;class Person {
public:static int m_A;	
private:static int m_B;
};
int Person::m_A = 100;//类外声明
int Person::m_B = 200;//共享数据
void test01() {Person p1;cout << p1.m_A << endl;Person p2;p2.m_A = 200;cout << p1.m_A << endl;//cout << p1.m_B << endl;//私有，类外无法访问
}//两种访问方式
void test02() {//1.通过对象访问Person p1;cout << p1.m_A << endl;//2.通过类名访问cout << Person::m_A << endl;
}int main() {//test01();test02();system("pause");return 0;
}

②静态成员函数

-所有对象共享同一个函数

-静态成员函数只能访问静态成员变量

#include<iostream>
#include<string>
using namespace std;class Person {
public://静态成员函数static void func() {m_A = 100;//静态成员函数可以访问静态成员变量//m_B = 99;//静态成员函数不可以访问非静态成员变量cout << "静态成员函数调用" << endl;}static int m_A;//静态成员变量int m_B;//非静态成员变量//静态成员函数也是有访问权限的
private:static void func2() {}
};
int Person::m_A = 0;void test01() {//1.通过对象调用Person p1;p1.func();Person p2;p2.func();//2.通过类名调用Person::func();//Person::func2();//权限问题，不可访问
}int main() {test01();system("pause");return 0;
}

2.3C++对象模型和this指针

2.3.1成员变量和成员函数分开存储

C++中，成员变量和成员函数分开存储，只有非静态成员变量才属于类的对象上面

#include<iostream>
#include<string>
using namespace std;class Person {int m_A;static int m_B;//静态成员变量不属于类的对象上void func(){}//非静态成员函数不属于类的对象上
};
int Person::m_B = 100;void test01() {Person p;//空对象占用的内存空间   //为了区分空对象占内存的位置//每个空对象会有一个独一无二的内存地址cout << "size of p = " << sizeof(p) << endl;//1 字节
}void test02() {Person p;cout << "size of p = " << sizeof(p) << endl;//4 字节
}//静态成员变量不属于类的对象上
void test03() {Person p;cout << "size of p = " << sizeof(p) << endl;//4 字节
}int main() {//test01();//test02();test03();system("pause");return 0;
}

2.3.2this指针

this指针指向被调用的成员函数所属的对象

用途：

①当形参和成员变量同名时，可用this来区分

②在类的非静态成员函数中返回对象本身，可用return *this;

未完待续。。。

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

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

相关文章

eNSP防火墙配置实验（trust、DMZ、untrust）

eNSP防火墙配置实验（trust、DMZ、untrust）

【拓扑】 设备 接口 IP地址/子网掩码/网关 AR1 G0/0/0 10.1.3.2/24 G0/0/1 100.1.1.2/24 FW1 G0/0/0 192.168.166.254/24 G1/0/0 10.1.1.1/24&#xff0c;trust域 G1/0/1 10.1.2.1/24&#xff0c;DMZ域 G1/0/2 100.1.3.1/24&#xff0c;untrust域 LSW1 G0/0/…
阅读更多...
大孔树脂与凝胶型树脂的区别及应用

大孔树脂与凝胶型树脂的区别及应用

在工业和环境工程中&#xff0c;离子交换树脂被广泛用于处理水和废水&#xff0c;去除有害的化学物质。两种常见的离子交换树脂类型是大孔树脂和凝胶型树脂。尽管它们在功能上有所重叠&#xff0c;但在物理结构、性能和应用领域上存在显著差异。本文将探讨这两种树脂的特点、区…
阅读更多...
微服务组件-注册中心

微服务组件-注册中心

微服务组件-注册中心 使用restTemplate实现远程服务调用存在以下的问题&#xff1a; 1、消费者不知道如何获取服务提供者具体信息。 2、在远程调用的过程中&#xff0c;直接采用填写url的硬编码方式&#xff0c;如果服务消费者发生变化&#xff0c;得到的结果就会出错。 3、如果…
阅读更多...
vue+element作用域插槽

vue+element作用域插槽

作用域插槽的样式由父组件决定&#xff0c;内容却由子组件控制。 在el-table使用作用域插槽 <el-table><el-table-column slot-scope" { row, column, $index }"></el-table-column> </el-table>在el-tree使用作用域插槽 <el-tree>…
阅读更多...
基于SpringBoot+Vue的二手车交易系统的设计与实现（源码+文档+包运行）

基于SpringBoot+Vue的二手车交易系统的设计与实现（源码+文档+包运行）

一.系统概述 如今社会上各行各业&#xff0c;都喜欢用自己行业的专属软件工作&#xff0c;互联网发展到这个时候&#xff0c;人们已经发现离不开了互联网。新技术的产生&#xff0c;往往能解决一些老技术的弊端问题。因为传统二手车交易信息管理难度大&#xff0c;容错率低&…
阅读更多...
初识ansible核心模块

初识ansible核心模块

目录 1、ansible模块 1.1 ansible常用模块 1.2 ansible-doc -l 列出当前anisble服务所支持的所有模块信息&#xff0c;按q退出 1.3 ansible-doc 模块名称 随机查看一个模块信息 2、运行临时命令 2.1 ansible命令常用的语法格式 3、常用模块详解与配置实例 3.1命令与…
阅读更多...
​宁德时代：用一块电池玩转两个万亿赛道

​宁德时代：用一块电池玩转两个万亿赛道

2022 到 2023 连续两年&#xff0c;被称为国内储能行业的大储&#xff08;发电侧、电网侧&#xff09;元年和中储&#xff08;工商业&#xff09;元年&#xff0c;整个储能行业可谓是异常火爆&#xff0c;众多资本或企业纷纷涌入该赛道。 对于行业从业者来说&#xff0c;所从事…
阅读更多...
力扣HOT100 - 206. 反转链表

力扣HOT100 - 206. 反转链表

解题思路&#xff1a; 迭代&#xff08;双指针&#xff09; class Solution {public ListNode reverseList(ListNode head) {ListNode cur head, pre null;while(cur ! null) {ListNode tmp cur.next; // 暂存后继节点 cur.nextcur.next pre; // 修改 next 引用指…
阅读更多...
MOSFET效应管

MOSFET效应管

【学习笔记】 金属氧化物半导体场效应晶体管&#xff08;Metal Oxide Semiconductor Field Effect Transistor&#xff0c;简称MOSFET&#xff09; MOSFET是三个端子器件&#xff0c;具有栅极、漏极和源极&#xff0c;栅极端子与漏极和源极之间的主导电流通道电气隔离&#xf…
阅读更多...
连锁服装店用哪个进销存软件好

连锁服装店用哪个进销存软件好

连锁服装店的进销存管理对于业务的高效运作至关重要&#xff0c;而选择合适的进销存软件能够极大地提升管理效率和经营水平。本文将介绍四款优秀的进销存软件&#xff0c;并重点关注商淘云连锁服装进销存管理系统&#xff0c;探讨其特点和优势。 1. 商淘云连锁服装进销存管理系…
阅读更多...
喜报｜炼石入选2024中国网络安全全景图 密码与数据安全六领

喜报｜炼石入选2024中国网络安全全景图 密码与数据安全六领

2024年4月12日&#xff0c;国内专业安全媒体安全牛发布《中国网络安全行业全景图&#xff08;第十一版&#xff09;》。第十一版全景图划分了16个一级安全分类和108个二级安全分类&#xff0c;汇集了510家安全厂商申报&#xff0c;实际收录为454家。全景图综合考量了产品的实用…
阅读更多...
一文读懂uniapp中的tabBar底部导航

一文读懂uniapp中的tabBar底部导航

目录 1. 基本知识2. Demo 1. 基本知识 UniApp 中的 tabBar 是用来在应用程序底部显示可切换的选项卡的组件&#xff0c;通常用于实现底部导航栏 允许用户通过点击不同的选项卡来切换应用程序的不同页面或功能模块 其代码如下&#xff1a; "tabBar":{"color&q…
阅读更多...
深入解析Rivest Cipher 4：理论与实践

深入解析Rivest Cipher 4：理论与实践

title: 深入解析Rivest Cipher 4&#xff1a;理论与实践 date: 2024/4/17 20:30:58 updated: 2024/4/17 20:30:58 tags: 密码学RC4算法流密码密钥调度安全分析优缺点应用实践 第一章&#xff1a;引言 密码学简介&#xff1a; 密码学是研究如何保护通信和信息安全的学科。它涉…
阅读更多...
# 从浅入深 学习 SpringCloud 微服务架构（一）基础知识

# 从浅入深 学习 SpringCloud 微服务架构（一）基础知识

从浅入深 学习 SpringCloud 微服务架构&#xff08;一&#xff09;基础知识 1、系统架构演变&#xff1a; 1&#xff09;单体应用架构。如电商项目。 用户管理、商品管理、订单管理&#xff0c;在一个模块里。 优点&#xff1a;开发简单&#xff0c;快速&#xff0c;适用于…
阅读更多...
React中redux、react-redux、@reduxjs/toolkit状态管理库的使用方式

React中redux、react-redux、@reduxjs/toolkit状态管理库的使用方式

效果 下载依赖 npm install redux react-redux reduxjs/toolkit --save在src目录下创建文件 创建index.ts文件 import { configureStore } from reduxjs/toolkit import userSlice from ./userReducerconst store configureStore({reducer: {user: userSlice.reducer} }) //…
阅读更多...
代码随想录算法训练营第四十三天| LeetCode 1049.最后一块石头的重量II、494. 目标和、474.一和零

代码随想录算法训练营第四十三天| LeetCode 1049.最后一块石头的重量II、494. 目标和、474.一和零

一、LeetCode 1049.最后一块石头的重量II 文章讲解/视频讲解&#xff1a;https://programmercarl.com/1049.%E6%9C%80%E5%90%8E%E4%B8%80%E5%9D%97%E7%9F%B3%E5%A4%B4%E7%9A%84%E9%87%8D%E9%87%8FII.html#%E6%80%9D%E8%B7%AF 状态&#xff1a;已解决 1.思路 其实这个题跟上个题…
阅读更多...
ssm056基于Java语言校园快递代取系统的设计与实现+jsp

ssm056基于Java语言校园快递代取系统的设计与实现+jsp

校园快递代取系统设计与实现 摘 要 现代经济快节奏发展以及不断完善升级的信息化技术&#xff0c;让传统数据信息的管理升级为软件存储&#xff0c;归纳&#xff0c;集中处理数据信息的管理方式。本校园快递代取系统就是在这样的大环境下诞生&#xff0c;其可以帮助管理者在短…
阅读更多...
4核8G配置服务器多少钱？2024年阿里云服务器700元1年价格便宜

4核8G配置服务器多少钱？2024年阿里云服务器700元1年价格便宜

4核8G配置服务器多少钱&#xff1f;2024年阿里云服务器700元1年价格便宜。阿里云4核8G服务器租用优惠价格700元1年&#xff0c;配置为ECS通用算力型u1实例&#xff08;ecs.u1-c1m2.xlarge&#xff09;4核8G配置、1M到3M带宽可选、ESSD Entry系统盘20G到40G可选&#xff0c;CPU采…
阅读更多...
Linux下的权限：论老流氓root的存在

Linux下的权限：论老流氓root的存在

文章目录 用户身份切换提权 权限管理文件访问者文件访问权限文件类型目录权限默认权限粘滞位 用户 Linux下有两中用户&#xff1a;超级用户&#xff08;root&#xff09;、普通用户 超级用户&#xff1a;可以在Linux系统下做任何事情&#xff0c;不受到限制普通用户&#xff…
阅读更多...
Java PDF文件流传输过程中速度很慢，如何解决？

Java PDF文件流传输过程中速度很慢，如何解决？

专栏集锦&#xff0c;大佬们可以收藏以备不时之需&#xff1a; Spring Cloud 专栏&#xff1a;http://t.csdnimg.cn/WDmJ9 Python 专栏&#xff1a;http://t.csdnimg.cn/hMwPR Redis 专栏&#xff1a;http://t.csdnimg.cn/Qq0Xc TensorFlow 专栏&#xff1a;http://t.csdni…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023