C++_02

1、类

1.1 什么是类

        C++ 中的类(class)是一种编程结 构,用于创建对象。这些对象可以拥有属性(即数据成员)和行为(即成员函数或方法)。类的概念是面向对象编程的核心之一,其主要目的是将数据和与数据相关的操作封装在一起。例如,如果你有一个“汽车”类,它可能包含颜色、品牌、型号等属性(数据成员),以及启动、停止、加速等行为(成员函数)。每当你基于这个类创建一个对象时,你就有了一个具体的汽车,具有这些属性和行为。  

        C++  类的基本结构通常包含:

        (1)数据成员(Attributes):定义类的属性。这些是类内部的变量,用于存储对象的状态。

        (2)成员函数(Methods:定义类的行为。这些是可以操作对象的数据成员的函数。

        (3)构造函数和析构函数:特殊的成员函数。构造函数在创建对象时自动调用,用于初始化对象。析构函数在对象销毁时调用,用于执行清理操作。

        (4)访问修饰符:如 public , private , protected ,用于控制对类成员的访问权限。例如, public成员可以在类的外部访问,而 private 成员只能在类内部访问。

        (5)继承:允许一个类继承另一个类的特性。这是代码重用和多态性的关键。

        通过这些特性,C++ 类提供了一种强大的方式来组织和处理数据,使得代码更加模块化、易于理解和维护。 

1.2 从结构体引入类

1.2.1 C中使用结构体

        如果用C语言实现上面描述的汽车类,实现代码如下:

#include <stdio.h>
#include <stdlib.h>struct Car{ //汽车“类”char *color; //颜色char *brand; //品牌char *type; //车型int year; //年限void (*printCarInfo)(char *color,char *brand,char *type, int year); //函数指针,指向车介绍函数void (*carRun)(char *type); //函数指针,指向车运行的函数void (*carStop)(char *type); //函数指针,执行车停止的函数
};void bwmThreePrintCarInfo(char *color,char *brand,char *type, int year)
{printf("车的品牌是:%s, 型号是: %s, 颜色是:%s,上市年限是%d\n", brand,type,color,year);
}void A6PrintCarInfo(char *color,char *brand,char *type, int year)
{printf("车的品牌是:%s,型号是: %s, 颜色是:%s, 上市年限是%d\n", brand,type,color,year);
}int main()
{struct Car BWMthree;BWMthree.color = "白色";BWMthree.brand = "宝马";BWMthree.type = "3系";BWMthree.year = 2023;BWMthree.printCarInfo = bwmThreePrintCarInfo;BWMthree.printCarInfo(BWMthree.color,BWMthree.brand,BWMthree.type,BWMthree.year);struct Car *AodiA6;AodiA6 = (struct Car*)malloc(sizeof(struct Car));AodiA6->color = "黑色";AodiA6->brand = "奥迪";AodiA6->type = "A6";AodiA6->year = 2008;AodiA6->printCarInfo = A6PrintCarInfo;AodiA6->printCarInfo(AodiA6->color,AodiA6->brand,AodiA6->type,AodiA6->year);return 0;
}

1.2.2 C++中使用结构体

        新建一个C++文件直接来执行上述代码,会有一些问题。

        在C++中字符串用string来表示,要修改所有char *为 string类型;

        在修改后,会发现现printf%s控制位,不能用于string的输出,即使有string构建了即将要输出的字符串;

        C++中,通过std::tostring()函数,将整型数转化成字符串;

        在printInfo中使用cout输出汽车信息;

        发现在C++工程中,使用malloc在堆申请结构体空间有问题,所以直接在此引入类的概念,把struct改成class;

        引入新问题,class的成员数据和成员函数在不指定权限的情况下,默认private权限,类的对象无法进行直接访问,因此要添加public属性;

访问权限
类内部
同一个类的对象
派生类(子类)
类外部
public
✔️ 可访问
✔️ 可访问
✔️ 可访问
✔️ 可访问
private
✔️ 可访问
不可访问
不可访问
不可访问
protected
✔️ 可访问
不可访问
✔️ 可访问
不可访问

        把main函数中的原本结构体变量改成了类的实例化,如果变量类型是指针,把原来的malloc改成new一个对象。

        最终修改完的代码如下:

