类与对象【中】

news2024/11/17 11:56:02

1.类的六个默认构造函数

如果一个类中什么成员都没有简称空类
但空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。
默认成员函数：用户没有显示实现，编译器会生成的成员函数。
在这里插入图片描述

2.构造函数

2.1 概念

下面是构造函数的几种形式

class Date
{
public:
	Date()   //无参构造函数
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}
	Date(int year,int month,int day)   //带参数构造函数
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date(int year=1, int month=1, int day=1)   //全缺省的构造函数
	//可以与无参数的构造函数同时存在，但是不可以与带参数的构造函数同时存在
	//但是一般也不会让两个构造函数同时存在，不然在main函数中使用可能会有歧义
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:   
	int _year;
	int _month;
	int _day;
int main()
}
	/*Date d1();*/    //不可以这样写，因为这样也可能为函数声明
	Date d1;   //用的无参的那个构造函数
	d1.print();
	Date d2(2024, 1, 27);
	d2.print();
	return 0;
}
};

构造函数是特殊的成员函数，名字与类名相同，创建类类型对象时由编译器自动调节，以保证每个数据成员都有一个合适的初始值，并且在对象整个生命周期内只调用一次。

private:   
	int _year=1;
	int _month=1;
	int _day=1;

如果这里给了缺省值，那么默认生成的构造函数会用缺省的数完成初始化。-

2.2 特性

构造函数是特殊的成员函数，需要注意的是构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象，而是初始化对象。
其特征如下：
1.函数名与类名相同
2.无返回值
3.对象实例化时编译器自动调节对应构造函数
4.构造函数可以重载
5.如果类没有显示定义构造函数，则c++编译器会自动生成一个无参的默认构造函数，一旦用户显示定义编译器将不再生成

 class Date
 {
  public:
 /*
 // 如果用户显式定义了构造函数，编译器将不再生成
 Date(int year, int month, int day)
 {
 _year = year;
 _month = month;
 _day = day;
 }
 */
 
 void Print()
 {
 cout << _year << "-" << _month << "-" << _day << endl;
 }
  
  private:
 int _year;
 int _month;
 int _day;
 };
  
  int main()
 {
 // 将Date类中构造函数屏蔽后，代码可以通过编译，因为编译器生成了一个无参的默认构造函
数
 // 将Date类中构造函数放开，代码编译失败，因为一旦显式定义任何构造函数，编译器将不再
生成
      // 无参构造函数，放开后报错：error C2512: “Date”: 没有合适的默认构造函数可用
 Date d1;
 return 0;
 }

6.关于编译器生成的默认成员函数，很多童鞋会有疑惑：不实现构造函数的情况下，编译器会生成默认的构造函数。但是看起来默认构造函数又没什么用？d对象调用了编译器生成的默认构造函数，但是d对象_year/_month/_day，依旧是随机值。也就说在这里编译器生成的默认构造函数并没有什么用？？
解答：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类型，如：int/char…，自定义类型就是我们使用class/struct/union等自己定义的类型，看看下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员_t调用的它的默认成员函数。

class Time
{
public:
 Time()
 {
 cout << "Time()" << endl;
 _hour = 0;
 _minute = 0;
 _second = 0;
 }
private:
 int _hour;
 int _minute;
 int _second;
};
class Date
{
private:
 // 基本类型(内置类型)
 int _year;
 int _month;
 int _day;
 // 自定义类型
 Time _t;
};
int main()
{
 Date d;
 return 0;
}

注意：C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在类中声明时可以给默认值。

class Time
{
public:
 Time()
 {
 cout << "Time()" << endl;
 _hour = 0;
 _minute = 0;
 _second = 0;
 }
private:
 int _hour;
 int _minute;
 int _second;
};
class Date
{
private:
 // 基本类型(内置类型)
 int _year = 1970;
 int _month = 1;
 int _day = 1;
 // 自定义类型
 Time _t;
};
int main()
{
 Date d;
 return 0;
}

7.无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。
注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。

3.析构函数

首先说明一点构造函数只是初始化不是创建析构函数也不是销毁，只是清理资源，也相当于之前说的链表中的Destroy

3.1 概念

通过构造函数的学习知道一个对象是怎么来的，那么一个对象又是怎么没的呢？
析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象的销毁是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。

3.2 特性

