C++类的引入

C++中类的前身

1> 面向对象三大特征：封装、继承、多态

2> 封装：将能够实现某一事物的所有万事万物都封装到一起，包括成员属性（成员变量），行为（功能函数）都封装在一起，我们称之为类。并向外部提供公共的接口，用户可以通过该接口来控制该类实例化的对象。

3> 只需将C++中的结构体的struct改成class就是类的定义

4> 类的定义格式

class 类名 { 访问权限： 成员； };

类的说明

1> 类中的访问权限有三种：public、protected、private

public:该权限下的成员，可以在类内、子类中以及类外被访问

protected：该权限下的成员，可以在类内、子类中被访问，类外不能被访问

private：该权限下的成员只能被类内访问，类外、子类中都不能被访问

在类中，默认的访问权限是private

2> 类中可以有成员属性和成员函数，一般成员属性设置成私有、成员变量设置成公共的

3> 类中的成员函数可以访问类中所有权限下的成员，包括私有成员

4> 每种访问权限，可以在类中出现多次，每个访问权限从关键字开始，到下一个关键字为止或者整个类体结束。

5> 一般将同一权限下的所有成员放在一起

6> 如果非要在类外对私有成员或受保护的成员进行读取或者写入，需要在类内提供相关公共的接口来完成

7> 类的访问权限是针对于类体而言，而不是针对于类对象而言