#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <iostream>using namespace std;class Car{ //汽车“类”
public:string color; //颜色string brand; //品牌string type; //车型int year; //年限void (*printCarInfo)(string color,string brand,string type, int year); //函数指针,指向车介绍函数void (*carRun)(string type); //函数指针,指向车运行的函数void (*carStop)(string type); //函数指针,执行车停止的函数
};void bwmThreePrintCarInfo(string color,string brand,string type, int year)
{string str = "车的品牌是:" + brand+ ",型号是: " + type+ ",颜色是:" + color+ ",上市年限是:" + std::to_string(year);cout << str << endl;
}void A6PrintCarInfo(string color,string brand,string type, int year)
{string str = "车的品牌是:" + brand+ ",型号是: " + type+ ",颜色是:" + color+ ",上市年限是:" + std::to_string(year);cout << str << endl;
}int main()
{Car BWMthree;BWMthree.color = "白色";BWMthree.brand = "宝马";BWMthree.type = "3系";BWMthree.year = 2023;BWMthree.printCarInfo = bwmThreePrintCarInfo;BWMthree.printCarInfo(BWMthree.color,BWMthree.brand,BWMthree.type,BWMthree.year);Car *AodiA6 = new Car();// AodiA6 = (struct Car*)malloc(sizeof(struct Car));AodiA6->color = "黑色";AodiA6->brand = "奥迪";AodiA6->type = "A6";AodiA6->year = 2008;AodiA6->printCarInfo = A6PrintCarInfo;AodiA6->printCarInfo(AodiA6->color,AodiA6->brand,AodiA6->type,AodiA6->year);return 0;
}

1.2.3 真正的成员函数

        在上一小节中的代码中,void (*printCarInfo)(string color,string brand,string type, int year);是一个指针变量,是保存某个函数地址的变量,所以它不是成员函数,是成员数。

        真正的成员函数遵守封装特性,在函数体内部访问成员数据的时候,不需要参数传递。

        在C++ 中,双冒号 :: 称为 "作用域解析运算符"Scope Resolution Operator)。它用于指定一个成员(如函数或变量)属于特定的类或命名空间。例如,在类的外部定义成员函数时, :: 用于 指明该函数属于哪个类。

#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <iostream>using namespace std;class Car{ //汽车“类”
public://成员数据string color; //颜色string brand; //品牌string type; //车型int year; //年限//其实也是成员数据,指针变量,指向函数的变量,并非真正的成员函数void (*printCarInfo)(string color,string brand,string type, int year); //函数指针,指向车介绍函数void (*carRun)(string type); //函数指针,指向车运行的函数void (*carStop)(string type); //函数指针,执行车停止的函数void realPrintCarInfo();//声明成员函数
};void Car::realPrintCarInfo() //在类的外部进行成员函数的实现
{string str = "车的品牌是:" + brand+ ",型号是: " + type+ ",颜色是:" + color+ ",上市年限是:" + std::to_string(year);cout << str << endl;
}void bwmThreePrintCarInfo(string color,string brand,string type, int year)
{string str = "车的品牌是:" + brand+ ",型号是: " + type+ ",颜色是:" + color+ ",上市年限是:" + std::to_string(year);cout << str << endl;
}void A6PrintCarInfo(string color,string brand,string type, int year)
{string str = "车的品牌是:" + brand+ ",型号是: " + type+ ",颜色是:" + color+ ",上市年限是:" + std::to_string(year);cout << str << endl;
}int main()
{Car BWMthree;BWMthree.color = "白色";BWMthree.brand = "宝马";BWMthree.type = "3系";BWMthree.year = 2023;BWMthree.printCarInfo = bwmThreePrintCarInfo;BWMthree.printCarInfo(BWMthree.color,BWMthree.brand,BWMthree.type,BWMthree.year);BWMthree.realPrintCarInfo();Car *AodiA6 = new Car();// AodiA6 = (struct Car*)malloc(sizeof(struct Car));AodiA6->color = "黑色";AodiA6->brand = "奥迪";AodiA6->type = "A6";AodiA6->year = 2008;AodiA6->printCarInfo = A6PrintCarInfo;AodiA6->printCarInfo(AodiA6->color,AodiA6->brand,AodiA6->type,AodiA6->year);AodiA6->realPrintCarInfo();return 0;
}

1.3 组合

        在C++中,一个类包含另一个类的对象称为组合(Composition)。这是一种常见的设计模式,用 于表示一个类是由另一个类的对象组成的。这种关系通常表示一种"拥有"("has-a")的关系。

        普通变量访问成员变量或者成员函数,使用 “ . ” 运算符;

        指针变量访问成员变量或者成员函数,使用“ -> ”运算符,像C语言的结构体用法