析构函数是特殊的成员函数，其特征如下：
1.析构函数名是在类名前加~。
2.无参无返回值类型
3.一个类只能有一个析构函数。若未显示定义，系统会自动生成一个默认的析构函数。
注意：析构函数不可以重载。
4.对象生命周期结束时，c++编译系统会自动调用析构函数

3.3

3.3.1为什么要使用析构函数

int main()
{
func();
date d1;
d1.print();
stack stl;
return 0;
}

假如main函数结束了，main函数开辟的空间也就会自动销毁了，但stl这个指针还指向这个空间，这个空间在堆上开辟的，当main函数结束以后堆上的空间并没有被释放，造成内存泄露。在之前链表，二叉树这些里面使用Destroy来清理这种动态开辟的资源。所以也要用析构函数对这里进行清理。

3.3.2 析构函数清理的顺序

class Date
{
public:
	Date(int year=1)
	{
		_year = year;
	}
	~Date()
	{
		cout << "~Date()->" << _year << endl;
	}

private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(1);
	Date d2(2);

	return 0;
}

在这里插入图片描述
从这里就可以看出来析构函数是后进先出，即后创建的先处理。

int main()
{
	Date d1(1);
	Date d2(2);
	static Date d3(3);
	return 0;
}

在这里插入图片描述

这里d3是静态的为全局变量，所以最后清理

class Date
{
public:
	Date(int year=1)
	{
		_year = year;
	}
	~Date()
	{
		cout << "~Date()->" << _year << endl;
	}

private:
	int _year;
	int _month;
	int _day;
};
void func()
{
	Date d3(3);
	static Date d4(4);
}
int main()
{
	Date d1(1);
	Date d2(2);
	func();
	return 0;
}

在这里插入图片描述
这里先销毁func函数，再销毁main函数，再销毁全局变量

class Date
{
public:
	Date(int year=1)
	{
		_year = year;
	}
	~Date()
	{
		cout << "~Date()->" << _year << endl;
	}

private:
	int _year;
	int _month;
	int _day;
};
void func()
{
	Date d3(3);
	static Date d4(4);
}
Date d5(5);
int main()
{
	Date d1(1);
	Date d2(2);
	func();
	return 0;
}

在这里插入图片描述
先局部对象（后定义先析构），再局部静态，再全局对象（后定义先析构）
不管是局部还是全局都是后定义先清理（注意：局部与局部比，全局与全局比）

4.拷贝构造函数

4.1概念

在创建对象的时候，可否创建一个与已存在对象一模一样的对象呢？
拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用（一般常用const修饰）在用已存在的类类型对象创建新对象时由编译器自动调用。

4.2 特征

1.拷贝构造函数是构造函数的一个重载形式
2.拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。

class Date
{
public:
	Date(int year=1,int month=1,int day=1)
	{
		_year = year;
		_month = month;
		_day = day;

	}
	Date(Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
private:
	int _year;
	int _month;
	int _day;
};
void func1(Date d)      //传值传参
{
}
void func2(Date& rd)   //传引用传参
{
}

int main()
{
	Date d1(2024.1,28);
	func1(d1);
	func2(d1);
	return 0;
}

在这里插入图片描述
这里的1至4代表的是func1(d1)；执行的顺序。
传值调用先要进行传参，而传参时先要进行拷贝构造，所以这里就是一个无限的循环，不会停止。

在这里插入图片描述
这里是引用传参，无需再使用拷贝构造了。

下面再举一个例子来说明为什么拷贝函数可能造成无限的循环


class Date
{
public:
	Date(int year=1,int month=1,int day=1)
	{
		_year = year;
		_month = month;
		_day = day;

	}
	Date(const Date d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
private:
	int _year;
	int _month;
	int _day;
};

}

int main()
{
	Date d1(2024.1,28);
	Date d2(d1);    //这里会出现大问题
	return 0;
}

在这里插入图片描述

这里是传参调用要用拷贝构造，而由于拷贝构造函数也是传值调用，它会再调用拷贝构造，会一直这样无限递归，连函数都进不去。
而这里只有引用才可以解决无限递归调用。

下面是完整的拷贝构造

class Date
{
public:
	Date(int year=1,int month=1,int day=1)
	{
		_year = year;
		_month = month;
		_day = day;

	}
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	void print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};


int main()
{
	Date d1(2024.1,28);
	Date d2(d1);
	d1. print();
	d2. print();

	return 0;
}

在这里插入图片描述
在这里插入图片描述
3.若未显示定义，编译器会生成的默认的拷贝构造函数。默认的拷贝构造函数对象按内置类型成员内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。
4.编译器生成的默认拷贝函数已经可以完成字节序的值拷贝了，还需要自己显示实现吗？
当然像日期类这样的类是没有必要的，那下面的类呢？

// 这里会发现下面的程序会崩溃掉？这里就需要我们以后讲的深拷贝去解决。
typedef int DataType;
class Stack
{
public:
 Stack(size_t capacity = 10)
 {
 _array = (DataType*)malloc(capacity * sizeof(DataType));
 if (nullptr == _array)
 {
 perror("malloc申请空间失败");
 return;
 }
 _size = 0;
 _capacity = capacity;
 }
 void Push(const DataType& data)
 {
 // CheckCapacity();
 _array[_size] = data;
 _size++;
 }
 ~Stack()
 {
 if (_array)
 {
 free(_array);
 _array = nullptr;
 _capacity = 0;
 _size = 0;
 }
 }
private:
 DataType *_array;
 size_t _size;
 size_t _capacity;
};
int main()
{
 Stack s1;
 s1.Push(1);
 s1.Push(2);
 s1.Push(3);
 s1.Push(4);
 Stack s2(s1);
 return 0;
}

在这里插入图片描述
注意：类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请
时，则拷贝构造函数是一定要写的，否则就是浅拷贝。