#include <iostream>using namespace std;//定义一个 Person 类
class Person
{
public:string name = "张三";char sex;             //性别private:int age = 18;protected:int money;public://定义展示函数void show(){cout<<"name = "<<name<<endl;          //公共权限下的成员，类内可以被访问cout<<"sex = "<<sex<<endl;            //公共权限下的成员，类内可以被访问cout<<"age = "<<age<<endl;            //私有权限下的成员，类内可以被访问cout<<"money = "<<money<<endl;        //受保护权限下的成员，类内可以被访问}//定义设置年龄函数void set_age(int a){if(a<0){cout<<"设置失败"<<endl;return;}age = a;}//定义获取年龄的函数int get_age(){return age;}};int main()
{//class Person p1;       //使用类定义一个变量Person p1;              //使用类，定义一个变量   ---> 使用Person类实例化一个对象p1.name = "二狗";           //类中公共权限下的成员，类外可以被访问p1.sex = 'M';               //类中公共权限下的成员，类外可以被访问//p1.age = 18;               //类中私有权限下的成员，类外无法被访问//p1.money = 1000000;          //类中受保护的成员，类外无法被访问p1.show();                //类中公共权限下的成员，类外可以被访问//设置年龄p1.set_age(118);cout<<"p1.age = "<<p1.get_age()<<endl;return 0;
}

练习：定义一个矩形（Rectangle）类，拥有私有成员属性：宽度(width)、高度(hight)

公共成员函数：

初始化函数：void init(int w, int h)

获取宽度函数：get_w();

设置宽度函数：set_w(int w);

获取高度函数：get_h();

设置高度函数：set_h(int h);

获取周长函数：get_perimeter();

获取面积函数：get_area();

在主程序中实例化对象，并测试下相关函数

#include <iostream>using namespace std;class Rectangle            //定义一个矩形类
{//私有成员属性
private:int width;       //矩形的宽度int hight;        //矩形的高度
public://初始化函数void init(int w,int h){if(w<=0 || h<=0){cout<<"初始化失败"<<endl;return;}width=w;hight=h;}//设置宽度函数void set_w(int w){width=w;}//设置高度函数void set_h(int h){hight=h;}//获取宽度int get_w(){return width;}//获取周长int get_peri(){return 2*width+2*hight;}//获取面积int get_area(){return width*hight;}
};int main()
{Rectangle r1;       //实例化一个矩形对象r1.init(3,5);         //初始化矩形cout<<"矩形的周长为："<<r1.get_peri()<<endl;cout<<"矩形的面积为："<<r1.get_area()<<endl;//重新设置矩形的宽度r1.set_w(10);cout<<"矩形的周长为："<<r1.get_peri()<<endl;cout<<"矩形的面积为："<<r1.get_area()<<endl;return 0;
}

练习：在上面的案例上面加一个功能：比较两个矩形框是否相等 bool judge()

判断两个矩形相等的原则：width==width && heigh==heigh

全局函数版本： bool judge(Rectangle r1, Rectangle r2);

#include <iostream>using namespace std;class Rectangle            //定义一个矩形类
{//私有成员属性
private:int width;       //矩形的宽度int hight;        //矩形的高度
public://初始化函数void init(int w,int h){if(w<=0 || h<=0){cout<<"初始化失败"<<endl;return;}width=w;hight=h;}//设置宽度函数void set_w(int w){width=w;}//设置高度函数void set_h(int h){hight=h;}//获取宽度int get_w(){return width;}//获取周长int get_peri(){return 2*width+2*hight;}//获取面积int get_area(){return width*hight;}//获取矩形框高度int get_h(){return hight;}//定义成员函数，比较两个矩形是否相等bool judge(Rectangle &r1, Rectangle &r2){//比较逻辑if(r1.width==r2.width && r1.hight==r2.hight){return true;}return false;}//定义成员函数，比较当前矩形框和其他传入的矩形框是否相等bool judge(Rectangle &other){//比较逻辑if(width==other.width && hight==other.hight){return true;}return false;}
};//定义全局函数完成求两个矩形框是否相等
bool judge(Rectangle &r1, Rectangle &r2)
{//比较逻辑if(r1.get_w()==r2.get_w() && r1.get_h()==r2.get_h()){return true;}return false;
}int main()
{Rectangle r1;       //实例化一个矩形对象r1.init(3,5);         //初始化矩形cout<<"矩形的周长为："<<r1.get_peri()<<endl;cout<<"矩形的面积为："<<r1.get_area()<<endl;//重新设置矩形的宽度r1.set_w(10);cout<<"矩形的周长为："<<r1.get_peri()<<endl;cout<<"矩形的面积为："<<r1.get_area()<<endl;//实例化另一个矩形框Rectangle r2;r2.init(10,10);//判断两个矩形框是否相等/*if(judge(r1,r2))        //调用全局函数{cout<<"两个矩形框相等"<<endl;}else{cout<<"两个矩形框不相等"<<endl;}*//*调用成员函数判断两个矩形框是否相等if(r1.judge(r1, r2)){cout<<"两个矩形框相等"<<endl;}else{cout<<"两个矩形框不相等"<<endl;}*/if(r1.judge(r2)){cout<<"两个矩形框相等"<<endl;}else{cout<<"两个矩形框不相等"<<endl;}return 0;
}

分文件编译

头文件

#ifndef RECANTLE_H
#define RECANTLE_H#include <iostream>
using namespace std;class Rectangle            //定义一个矩形类
{//私有成员属性
private:int width;       //矩形的宽度int hight;        //矩形的高度
public://初始化函数void init(int w,int h);//设置宽度函数void set_w(int w);//设置高度函数void set_h(int h);//获取宽度int get_w();//获取周长int get_peri();//获取面积int get_area();//获取矩形框高度int get_h();//定义成员函数，比较两个矩形是否相等bool judge(Rectangle &r1, Rectangle &r2);//定义成员函数，比较当前矩形框和其他传入的矩形框是否相等bool judge(Rectangle &other);
};//全局函数的声明
bool judge(Rectangle &r1, Rectangle &r2);#endif // RECANTLE_H

源文件

#include "recantle.h"//初始化函数
void Rectangle::init(int w,int h)
{if(w<=0 || h<=0){cout<<"初始化失败"<<endl;return;}width=w;hight=h;
}//设置宽度函数
void  Rectangle::set_w(int w)
{width=w;
}
//设置高度函数
void  Rectangle::set_h(int h)
{hight=h;
}
//获取宽度
int  Rectangle::get_w()
{return width;
}
//获取周长
int  Rectangle::get_peri()
{return 2*width+2*hight;
}
//获取面积
int  Rectangle::get_area()
{return width*hight;
}//获取矩形框高度
int  Rectangle::get_h()
{return hight;
}//定义成员函数，比较两个矩形是否相等
bool  Rectangle::judge(Rectangle &r1, Rectangle &r2)
{//比较逻辑if(r1.width==r2.width && r1.hight==r2.hight){return true;}return false;
}//定义成员函数，比较当前矩形框和其他传入的矩形框是否相等
bool  Rectangle::judge(Rectangle &other)
{//比较逻辑if(width==other.width && hight==other.hight){return true;}return false;
}//定义全局函数完成求两个矩形框是否相等
bool judge(Rectangle &r1, Rectangle &r2)
{//比较逻辑if(r1.get_w()==r2.get_w() && r1.get_h()==r2.get_h()){return true;}return false;
}

测试文件

#include"recantle.h"        //引入自定义的头文件int main()
{Rectangle r1;       //实例化一个矩形对象r1.init(3,5);         //初始化矩形cout<<"矩形的周长为："<<r1.get_peri()<<endl;cout<<"矩形的面积为："<<r1.get_area()<<endl;//重新设置矩形的宽度r1.set_w(10);cout<<"矩形的周长为："<<r1.get_peri()<<endl;cout<<"矩形的面积为："<<r1.get_area()<<endl;//实例化另一个矩形框Rectangle r2;r2.init(10,10);//判断两个矩形框是否相等/*if(judge(r1,r2))        //调用全局函数{cout<<"两个矩形框相等"<<endl;}else{cout<<"两个矩形框不相等"<<endl;}*//*调用成员函数判断两个矩形框是否相等if(r1.judge(r1, r2)){cout<<"两个矩形框相等"<<endl;}else{cout<<"两个矩形框不相等"<<endl;}*/if(r1.judge(r2)){cout<<"两个矩形框相等"<<endl;}else{cout<<"两个矩形框不相等"<<endl;}return 0;
}

this指针

1> this指针是类中系统为所有非静态成员函数提供的一个隐藏的形参指针，指代当前对象的起始地址

2> 指代当前对象，哪个对象使用我，我就指向哪个对象

3> 在非静态成员函数中，如果调用了类中的成员（成员函数、成员变量），即使没有加this，系统也默认加了this。

局部名称屏蔽成员名称除外

4> this的原型： 类名 * const this;

5> 必须使用this的情况：

1、当形参名和成员名同名时，可以使用this用于区分

2、在拷贝赋值函数中，用于返回自身引用时，必须使用this（后期讲）

#include <iostream>using namespace std;class Stu
{string name = "zhangsan";int age = 18;public://非静态成员函数void show(){cout<<"show::this = "<<this<<endl;//cout<<"name = "<<name<<"    age = "<<age<<endl;cout<<"name = "<<this->name<<"    age = "<<this->age<<endl;}//定义设置函数void set_data(string name, int a)         //this形参的原型： Stu * const this;{cout<<"set_data::this = "<<this<<endl;this->name = name;              //将形参name，赋值给成员变量namethis->age = a;                  //可以通过this改变指针指向的内存空间中的值//this = NULL;                   //不能通过this改变指针的值this->show();             //成员函数中调用另一个成员函数}};

类的大小

1> 一个空类的大小为 1 字节，用于占位作用，后期如果有成员变量，就会将该1字节空间分配给成员使用

2> 类中的成员函数不占类体的大小，成员函数只有被调用时，才会分配空间

3> 只有类的成员属性才占内存空间，其类的大小要遵循字节对齐原则

4> 如果类中有虚函数，则会多一个虚指针的空间 （后期讲）

#include <iostream>using namespace std;//一个空类的大小为 1字节
class A
{};//成员 变量占内存空间，要符合字节对齐原则
class B
{int value_a;char value_b;short value_c;char value_d;double value_e;short value_f;        //11112033400000005555555566000000
};//定义一个类，既有成员属性也有成员变量,类的成员函数是不占类体的空间的
class C
{int a;void show(){int b;cout<<"b = "<<b<<"   a = "<<a<<endl;}void display(){this->show();}
};//当类中出现虚函数时，系统会给类默认提供一个虚指针，无论有多少虚函数，都只提供一个虚函数指针
class D
{int value_a;      //成员变量//非虚函数void show(){}//定义虚函数virtual void diaplay(){}//虚函数       virtual void fun(){}
};int main()
{cout << sizeof(A) << endl;            // 1cout << sizeof(B) << endl;            // 32cout << sizeof(C) << endl;            // 4cout << sizeof(D) << endl;            // 16return 0;
}

类中特殊成员函数

1> 当定义一个空类时，即使没有手动定义某些函数，C++系统会默认自动为其提供一些特殊成员函数

2> 这些函数也可以程序员手动定义，当手动定义后，系统就不再提供默认的了

3> 这些函数也无需程序员手动调用，在特殊时期，C++系统会自动调用

4> 种类：构造函数、析构函数、拷贝构造函数、拷贝赋值函数、移动构造函数、移动赋值函数、取地址运算符重载函数

构造函数

1> 构造函数是在使用类实例化对象时，用于给类对象分配内存空间以及对成员进行初始化工作时使用

2> 定义格式

1、构造函数没有返回值，不需要写返回值类型 2、函数名与类同名 3、可以有参，也可以无参 4、一般为公共权限 5、格式： 类名(形参列表){函数体内容}

3> 调用时机：无需程序员手动调用，当使用一个类实例化对象时，系统自动调用构造函数

4> 调用格式：

无参构造： 类名 对象名；

例如：string s1;

有参构造： 类名 对象名（实参列表）;

例如：string s2("hello a");

string s3(5, 'A');

5> 一个类中可以定义多个构造函数，要求参数必须不同，这些构造函数构成重载关系

虽然一个类中可以定义多个构造函数，但是一个类对象的只能使用一个构造函数构造出来

6> 一个类中，如果没有显性定义任何构造函数，那么系统会默认提供一个无参构造函数

但凡类中提供任意一个构造函数，系统就不再提供默认的无参构造函数了，如果非要使用无参构造函数，需要程序员手动定义无参构造函数

7> 构造函数的形参列表也可以设置默认参数，但是要注意是否跟其他重载的函数冲突

8> 构造函数的初始化工作是在初始化列表中完成的。

初始化列表：在构造函数函数头部后面，由冒号引出，完成初始化工作

格式： 类名(形参类型1 形参1， 形参类型2 形参2，。。。， 形参类型n 形参n) : 成员变量1（形参1），成员变量2（形参2），。。。，成员变量n(形参n) {}

#include <iostream>using namespace std;//定义一个类
class Stu
{
private:const string name;           //如果类中有const修饰的成员变量，必须使用初始化列表完成对其进行初始化工作int age;public://无参构造函数Stu():name("二狗"){//this->name = "二狗";this->age = 100;cout<<"Stu::无参构造"<<endl;}//定义有参构造函数Stu(string n) :name(n){//this->name = n;cout<<"Stu::有参构造1"<<endl;}//定义有参构造//Stu(string n="大毛", int a=20)         //带默认参数的构造函数Stu(string name, int age) :name(name), age(age)              //使用初始化列表完成对成员的初始化工作{//此处是给成员变量赋值，而不是初始化//this->name = n;//this->age = a;cout<<"Stu::有参构造2"<<endl;}//定义展示函数void show(){cout<<"name = "<<name<<"    gae = "<<age<<endl;}};int main()
{Stu s1;           //系统会自动调用该类中的无参构造函数s1.show();cout<<"***************************\n";Stu s2("张三");        //调用自定义的有参构造s2.show();cout<<"***************************\n";Stu s3("张三", 18);        //调用自定义的有参构造s3.show();return 0;
}

9> 必须使用构造函数的初始化列表的情况

1、如果类的成员变量中有常成员变量，对该成员的初始化工作，必须使用初始化列表完成

2、如果类中有引用成员，那么对该成员也必须使用初始化列表完成

3、如果构造函数的形参名和成员变量同名时，可以使用初始化列表来解决

4、如果一个类中，有另一个类的对象，对该成员对象的初始化工作需要在初始化列表中显性定义该成员对象的有参构造，否则系统会自动调用其无参构造

#include <iostream>using namespace std;//定义一个汽车类
class Car
{
private:string name;string color;
public:Car() {cout<<"Car::无参构造"<<endl;}Car(string n, string c):name(n), color(c){cout<<"Car::有参构造"<<endl;}
};//定义一个类
class Stu
{
private:const string name;           //如果类中有const修饰的成员变量，必须使用初始化列表完成对其进行初始化工作int age;int &score;            //引用成员 必须在构造函数的初始化列表中进行初始化工作Car c;public://无参构造函数Stu():name("二狗"), score(*new int(520)), c("擎天柱","red"){//this->name = "二狗";this->age = 100;cout<<"Stu::无参构造"<<endl;}//定义有参构造函数Stu(string n, int &score) :name(n), score(score){//this->name = n;cout<<"Stu::有参构造1"<<endl;}//定义有参构造//Stu(string n="大毛", int a=20)         //带默认参数的构造函数Stu(string name, int age, int &score) :name(name), age(age), score(score)              //使用初始化列表完成对成员的初始化工作{//此处是给成员变量赋值，而不是初始化//this->name = n;//this->age = a;cout<<"Stu::有参构造2"<<endl;}//定义展示函数void show(){cout<<"name = "<<name<<"    gae = "<<age<<endl;}};int main()
{Stu s1;           //系统会自动调用该类中的无参构造函数s1.show();cout<<"***************************\n";int s = 99;Stu s2("张三", s);        //调用自定义的有参构造s2.show();cout<<"***************************\n";Stu s3("张三", 18, s);        //调用自定义的有参构造s3.show();return 0;
}

使用C++手动封装一个顺序表，包含成员指针变量，成员变量N个

#include <iostream>using namespace std;
//类型重命名
using datatype = int;     //typedef int datatype;//定义一个顺序表类
class SeqList
{private:datatype *data;                //指向堆区空间的指针int size = 0;                      //数组的大小int len = 0;                     //顺序表实际长度public://无参构造/*SeqList():data(new datatype[10]), size(10), len(0){cout<<"无参构造"<<endl;}*///有参构造SeqList(int s):data(new datatype[s]), size(s), len(0){cout<<"有参构造"<<endl;}//要实现的函数//判空函数bool empty(){return len==0;}//判满函数bool full(){return len==size;}//添加数据函数bool add(datatype e){if(full()){return false;}len++;data[len] = e;return true;}//求当前顺序表的实际长度int length(){return len;}//任意位置插入函数bool insert_pos(int pos, datatype e){if(full()||pos<0||pos>len){return false;}for(int i=len;i>pos;i--){data[i]=data[i-1];}data[pos]=e;len++;return true;}//任意位置函数函数bool delete_pos(int pos){if(empty()||pos<0||pos>=len){return false;}for(int i=pos;i<len-1;i++){data[i]=data[i+1];}len--;return true;}//访问容器中任意一个元素 atdatatype &at(int index){if(index<0||index>=len){return data[-1];}return data[index];}//君子函数：二倍扩容void expend(){size *=2;datatype *newdata =new datatype[size];for(int i=0;i<len;i++){newdata[i] = data[i];}delete []data;data = newdata;}//释放顺序表void seqfree(){delete[]data;data =NULL;size = 0;len = 0;          }
};int main()
{SeqList S(5);S.add(1);S.add(2);S.insert_pos(1,3);cout <<"长度 = "<<S.length()<<endl;return 0;
}

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

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

相关文章

【YOLOv8杂草作物目标检测】

【YOLOv8杂草作物目标检测】

YOLOv8杂草目标检测 算法介绍模型和数据集下载 算法介绍 YOLOv8在禾本科杂草目标检测方面有显著的应用和效果。以下是一些关键信息的总结&#xff1a; 农作物幼苗与杂草检测系统&#xff1a;基于YOLOv8深度学习框架&#xff0c;通过2822张图片训练了一个目标检测模型&#xff…
阅读更多...
图像处理 | 图像二值化

图像处理 | 图像二值化

在图像处理领域&#xff0c;图像二值化是一个重要的操作&#xff0c;它将彩色或灰度图像转换为只有两种颜色&#xff08;通常是黑白&#xff09;的图像。二值化广泛应用于文字识别、图像分割、边缘检测等领域&#xff0c;尤其在处理简洁和高对比度的图像时非常有效。本文将深入…
阅读更多...
概率论与数理统计总复习

概率论与数理统计总复习

复习课本&#xff1a;中科大使用的教辅《概率论和数理统计》缪柏其、张伟平版本 目录 0.部分积分公式 1.容斥原理 2.条件概率 3.全概率公式 4.贝叶斯公式 5.独立性 6.伯努利分布&#xff08;两点分布&#xff09; 7.二项分布 8.帕斯卡分布&#xff08;负二项分布&am…
阅读更多...
从CentOS到龙蜥：企业级Linux迁移实践记录（系统安装）

从CentOS到龙蜥：企业级Linux迁移实践记录（系统安装）

引言&#xff1a; 随着CentOS项目宣布停止维护CentOS 8并转向CentOS Stream&#xff0c;许多企业和组织面临着寻找可靠替代方案的挑战。在这个背景下&#xff0c;龙蜥操作系统&#xff08;OpenAnolis&#xff09;作为一个稳定、高性能且完全兼容的企业级Linux发行版&#xff0…
阅读更多...
计算机网络期末复习（知识点）

计算机网络期末复习（知识点）

概念题 在实际复习之前&#xff0c;可以看一下这个视频将网络知识串一下&#xff0c;以便更好地复习&#xff1a;【你管这破玩意叫网络&#xff1f;】 网络规模的分类 PAN&#xff08;个人区域网络&#xff09;&#xff1a;用于个人设备间的连接&#xff0c;如手机与蓝牙耳机…
阅读更多...
IDEA Maven构建时报错：无效的目标发行版17

IDEA Maven构建时报错：无效的目标发行版17

报错分析 报错原因&#xff1a;Maven 构建时&#xff0c;Java 版本配置不匹配 我安装的JDK版本是1.8&#xff0c;但由于种种原因&#xff0c;Maven构建时指定了 Java 17 作为目标发行版&#xff0c;从而导致错误 解决方案 首先&#xff0c;java -version&#xff0c;查看环…
阅读更多...
国产编辑器EverEdit - 扩展脚本：关闭所有未修改文档

国产编辑器EverEdit - 扩展脚本：关闭所有未修改文档

1 扩展脚本&#xff1a;关闭所有未修改文档 1.1 应用场景 当用户打开过多文档时&#xff0c;部分文档已经修改&#xff0c;而大部分没有修改&#xff0c;为了减少在众多已打开文档中来回跳转的不便&#xff0c;可以将没有修改的文档全部关闭&#xff0c;但目前提供的快速关闭窗…
阅读更多...
Knowledge Editing through Chain-of-Thought

Knowledge Editing through Chain-of-Thought

题目 通过思路链进行知识编辑 论文地址&#xff1a;https://arxiv.org/abs/2412.17727 摘要 大型语言模型 (LLM) 在广泛的自然语言处理 (NLP) 任务中表现出卓越的能力。然而&#xff0c;由于频繁重新训练的成本很高&#xff0c;让这些模型与不断发展的世界知识保持同步仍然是一…
阅读更多...
运行.Net 7 Zr.Admin项目（后端）

运行.Net 7 Zr.Admin项目（后端）

1.下载Zr.Admin代码压缩包 https://codeload.github.com/izhaorui/Zr.Admin.NET/zip/refs/heads/main 2.打开项目 我这里装的是VS2022社区版 进入根目录&#xff0c;双击ZRAdmin.sln打开项目 3.安装.net7运行时 我当时下载的代码版本是.net7的 点击安装 点击安装&#xff0…
阅读更多...
spark——RDD算子集合

spark——RDD算子集合

目录 算子转换算子示例mapflatMapReduceByKeyfilterdistinctglomgroupBygroupByKeySortBysortByKeyunion交集intersection和差集subtractjoinpartitionBymapPartitionsample 行动算子示例ForeachPartitionForeachSaveAsTextFileCountByKeyReducefoldfirst、take、counttop、tak…
阅读更多...
Taro+react 开发第一节创建 带有redux状态管理的项目

Taro+react 开发第一节创建 带有redux状态管理的项目

Taro 项目基于 node&#xff0c;请确保已具备较新的 node 环境&#xff08;>16.20.0&#xff09;&#xff0c;推荐使用 node 版本管理工具 nvm 来管理 node&#xff0c;这样不仅可以很方便地切换 node 版本&#xff0c;而且全局安装时候也不用加 sudo 了。 1.安装 npm inf…
阅读更多...
Qt C++读写NFC标签NDEF网址URI

Qt C++读写NFC标签NDEF网址URI

本示例使用的发卡器&#xff1a;https://item.taobao.com/item.htm?spma21dvs.23580594.0.0.1d292c1biFgjSs&ftt&id615391857885 #include "mainwindow.h" #include "ui_mainwindow.h" #include <QDebug> #include "QLibrary" …
阅读更多...
Js的回调函数

Js的回调函数

一、什么是回调函数&#xff08;Callback&#xff09;&#xff1f; 回调函数&#xff08;Callback Function&#xff09;是指一个函数被作为参数传递给另一个函数&#xff0c;并在特定事件发生或操作完成时执行。 可以通俗地理解为一种“委托”机制。 在JavaScript中&#xff0…
阅读更多...
OSPF - 1类LSA（Router-LSA）

OSPF - 1类LSA（Router-LSA）

前篇博客有对常用LSA的总结 1类LSA是OSPF计算最原始的材料&#xff0c;他会泛洪发给所有的路由器 LSA是包含在LSU中的&#xff0c;一条LSU能够携带多条LSA options位所有LSA都会有&#xff0c;用于标记起源于什么类型的区域&#xff0c;具体查看文章【邻居建立】 flags位是一…
阅读更多...
python学opencv|读取图像（三十一）缩放图像的三种方法

python学opencv|读取图像（三十一）缩放图像的三种方法

【1】引言 前序学习进程中&#xff0c;我们至少掌握了两种方法&#xff0c;可以实现对图像实现缩放。 第一种方法是调用cv2.resize()函数实现&#xff0c;相关学习链接为&#xff1a; python学opencv|读取图像&#xff08;三&#xff09;放大和缩小图像_python opencv 读取图…
阅读更多...
实训云上搭建集群

实训云上搭建集群

文章目录 1. 登录实训云1.1 实训云网址1.2 登录实训云 2. 创建网络2.1 网络概述2.2 创建步骤 3. 创建路由器3.1 路由器名称3.1 创建路由器3.3 查看网络拓扑 4. 连接子网5. 创建虚拟网卡5.1 创建原因5.2 查看端口5.3 创建虚拟网卡 6. 管理安全组规则6.1 为什么要管理安全组规则6…
阅读更多...
c++入门之 命名空间与输入输出

c++入门之 命名空间与输入输出

1、命名空间 1.1使用命名空间的原因 先看一个例子&#xff1a; #include <iostream>int round 0;int main() {printf("%d", round);return 0; }请问&#xff0c;这个程序能跑起来吗&#xff1f; 答案是否定的 原因是&#xff0c;当我们想创建一个全局变量 …
阅读更多...
继承（7）

继承（7）

大家好&#xff0c;今天我们继续来学习一下继承的知识&#xff0c;这方面需要大家勤动脑才能理解&#xff0c;那么我们来看。 1.9 protected关键字 在类和对象章节中&#xff0c;为了实现封装特性,java中引入访向限定符,主要限定:类或者类中成员能否在类外和其他包中被访问. …
阅读更多...
Unity中 Xlua使用整理（二）

Unity中 Xlua使用整理（二）

1.Xlua的配置应用 xLua所有的配置都支持三种方式&#xff1a;打标签&#xff1b;静态列表&#xff1b;动态列表。配置要求&#xff1a; 列表方式均必须是static的字段/属性 列表方式均必须放到一个static类 建议不用标签方式 建议列表方式配置放Editor目录&#xff08;如果是H…
阅读更多...
Flink三种集群部署模型

Flink三种集群部署模型

这里写自定义目录标题 Flink 集群剖析Flink 应用程序执行Flink Session 集群&#xff08;Session Mode&#xff09;Flink Job 集群&#xff08;以前称为per-job&#xff09;Flink Application 集群&#xff08;Application Mode&#xff09; 参考 Flink 集群剖析 Flink 运行时…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023