#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <iostream>using namespace std;class Wheel
{
public:string brand;int year;void wheelPrintInfo();
};void Wheel::wheelPrintInfo()
{cout << "我的轮胎品牌是:" << brand << endl;cout << "我的轮胎日期是:" << year << endl;
}//在 C++中,一个类包含另一个类的对象称为组合(Composition)。
class Car{ //汽车“类”
public://成员数据string color; //颜色string brand; //品牌string type; //车型int year; //年限Wheel wl;Wheel *pwl;//其实也是成员数据,指针变量,指向函数的变量,并非真正的成员函数void (*printCarInfo)(string color,string brand,string type, int year); //函数指针,指向车介绍函数void (*carRun)(string type); //函数指针,指向车运行的函数void (*carStop)(string type); //函数指针,执行车停止的函数void realPrintCarInfo();//声明成员函数
};void Car::realPrintCarInfo() //在类的外部进行成员函数的实现
{string str = "车的品牌是:" + brand+ ",型号是: " + type+ ",颜色是:" + color+ ",上市年限是:" + std::to_string(year);cout << str << endl;
}void bwmThreePrintCarInfo(string color,string brand,string type, int year)
{string str = "车的品牌是:" + brand+ ",型号是: " + type+ ",颜色是:" + color+ ",上市年限是:" + std::to_string(year);cout << str << endl;
}void A6PrintCarInfo(string color,string brand,string type, int year)
{string str = "车的品牌是:" + brand+ ",型号是: " + type+ ",颜色是:" + color+ ",上市年限是:" + std::to_string(year);cout << str << endl;
}int main()
{Car BWMthree;BWMthree.color = "白色";BWMthree.brand = "宝马";BWMthree.type = "3系";BWMthree.year = 2023;//类里面的对象如果是指针,也要new一下BWMthree.pwl = new Wheel();BWMthree.pwl->brand = "米其林";BWMthree.pwl->year = 2023;//BWMthree.wl.brand = "米其林";//BWMthree.wl.year = 2023;BWMthree.printCarInfo = bwmThreePrintCarInfo;BWMthree.printCarInfo(BWMthree.color,BWMthree.brand,BWMthree.type,BWMthree.year);BWMthree.realPrintCarInfo();//BWMthree.wl.wheelPrintInfo();Car *AodiA6 = new Car();// AodiA6 = (struct Car*)malloc(sizeof(struct Car));AodiA6->color = "黑色";AodiA6->brand = "奥迪";AodiA6->type = "A6";AodiA6->year = 2008;AodiA6->printCarInfo = A6PrintCarInfo;AodiA6->pwl = new Wheel;AodiA6->pwl->brand = "普利司通";AodiA6->pwl->year = 2012;//AodiA6->wl.brand = "马牌";//AodiA6->wl.year = 2023;AodiA6->printCarInfo(AodiA6->color,AodiA6->brand,AodiA6->type,AodiA6->year);AodiA6->realPrintCarInfo();//AodiA6->wl.wheelPrintInfo();AodiA6->pwl->wheelPrintInfo();return 0;
}

2、权限初识

2.1 基本介绍

        C++的访问权限主要分为三种: public private protected 。这些权限决定了类成员(包括数据成员和成员函数)的可访问性。

访问权限
类内部
同一个类的对象
派生类(子类)
类外部
public
✔️ 可访问
✔️ 可访问
✔️ 可访问
✔️ 可访问
private
✔️ 可访问
不可访问
不可访问
不可访问
protected
✔️ 可访问
不可访问
✔️ 可访问
不可访问

        使用权限(如 public private protected )在C++中是一种关键的封装手段,它们旨在控制对类成员的访问。下面是一个表格,总结了使用权限的主要好处和潜在缺点:

好处 / 缺点
描述
好处
封装性
通过隐藏类的内部实现(私有和受保护成员),提高了代码的安全性和健壮性。
接口与实现的分离
公开接口(公开成员)与私有实现分离,有助于用户仅关注于如何使用类而不是如何实现。
易于维护
修改类的内部实现不会影响使用该类的代码,从而降低了维护成本。
控制读写访问
通过设置访问权限,可以精确控制类成员的读写访问。
继承的灵活性
protected 成员在派生类中是可访问的,使得继承更加灵活。
缺点
增加复杂性
过度使用或不当使用权限可能导致代码结构复杂,难以理解。
测试难度
私有成员的测试比公共成员更困难,因为它们不能从类的外部访问。
灵活性降低
过于严格的封装可能限制了某些有效的用法,降低了灵活性。
可能导致紧耦合
过多依赖 friend 类或函数可能导致类之间的耦合过紧。