  1. 拷贝构造函数典型调用场景：
    使用已存在对象创建新对象
    函数参数类型为类类型对象
    函数返回值类型为类类型对象
class Date
{
public:
 Date(int year, int minute, int day)
 {
 cout << "Date(int,int,int):" << this << endl;
 }
 Date(const Date& d)
 {
 cout << "Date(const Date& d):" << this << endl;
 }
 ~Date()
 {
 cout << "~Date():" << this << endl;
 }
private:
 int _year;
 int _month;
 int _day;
};
Date Test(Date d)
{
 Date temp(d);
 return temp;
}
int main()
{
 Date d1(2022,1,13);
 Test(d1);
 return 0;
}

在这里插入图片描述
为了提高程序效率，一般对象传参时，尽量使用引用类型，返回时根据实际场景，能用引用
尽量使用引用。

5.赋值运算符重载

5.1 运算符重载

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
函数名字为：关键字operator后面接需要重载的运算符符号。
函数原型：返回值类型 operator操作符(参数列表)
注意：
1.不能通过连接其他符号来创建新的操作符：比如operator@
2.重载操作符必须有一个类类型参数
3.用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不 能改变其含义
4.作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this.* :: sizeof ?: . 注意以上5个运算符不能重载。这个经常在笔试选择题中出现。

下面是使用运算符重载的一个例子：

// 全局的operator==
class Date
{ 
public:
 Date(int year = 1900, int month = 1, int day = 1)
   {
        _year = year;
        _month = month;
        _day = day;
   }    
//private:
 int _year;
 int _month;
 int _day;
};
// 这里会发现运算符重载成全局的就需要成员变量是公有的，那么问题来了，封装性如何保证？
// 这里其实可以用我们后面学习的友元解决，或者干脆重载成成员函数。
bool operator==(const Date& d1, const Date& d2)
{
    return d1._year == d2._year
   && d1._month == d2._month
        && d1._day == d2._day;
}
void Test ()
{
    Date d1(2018, 9, 26);
    Date d2(2018, 9, 27);
    cout<<(d1 == d2)<<endl;
}

class Date
{ 
public:
 Date(int year = 1900, int month = 1, int day = 1)
 {
        _year = year;
        _month = month;
        _day = day;
   }
    
    // bool operator==(Date* this, const Date& d2)
    // 这里需要注意的是，左操作数是this，指向调用函数的对象
    bool operator==(const Date& d2)
 {
        return _year == d2._year;
            && _month == d2._month
            && _day == d2._day;
 }
private:
 int _year;
 int _month;
 int _day;
};

5.2 赋值运算符重载

1.赋值运算符重载格式
参数类型：const T&，传递引用可以提高传参效率。
返回值类型：T&，返回引用可以提高返回的效率，由返回值的目的是为了支持连续赋值
检测是否自己给自己赋值
返回*this：要复合连续赋值的含义-

2.赋值运算符只可以重载成类的成员函数不能重载成全局函数：原因是，赋值运算符如果不显示实现，编译器会生成一个默认的。因此用户再在类外自己实现一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值运算符重载只能是类的成员函数。
3.用户没有显示实现时，编译器会默认生成一个赋值运算符重载，以值的方式逐字拷贝。注意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值。

class Date
{
public:
	Date(int year=1,int month=1,int day=1)
	{
		_year = year;
		_month = month;
		_day = day;

	}
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