2.2 简单示例

        public权限相当于我们学习C语言结构体一样,不考虑访问权限的存在,但是要注意,类中不写权限,默认是私有权限。

        假设一个场景:银行的账户是一个模板,是一个类,有存款人信息和账户额度,而具体的存款人视为一个对象, 一个对象不能私自修改账户额度,需要通过一个操作流程,比如去ATM或者柜台进行操作才能修改到账户额度,所以,存款人信息和账户额度设计成私有权限,通过公有的操作流程,也就是公有函数去操作私有变量。基于这个场景,我们编程实现代码。

#include <iostream>
#include <string>using namespace std;class BankAccount{
private://有存款人信息和账户额度string name;string addr;int age;double balance;public:string bankAddr;//比如去ATM或者柜台进行操作才能修改到账户额度void registerMes(string newName, string newAddr,int newAge,double newBalance);void withdraw(double amount);void deposit(double amount);double getBalance();void printUserInfo();
};void BankAccount::printUserInfo()
{string mesTem = "账户名:" + name + ",地址:" + addr +",年龄:"+ std::to_string(age) + ",存款:" + std::to_string(balance);cout << mesTem << endl;
}void BankAccount::registerMes(string newName, string newAddr,int newAge,double newBalance)
{name = newName;addr = newAddr;age = newAge;balance = newBalance;
}// 存款方法
void BankAccount::deposit(double amount) {if (amount > 0) {balance += amount;} else {cerr << "Deposit amount must be positive." << endl;}
}// 取款方法
void BankAccount::withdraw(double amount) {if (amount > balance) {cerr << "Insufficient funds." << endl;} else if (amount <= 0) {cerr << "Withdrawal amount must be positive." << endl;} else {balance -= amount;}
}// 获取当前余额的方法
double BankAccount::getBalance() {return balance;
}int main()
{BankAccount user1;user1.registerMes("老A","深圳光明区",35,100);user1.printUserInfo();user1.deposit(1000);cout << user1.getBalance() << endl;user1.withdraw(30);cout << user1.getBalance() << endl;return 0;
}

        在这个示例中, balance 是一个 private 成员变量,它不能被类的外部直接访问。这保证了账户余额只能通过类提供的方法(如 deposit , withdraw , getBalance )来修改和查询,从而防止了不合适的修改,比如直接设置余额为负数或任意值。这样的设计保证了类的封装性和数据的完整性。

3、引用

3.1 引用和指针的区别

        引用变量是一个别名,也就是说,它是某个已存在变量的另一个名字。一旦把引用初始化为某个变量,就可以使用该引用名称或变量名称来指向变量。

        在C语言中,一个数据对应一个内存,通过由一个变量名来访问这个内存空间的数据,叫做直接访问,相对直接访问,有个间接访问的说法,叫做指针。

        而引用相当于又给这个内存中的数据提供了一个新的变量名,而且这个变量名功能比传统变量名更特殊,是直达地址的。

        主要区别:

        (1)不存在空引用。引用必须连接到一块合法的内存。

        (2)一旦引用被初始化为一个对象,就不能被指向到另一个对象。指针可以在任何时候指向到另一个对象。

        (3)引用必须在创建时被初始化。指针可以在任何时间被初始化。

//使用 & 进行引用
int& r = i;    //r 是一个初始化为 i 的整型引用
double& s = d;    //s 是一个初始化为 d 的 double 型引用
#include <iostream>using namespace std;int main ()
{// 声明简单的变量int i;double d;// 声明引用变量int& r = i;double& s = d;i = 5;cout << "Value of i : " << i << endl;cout << "Value of i reference : " << r << endl;d = 11.7;cout << "Value of d : " << d << endl;cout << "Value of d reference : " << s << endl;return 0;
}

3.2 将引用作为参数

#include <iostream>using namespace std;// 函数声明
void swap(int& x, int& y);int main ()
{// 局部变量声明int a = 100;int b = 200;cout << "交换前,a 的值:" << a << endl;cout << "交换前,b 的值:" << b << endl;/* 调用函数来交换值 */swap(a, b);cout << "交换后,a 的值:" << a << endl;cout << "交换后,b 的值:" << b << endl;return 0;
}// 函数定义
void swap(int& x, int& y)
{int temp;temp = x; /* 保存地址 x 的值 */x = y; /* 把 y 赋值给 x */y = temp; /* 把 x 赋值给 y */return 0;
}

3.3 将引用作为返回值

        通过使用引用来替代指针,会使 C++ 程序更容易阅读和维护。C++ 函数可以返回一个引用,方式与返回一个指针类似。

        当函数返回一个引用时,则返回一个指向返回值的隐式指针。这样,函数就可以放在赋值语句的左边。

#include <iostream>using namespace std;double vals[] = {10.1, 12.6, 33.1, 24.1, 50.0};double& setValues(int i) {double& ref = vals[i];return ref; // 返回第 i 个元素的引用,ref 是一个引用变量,ref 引用 vals[i]
}// 要调用上面定义函数的主函数
int main ()
{cout << "改变前的值" << endl;for ( int i = 0; i < 5; i++ ){cout << "vals[" << i << "] = ";cout << vals[i] << endl;}setValues(1) = 20.23; // 改变第 2 个元素setValues(3) = 70.8; // 改变第 4 个元素cout << "改变后的值" << endl;for ( int i = 0; i < 5; i++ ){cout << "vals[" << i << "] = ";cout << vals[i] << endl;}return 0;
}

        当返回一个引用时,要注意被引用的对象不能超出作用域。所以返回一个对局部变量的引用是不合法的,但是,可以返回一个对静态变量的引用。

int& func() {int q;//! return q; // 在编译时发生错误static int x;return x; // 安全,x 在函数作用域外依然是有效的
}

4、重载

4.1 函数重载

        在同一个作用域内,可以声明几个功能类似的同名函数,这些同名函数的形式参数(指参数的个数、类型或者顺序)必须不同,不能仅通过返回类型的不同来重载函数。

        在下面的例子中,同名函数 print() 被用于输出不同的数据类型:

#include <iostream>using namespace std;class printData
{public:void print(int i) {cout << "整数为: " << i << endl;}void print(double f) {cout << "浮点数为: " << f << endl;}void print(char c[]) {cout << "字符串为: " << c << endl;}
};int main(void)
{printData pd;// 输出整数pd.print(5);// 输出浮点数pd.print(500.263);// 输出字符串char c[] = "Hello C++";pd.print(c);return 0;
}

4.2 运算符重载

        在C++中,运算符重载是一个允许程序员自定义各种运算符(如 + , - , == , != 等)在自定义类型(类或结构体)上的行为的特性。这意味着你可以定义类似于内置类型的运算符行为,使你的自定义类型更加直观和易于使用。

        基本原则:
        (1)不可以创建新的运算符
:只能重载已经存在的运算符。

        (2)至少有一个操作数是用户定义的类型:不能重载两个基本类型的运算符。

        (3)不能更改运算符的优先级:重载的运算符保持其原有的优先级和结合性。

        示例1:假设我们有一个Person 类,我们可以重载 == 运算符来实现两个Person是否相等的判断。

#include <iostream>using namespace std;class Person
{public:string name;int inNumberTail;bool operator==(Person pTmp);
};bool Person::operator==(Person pTmp){return pTmp.name == name && pTmp.inNumberTail == inNumberTail;
}int main()
{//假设我们认定名字和身份证尾号6位一样的两个对象是同一个人!Person p1;p1.name = "张三";p1.inNumberTail = 412508;Person p2;p2.name = "张三";p2.inNumberTail = 412508;bool ret = p1 == p2;cout << ret << endl;return 0;
}

        示例2:假设我们有一个简单的 Point 类,我们可以重载 + 运算符来实现两个点的加法。