	bool operator==(const Date& y)
	{
		return _year == y._year
			&& _month == y._month
			&& _day == y._day;
	
	}
	bool operator<(const Date& y)
	{
		if (_year < y._year)
		{
			return true;
		}
		else if (_year==y._year)
		{
			if (_month < y._month)
			{
				return true;
			}
			else if (_month == y._month)
			{
				return _day < y._day;
			}
		}
		return false;
	}
	bool operator=(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
private:
	int _year;
	int _month;
	int _day;
};


int main()
{
	Date d1(2024,1,28);
	Date d2(2024,4,6);

	cout << d1.operator==(d2) << endl;
	cout << d1.operator<(d2) << endl;
	//由于定义的函数在类里面，所以这样写传的d1的时候由隐藏的this指针负责
	//上面这两句代码与下面的这两句代码是等价的
	cout << (d1 == d2) << endl;
	cout << (d1<d2) << endl;
	
	Date d3(d1);  //拷贝构造，同类型一个存在的对象进行初始化要创建的对象
	d2 = d1;        //赋值重载  已经存在的对象，一个拷贝赋值给另一个

	d1 = d2 = d3;   //这句代码是错误的，自定义类型是不可以连续赋值的，除非像下面这样加上返回值
	return 0;


//如果要可以进行连续赋值的话，加上返回值就可以
Date operator=(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
		return *this;
	}
}
//其实改成这样还是有缺陷，这里用的是传值返回，返回的并不是*this，而是它的拷贝，同类型拷贝又要调用拷贝构造，这样太浪费了，因此可以改成下面的样子


Date& operator=(const Date& d)  //加一个引用
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
		return *this;
	}

5.3 前置++和后置++重载

class Date
{
public:
 Date(int year = 1900, int month = 1, int day = 1)
 {
 _year = year;
 _month = month;
 _day = day;
 }
 // 前置++：返回+1之后的结果
 // 注意：this指向的对象函数结束后不会销毁，故以引用方式返回提高效率
 Date& operator++()
 {
 _day += 1;
 return *this;
 }
 // 后置++：
 // 前置++和后置++都是一元运算符，为了让前置++与后置++形成能正确重载
 // C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器
自动传递
 // 注意：后置++是先使用后+1，因此需要返回+1之前的旧值，故需在实现时需要先将this保存
一份，然后给this+1
 //       而temp是临时对象，因此只能以值的方式返回，不能返回引用
 Date operator++(int)
 {
 Date temp(*this);
 _day += 1;
 return temp;
 }
private:
 int _year;
 int _month;
 int _day;
};

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

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

相关文章

公安局软件管理平台建设方案和必要性，论文-3-———未来之窗行业应用跨平台架构

公安局软件管理平台建设方案和必要性，论文-3-———未来之窗行业应用跨平台架构

三、平台功能设计 四、技术架构 1. 前端界面 - 采用简洁、易用的设计风格&#xff0c;适应不同终端设备的访问。 - 基于 HTML5、CSS3 和 JavaScript 构建。 2. 后端服务 - 选择主流的 Web 开发框架&#xff0c;如 未来之窗跨平台架构&#xff0c;VUE。 - 数据库…
阅读更多...
IIS HTTPS 网页可能暂时无法连接，或者它已永久性地移动到了新网址 ERR_HTTP2_INADEQUATE_TRANSPORT_SECURITY

IIS HTTPS 网页可能暂时无法连接，或者它已永久性地移动到了新网址 ERR_HTTP2_INADEQUATE_TRANSPORT_SECURITY

问题描述&#xff1a;站点突然无法访问&#xff0c;经排查发现&#xff0c;HTTP协议的网址可以继续访问&#xff0c;HTTPS的网址不可以访问。 问题分析&#xff1a;在Windows更新和滚动之后&#xff0c;由于 HTTP/2&#xff0c;当站点启动了 HTTP/2 连接&#xff0c;会出现一个…
阅读更多...
【春秋云境】CVE-2024-23897-Jenkins 2.441之前版本存在任意文件读取漏洞

【春秋云境】CVE-2024-23897-Jenkins 2.441之前版本存在任意文件读取漏洞

一、靶场介绍 Jenkins 2.441及更早版本&#xff0c;以及LTS 2.426.2及更早版本没有禁用其CLI命令解析器的一个功能&#xff0c;该功能会将参数中’字符后跟的文件路径替换为该文件的内容&#xff0c;允许未经身份验证的攻击者读取Jenkins控制器文件系统上的任意文件。 二、P…
阅读更多...
Linux——HTTPS协议

Linux——HTTPS协议

HTTPS也是一个应用层协议&#xff1a;只是是在 HTTP 协议的基础上引入了一个加密层而已~ 目录 概念准备 1什么是加密 2为什么要加密 3常见的加密方式 对称加密 非对称加密 数据摘要(数据指纹) 一HTTPS加密方式 方案1只使用对称加密 方案2只使用非对称加密 方案3双…
阅读更多...
C#|.net core 基础 - 深拷贝的五大类N种实现方式

C#|.net core 基础 - 深拷贝的五大类N种实现方式

在实际应用中经常会有这样的需求&#xff1a;获取一个与原对象数据相同但是独立于原对象的精准副本&#xff0c;简单来说就是克隆一份&#xff0c;拷贝一份&#xff0c;复制一份和原对象一样的对象&#xff0c;但是两者各种修改不能互相影响。这一行为也叫深克隆&#xff0c;深…
阅读更多...
第6章 常用UI组件库

第6章 常用UI组件库

一.Element Plus组件库 1. 安装Element Plus 什么是Element Plus&#xff1f; Element Plus是基于Vue 3开发的优秀的PC端开源UI组件库&#xff0c;它是Element的升级版&#xff0c;对于习惯使用Element的人员来说&#xff0c;在学习Element Plus时&#xff0c;不用花费太多的…
阅读更多...
CC面试准备

CC面试准备

半导体基础 半导体是介于导体和绝缘体之间的一种介质&#xff0c;在不同条件下表现出不同的导电性或者不导电特性&#xff0c; 电子半导体器件材料大部分为硅&#xff0c;锗等元素 本征半导体&#xff1a;完全不含杂质的纯净半导体&#xff0c;因为不含杂质&#xff0c;其中…
阅读更多...
[笔记]一组电缆、定位相关产品的技术参数

[笔记]一组电缆、定位相关产品的技术参数

csdn不允许做广告&#xff0c;这里的那家定位供应商的技术看起来是可以的。很有希望。它的原理并不复杂&#xff0c;这家企业在处理业务领域以外的新型产品时&#xff0c;是查过资料的&#xff0c;这就超过了60%的同行。 1.电缆 仅给出现在市面供应的铠装电缆结构&#xff0c…
阅读更多...
七层负载均衡和四层负载均衡的区别

七层负载均衡和四层负载均衡的区别

文章目录 什么是七层负载均衡&#xff1f;一、定义与工作原理二、优点与缺点三、应用场景四、常见七层负载均衡器五、负载均衡算法 什么是四层负载均衡&#xff1f;一、定义与原理定义&#xff1a;原理&#xff1a; 二、特点与应用场景特点&#xff1a;应用场景&#xff1a; 三…
阅读更多...
STM32基础学习笔记-ADC面试基础题6

STM32基础学习笔记-ADC面试基础题6

第六章、ADC 常见问题 1、基本概念&#xff1a;什么是ADC &#xff1f;作用 &#xff1f;逐次逼近型 2、传感器本质 &#xff1f;传感器、电压、ADC数值转化 &#xff1f; 3、ADC的特征 &#xff1f; 转化时间、分辨率、精度、量化误差 &#xff1f; 4、ADC框图组成部分 &…
阅读更多...
华为云发布全栈可观测平台AOM，以AI赋能应用运维可观测

华为云发布全栈可观测平台AOM，以AI赋能应用运维可观测

9月19日&#xff0c;华为全联接大会2024举办期间&#xff0c;在“AI赋能应用现代化&#xff0c;加速软件生产力跃升”为主题的论坛上&#xff0c;华为云发布全栈可观测平台AOM&#xff0c;以AI赋能应用运维可观测&#xff0c;提升企业应用可用性与稳定性。 该平台发布标志着华…
阅读更多...
针对国产化--离线安装Nginx rpm包下载 ARM64(.aarch64.rpm) 版本下载

针对国产化--离线安装Nginx rpm包下载 ARM64(.aarch64.rpm) 版本下载

源地址&#xff1a;https://nginx.org/packages/centos/7/aarch64/RPMS/ 可以选择系统分别进行下载对应的rmp包
阅读更多...
公安局软件管理平台建设方案和必要性，论文-2-———未来之窗行业应用跨平台架构

公安局软件管理平台建设方案和必要性，论文-2-———未来之窗行业应用跨平台架构

一、平台方略 随着gov信息化建设的不断推进&#xff0c;各类ZW软件的应用需求日益增加。为了提高ZW软件的获取便利性、AQ性和规范性&#xff0c;建设一个专门的GOV软件管理平台具有重要意义。 集中提供各类ZW软件&#xff0c;方便工作人员快速获取和安装&#xff0c;减少因软…
阅读更多...
基于DAMODEL——Faster-RCNN 训练与测试指南

基于DAMODEL——Faster-RCNN 训练与测试指南

Faster-RCNN 训练与测试指南 前言 今天我们要来实现一个经典的目标检测模型&#xff1a;Faster-Rcnn。我们使用DAMODEL云平台来实现&#xff0c;这是个很强大的云端平台&#xff0c;功能众多&#xff0c;你可以投你所好去进行你想做的事情。 1. 环境与工具准备 1.1 远程连接…
阅读更多...
经颅磁刺激技术，脑科学研究——精神患者治疗方案

经颅磁刺激技术，脑科学研究——精神患者治疗方案

经颅磁刺激&#xff08;Transcranial Magnetic Stimulation &#xff0c;TMS&#xff09;技术是一种利用脉冲磁场作用于中枢神经系统&#xff08;主要是大脑&#xff09;&#xff0c;改变皮层神经细胞的膜电位&#xff0c;使之产生感应电流&#xff0c;影响脑内代谢和神经电活动…
阅读更多...
开放原子开源基金会OPENATOM

开放原子开源基金会OPENATOM

AtomGit_开放原子开源基金会代码托管平台-AtomGit 开放原子开源基金会是致力于推动全球开源事业发展的非营利机构&#xff0c;于 2020 年 6 月在北京成立&#xff0c;由阿里巴巴、百度、华为、浪潮、360、腾讯、招商银行等多家龙头科技企业联合发起。 精选项目&#xff1a; 比…
阅读更多...
HDFS_API文件和文件夹

HDFS_API文件和文件夹

代码&#xff1a; Beforepublic void init() throws URISyntaxException, IOException {URI uri new URI("hdfs://master:9000");// 创建一个配置文件Configuration entries new Configuration();// 获取到了客户端对象 // entries.set("dfs.replicat…
阅读更多...
【C++笔试强训】

【C++笔试强训】

​ 学习编程就得循环渐进&#xff0c;扎实基础&#xff0c;勿在浮沙筑高台 循环渐进Forward-CSDN博客 目录 循环渐进Forward-CSDN博客 第一题&#xff1a;除2&#xff01; 第二题&#xff1a;dd爱框框 第三题&#xff1a;简写单词 第一题&#xff1a;除2&#xff01; 牛客网…
阅读更多...
Uniapp 打包后的横屏控制

Uniapp 打包后的横屏控制

文章目录 问题处理参考 问题 Uniapp 打包后的横竖屏跟开发模式不太一样&#xff0c;需要在代码里设置一下 处理 需要改两个地方 pages.json&#xff1a;在 globalStyle 中添加 "pageOrientation": "auto", manifest.json&#xff1a;在第一层后面添加…
阅读更多...
每日学习一个数据结构-哈希表(散列表)

每日学习一个数据结构-哈希表(散列表)

文章目录 示意图一、基本概念二、工作原理三、常用哈希函数四、冲突解决方法五、优缺点六、应用场景 哈希表&#xff08;Hash table&#xff09;&#xff0c;也被称为散列表&#xff0c;是一种基于哈希函数的数据结构&#xff0c;它通过把关键码值&#xff08;Key value&#x…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023