class Point {public:int x, y;// 重载 + 运算符Point operator+(const Point& other) const {return Point(x + other.x, y + other.y);}
};int main() {Point p1;p1.x = 1;p1.y = 2;Point p2;p2.x = 2;p2.y = 3;Point p3 = p1 + p2; // 使用重载的 + 运算符std::cout << "p3.x: " << p3.x << ", p3.y: " << p3.y << std::endl; // 输出p3.x: 4, p3.y: 6return 0;
}

        在示例2中,operator+ 被重载为一个成员函数,接受一个 Point 类型的常量引用作为参数,并返回两个点相加的结果。

        这里的 const 表明这个 operator+ 函数不会修改调用它的 Point 对象。它只是读取对象的 x y成员,并返回一个新的 Point 对象。这种做法在设计类的时候是很有用的,因为它可以确保某些函数不会意外地改变对象的状态,同时也使得这个函数可以在常量对象上被调用。

        注:(1)一致性:重载的运算符应与其原始意图和常见用法保持一致。例如, + 运算符通常应该实现加法,而不是其他意外的操作。

        (2)复杂性:过度使用运算符重载可能导致代码难以理解和维护。确保它们的使用直观且合理。

        运算符重载是C++中提高代码可读性和表达力的强大工具,但需要谨慎使用,以保证代码的清晰性和维护性。

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

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

相关文章

2024年港澳台联考考生成绩数据分析来啦

分数线 出炉 2024年的港澳台联考正式出分&#xff01;根据考生成绩&#xff0c;全国联招划档线如下&#xff1a; 一、本科批次 &#xff08;一&#xff09;普通类院校&#xff08;专业&#xff09;&#xff1a;文史类365分、理工类390分&#xff08;部分院校执行高分线&#…

持续直击WCCI 2024:金耀初教授、台湾省台北分会等获殊荣 横滨夜景美不胜收

持续直击WCCI 2024&#xff1a;金耀初教授、台湾省台北分会等获殊荣&#xff01;横滨夜景美不胜收&#xff01; 会议之眼 快讯 会议介绍 IEEE WCCI&#xff08;World Congress on Computational Intelligence&#xff09;2024&#xff0c;即2024年IEEE世界计算智能大会&…

BAS(入侵与攻击模拟)正在替代红队测试?

之前经常会被用户问到&#xff0c;漏扫、渗透和红队红的区别是啥&#xff1f; 传统的漏扫、渗透和红蓝对抗&#xff0c;可以看到工具化的漏洞不可靠&#xff0c;人工的成本就高。怎么找到一个漏洞可信度又高&#xff0c;成本又低的&#xff0c;就诞生了BAS。 抛开漏扫&#xf…

解析Kotlin中的Lambda【笔记摘要】

先看实例&#xff1a; fun b(param: Int): String {return param.toString() }fun a(funParam: (Int) -> String): String {return funParam(1) }a(::b) val d ::b1.双冒号 ::method 到底是什么&#xff1f;答&#xff1a;一个指向和该函数具有相同功能的对象的引用 因为…

umi项目中的一些趣事

前言 出于某些安全问题&#xff0c;需要把HTML中框架注入的umi版本信息去掉&#xff0c;那要怎么搞呢~ 方案 查找官方文档&#xff0c;没发现可以去掉注入信息的方法&#xff0c;但在一番折腾后&#x1f609;终究还是解决了~ 发现 版本信息是从这里注入的~ Object.define…

解决pip安装时的“SyntaxError: invalid syntax”错误

项目场景&#xff1a; 项目中有新的成员加入时&#xff0c;第一步就是安装开发环境&#xff0c;然而往往同样的机器、同样的配置&#xff0c;我们却总能遇到各种各样不同的问题。 今天分享一个简单的操作问题。 问题描述 项目用到pandas&#xff0c;安装pandas时遇到Syntax…

Java后端每日面试题(day2)

目录 Session和Cookie的关系Cookie与Session的区别JWT 由哪些部分组成&#xff1f;如何防止 JWT 被篡改&#xff1f;JWT 的特点 Session和Cookie的关系 Session和Cookie都可以用来实现跟踪用户状态&#xff0c;而二者是关系的&#xff1a;Session的实现依赖于Cookie。 Session…

微信小程序tabar属性

微信小程序的TabBar是用于在小程序内创建底部导航栏的一种组件。它允许用户在多个页面之间快速切换&#xff0c;提高了用户体验。下面将详细讲解如何配置和使用微信小程序的TabBar。 配置TabBar {"pages": ["pages/index/index","pages/logs/logs&q…

计算机相关单词

以下是计算机学科中专业术语、软件、硬件、网络设备相关的一些术语&#xff1a; ps&#xff1a;涉及不懂的专有名词&#xff0c;需去主动了解&#xff0c;拓宽知识面 专业术语 API&#xff1a;Application Programming Interface&#xff0c;应用程序编程接口&#xff0c;允…

【C语言】顺序表经典算法

本文介绍的是两道顺序表经典算法题目。 移除元素 &#xff08;来源&#xff1a;LeetCode&#xff09; 题目 分析 我们很容易想到的办法是去申请一个新的数组&#xff0c;遍历原数组不等于val就把它拿到新数组里。但是题目的要求是不使用额外空间&#xff0c;所以这种方法我们…

Python面向对象编程中的继承及其应用

目录 1. 继承的基本概念 2. 继承的语法 3. 继承的应用场景 4. 使用示例&#xff1a;汽车销售系统 5. 总结 继承是面向对象编程中的一个重要概念&#xff0c;它允许我们根据已有类创建新类&#xff0c;并继承已有类的属性和方法。在本文中&#xff0c;我们将学习Python中的…

Unity3D中,AI角色Rigidbody旋转导致的动画问题

在制作一些AI角色的时候&#xff0c;可能会运用到Rigidbody组件来使AI角色拥有一些相关的物理属性&#xff0c;但是AI角色在受到一些物理碰撞或者惯性等原因&#xff0c;会发生旋转导致动画出现意料外的错误&#xff0c;比如在由动转静的时候&#xff0c;可能会发生向前翻转等一…

卷积层里的填充和步幅

一、定义 1、对于卷积&#xff0c;我们另一个超参数是核的大小&#xff0c;通常使用的卷积核是33或者55&#xff0c;很少用偶数核 2、填充是为了让输出不变或者变大&#xff0c;是为了在输入不太大&#xff0c;又能使模型足够深的情况下使用 3、填充&#xff1a;在输入周围添…

【Java学习笔记】java图形界面编程

在前面的章节中&#xff0c;我们开发运行的应用程序都没有图形界面&#xff0c;但是很多应用软件&#xff0c;如Windows下的Office办公软件、扑克牌接龙游戏软件、企业进销存ERP系统等&#xff0c;都有很漂亮的图形界面。素以需要我们开发具有图形界面的软件。 Java图形界面编程…

2024年上半年典型网络攻击事件汇总

文章目录 前言一、Ivanti VPN 的0 Day攻击(2024年1月)二、微软公司高管账户泄露攻击(2024年1月)三、Change Healthcare网络攻击(2024年2月)四、ConnectWise ScreenConnect漏洞利用攻击(2024年2月)五、XZ Utils软件供应链攻击(2024年3月)六、AT&T数据泄露攻击(20…

Megatron-DeepSpeed与Megatron-LM在reduce grad上的差异

Megatron-DeepSpeed与Megatron-LM在reduce grad上的差异 一.Megatron-DeepSpeed 实现【deepspeed/runtime/engine.py】二.ModelLink 实现【ParamAndGradBuffer】1.ParamAndGradBuffer功能介绍2.实现原理A.分配一大块内存B.获取视图C.all_reduce grad 测试DP1,TP2,PP1,MBS1,zero…

使用Java实现实时地图应用

使用Java实现实时地图应用 大家好&#xff0c;我是免费搭建查券返利机器人省钱赚佣金就用微赚淘客系统3.0的小编&#xff0c;也是冬天不穿秋裤&#xff0c;天冷也要风度的程序猿&#xff01;今天我们来探讨如何使用Java实现一个实时地图应用。 实时地图应用在现代互联网应用中…

Java_Spring框架:Bean的生命周期

在Spring框架中&#xff0c;Bean的生命周期包括以下几个阶段&#xff1a; 实例化&#xff08;Instantiation&#xff09;&#xff1a;在这个阶段&#xff0c;Spring会根据配置或注解创建Bean的实例。这可以通过构造函数实例化、工厂方法或者Bean容器中的其他方式来实现。 属性…

【信即是功夫】人皆有良知在心中

良知就是做人、做事的准则&#xff0c;良知就是天理&#xff1b;实实在在地自信 每个人心中都有一个圣人&#xff0c;只因自己不能真的相信&#xff0c;把这个圣人埋没了 良知在每个人心中&#xff0c;无论你如何做&#xff0c;也无法泯灭它。即使身为盗贼的人&#xff0c;他…

力扣1124.表现良好的最长时间段

力扣1124.表现良好的最长时间段 哈希表存最小的下标 当s[i] > 0 那么他到头可以构成一个合法时间段否则 找到之前的 s[i] - 1 的下标&#xff1a; 因为连续的前缀和一定只相差1若想算更小的s[i] - 2,s[i] - 3…一定会先算到s[i] - 1那么这些更小数必然在 s[i]−1 首次出现的…