【C++】类与对象 第二篇(构造函数，析构函数，拷贝构造，赋值重载)

目录

类的6个默认成员函数

初始化和清理

1.构造函数

2.析构函数

3.共同点

拷贝复制

1.拷贝构造

使用细节

2.赋值重载

运算符重载

== <= < >= > !=

连续赋值

C++入门 第一篇(C++关键字， 命名空间，C++输入&输出)-CSDN博客

C++入门 第二篇( 引用、内联函数、auto关键字、指针空值nullptr)-CSDN博客

【C++】类与对象 第一篇(class,this)-CSDN博客

类的6个默认成员函数

默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。

初始化和清理

1.构造函数

特征： 构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任 务并不是开空间创建对象，而是初始化对象。 其特征如下:

  1. 函数名与类名相同。

  2. 无返回值。

  3. 对象实例化时编译器自动调用对应的构造函数。

  4. 构造函数可以重载。

 class Stack
 {
 public:
     Stack()
     {
         _a=nullptr;
         _size=_capacity=0;
     }
 ​
     Stack(int n)
     {
         _a=(int*)malloc(sizeof(int)*n);
         _size=_capacity=0;
     }
 ​
     void Init(int n=4)
     {
         _a=(int*)malloc(sizeof(int)*n);
         if (nullptr==_a)
         {
             perror("malloc is fail");
             return;
         }
         _capacity=n;
         _size=0;
     }
 ​
     void Push(int x)
     {
         //...
         a[_size++]=x;
     }
     //...
     void Dstory()
     {
         //...
     }
 ​
 private:
     int _a;
     int _size;
     int _capacity;
 };
 ​
 int main()
 {
     Stack st;//无参
    //Stack st();//有参
 ​
     st.Push(1);
     st.Push(2);
     st.Push(3);
     st.Push(4);
 ​
     st.Dstory();
 ​
     return 0;
 }

以上述代码为例：

自动调用初始化

注意：调用无参时如：Data d;此处在后面不能➕()，否则编译器会调用有参的。

使用缺省值：

 class Date
 {
 public:
     Date(int year=1,int month=1,int day=1)
     {
         _year=1;
         _month=1;
         _day=1;
     }
 ​
     void print()
     {
         cout<<_year<<"/"<<_month<<"/"<<_day<<endl;
     }
 ​
 private:
     //成员变量
     int _year;
     int _month;
     int _day;
 };
 ​
 int main()
 {
     //Date d1;
     Date d2(2077,2,3);
     d2.print();
 ​
     return 0;
 }

2.析构函数

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

特性 析构函数是特殊的成员函数，其特征如下:

  1. 析构函数名是在类名前加上字符 ~。

  2. 无参数无返回值类型。

  3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意:析构 函数不能重载

  4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。

例子：

 typedef int DataType;
 class Stack
 {
 public:
     Stack(size_t capacity = 3)
     {
         _array = (DataType *)malloc(sizeof(DataType) * capacity);
         if (NULL == _array)
         {
             perror("malloc申请空间失败!!!");
             return;
         }
         _capacity = capacity;
         _size = 0;
     }
     void Push(DataType data)
     {
         // CheckCapacity();
         _array[_size] = data;
         _size++;
     }
     // 其他方法...
     ~Stack()
     {
         if (_array)
         {
             free(_array);
             _array = NULL;
             _capacity = 0;
             _size = 0;
         }
     }
 ​
 private:
     DataType *_array;
     int _capacity;
     int _size;
 };
 void TestStack()
 {
     Stack s;
     s.Push(1);
     s.Push(2);
 }

3.共同点

如果编译过程不写，那编译器会自动生成一个默认的，但是如果我们实现了任意一个，编译器就不会生成了。

若是自动初始化，那为什么这个地方会生成随机值呢？

C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类 型，如:int/char...，自定义类型就是我们使用class/struct/union等自己定义的类型，看看 下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员_t调用的它的默认成员 函数。

内置类型(基本类型):int/char/double... /任意类型指针 自定义类型:class/structd定义的

默认生成构造函数：

1.内置类型成员不做处理。

2.自定义类型的成员，会去调用它的默认构造（不用传参数的构造）

 private:
     // 基本类型/内置类型 - 不进初始化
     int _year;
     int _month;
     int _day;

实用场景：

 class Date
 {
 public:
     //内置类型成员不做处理
     void print()
     {
         cout<<_year<<"/"<<_month<<"/"<<_day<<endl;
     }
 ​
 private:
     // 基本类型/内置类型 - 不进初始化
     int _year;
     int _month;
     int _day;
 };
 ​
 class MyQueue
 {
     // 默认生成构造函数，对自定义类型，会调用它的默认构造函数
     void push(int x);
     {
 ​
     }
     //...
   
     Stack _pushST();
     Stack _popST();
 };

析构：

默认生成构造函数：

1.内置类型成员不做处理。

2.自定义类型的成员，会去调用它的析构函数

 class MyQueue
 {
     // 默认生成析构函数，对自定义类型，会调用它的析构函数
     void push(int x);
     {
 ​
     }
     Stack _pushST();
     Stack _popST();
 };
 ​
 int main()
 {
     //Date d1;
     Date d1;
     d1.print();
 ​
     MyQueue q;
 ​
     return 0;
 }

内置类型并不会主动初始化，但可以通过给缺省值进行初始化：

 private:
 //声明位置给缺省值
     int _year=1;
     int _month=1;
     int _day=1;

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

拷贝复制

1.拷贝构造

拷贝构造函数:只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存 在的类类型对象创建新对象时由编译器自动调用。

拷贝构造：内置类型，编译器直接拷贝，自定义类型拷贝需要调用拷贝构造

特征

拷贝构造函数也是特殊的成员函数，其特征如下:

  1. 拷贝构造函数是构造函数的一个重载形式。

    （

    为什么自定义类型要用拷贝构造，而内置类型编译器却可以直接拷贝(按字节拷贝)？ ​ 因为自定义类型进行拷贝容易出问题：若要拷贝栈，栈的成员变量都是指向相同的空间，若进行拷贝，则会导致两个Stack指向同一个空间，导致原本Stack执行析构函数时被销毁，而复制的那个则指向空，正确的应该是各有各的空间。

    ）

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

class Date
 {
 public:
     Date(int year=2077, int month=10, int day=12)
     {
         _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;
 };

在拷贝构造函数 Date(Date d) 中，参数 d 是按值传递的，这意味着每次调用拷贝构造函数时都会创建一个新的 Date 对象，并将原始对象 d 复制到新的对象中。然而，在拷贝构造函数内部，对于拷贝构造函数的调用又会传递同样的参数 d，导致不断地递归调用拷贝构造函数，从而产生无限递归。

则可以使用 & ，使其不在重新创建空间并使用原Date对象

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

这个拷贝构造函数将创建一个新的 Date 对象，并将原始对象的 _year、_month 和 _day 成员变量的值分别拷贝到新对象的相应成员变量中。通过使用对象引用作为参数，我们可以避免无限递归调用拷贝构造函数的问题，并且确保在构造新对象时不会复制整个对象

 
class Date
 {
 public:
     Date(int year = 2077, int month = 10, int day = 12)
     {
         _year = year;
         _month = month;
         _day = day;
     }
 ​
     Date(const Date& d)//const是为了防止写反->d._year = _year;加const缩小权限
     {
         cout<<"Date(Date& d);"<<endl;
         _year = d._year;
         _month = d._month;
         _day = d._day;
     }
 ​
 private:
     int _year;
     int _month;
     int _day;
 };
 ​
 int main()
 {
     Date d1(2023, 2, 3);
     //两种拷贝方式
     Date d2(d1); // 使用拷贝构造函数创建对象 d2，并将 d1 的值拷贝到 d2 中
     Date d3=d1;
 ​
     return 0;
 }

RunCode:

若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按 字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

深拷贝是指在对象拷贝时，复制所有的数据和资源，使得新对象和原对象完全独立，互不影响。与之相对的是浅拷贝，浅拷贝只复制指针或引用，导致新旧对象共享同一份数据，修改一个可能会影响另一个。深拷贝能够保证对象之间的独立性和数据完整性。

分清楚是不是拷贝构造：

 class Date
 {
 public:
     Date(int year = 2077, int month = 10, int day = 12)
     {
         _year = year;
         _month = month;
         _day = day;
     }
   
     //拷贝构造函数   
     Date(const Date& d)
     {
         cout<<"Date(Date& d);"<<endl;
         _year = d._year;
         _month = d._month;
         _day = d._day;
     }
 ​
     //构造函数 不是拷贝构造
     Date(const Date* d)
     {
         cout<<"Date(Date& d);"<<endl;
         _year = d._year;
         _month = d._month;
         _day = d._day;
     }
 private:
     int _year;
     int _month;
     int _day;
 };
 ​
 int main()
 {
     Date d1(2023, 2, 3);
 //Date(const Date* d)
     Date d2(&d1); 
     Date d3=&d1;
 ​
     return 0;
 }

拷贝构造函数典型调用场景:

  • 使用已存在对象创建新对象

  • 函数参数类型为类类型对象

  • 函数返回值类型为类类型对象

使用细节

1使用拷贝构造时最好加上const，以防权限的放大

   // 拷贝构造
     Date(const Date &d)
     {
         _year = d.year;
         _month = d.month;
         _year = d.year;
     }

2编译器可自动生成但存在问题

本文所用的日期类可以使用自动生成拷贝，但进行拷贝栈时就会出现问题

当进行拷贝时，用值拷贝，导致两个栈指向同一个空间，造成空间互相覆盖 指向同一块空间的问题：1.插入删除数据会互相影响 2.析构两次，程序崩溃

析构是也跟栈一样是后进先出，后定义的先析构，故st2先析构，对st2滞空是，并不影响st1，导致野指针。此时浅拷贝行不通，需要进行深拷贝:

代码实现：

class Stack
 {
 public:
     void Push(const int &data)
     {
         _array[_size] = data;
         _size++;
     }
 ​
     Stack(const Stack &st)
     {
         _array = (int *)malloc(sizeof(int) * st._capacity);
         if (nullptr == _array)
         {
             perror("malloc is fail");
             exit(-1);
         }
         memcpy(_array, st._array, sizeof(int) * st._size);
         _size = st._size;
         _capacity = st._capacity;
     }
 ​
     ~Stack()
     {
         if (_array)
         {
             delete[] _array;
             _array = nullptr;
             _capacity = 0;
             _size = 0;
         }
     }
 ​
 private:
     int *_array;
     int _size;
     int _capacity;
 };
 ​
 int main()
 {
     Stack st1;
     st1.Push(1);
     st1.Push(2);
     st1.Push(3);
 ​
     Stack st2(st1);
 ​
     return 0;
 }

什么情况下需要事项拷贝构造呢？ 自己实现了析构释放空间，就需要实现拷贝构造

 class Stack
 {
 public:
     //构造函数  
     Stack(size_t _capacity = 10)
     {
         cout << "Stack(size_t _capacity)" << endl;
         _array = (int *)malloc(sizeof(int) * _capacity);
         if (nullptr == _array)
         {
             perror("malloc is fail");
             exit(-1);
         }
         _size = 0;
         _capacity = _capacity;
     }
 ​
     void Push(const int &data)
     {
         _array[_size] = data;
         _size++;
     }
 ​
     //拷贝构造
     Stack(const Stack &st)
     {
         _array = (int *)malloc(sizeof(int) * st._capacity);
         if (nullptr == _array)
         {
             perror("malloc is fail");
             exit(-1);
         }
         memcpy(_array, st._array, sizeof(int) * st._size);
         _size = st._size;
         _capacity = st._capacity;
     }
 ​
     ~Stack()
     {
         if (_array)
         {
             delete[] _array;
             _array = nullptr;
             _capacity = 0;
             _size = 0;
         }
     }
 ​
 private:
     int *_array;
     int _size;
     int _capacity;
 };
 ​
 class MyQueue
 {
     //默认生成构造 ->生成定义在Stack中的默认构造函数
     //默认生成析构
     //默认生成的拷贝构造
     
 private:
     Stack _pushST;
     Stack _popST;
     int _size = 0;
 };
 ​
 int main()
 {
     Stack st1;
     st1.Push(1);
     st1.Push(2);
     st1.Push(3);
 ​
     Stack st2(st1);
     cout<<"====="<<endl;
     MyQueue q;
 ​
     return 0;
 }

默认生成拷贝构造和赋值重载：

a.内置类型完成 浅/值 拷贝--按byte一个一个拷贝

b.自定义类型，去调用这个成员 拷贝构造/赋值重载

2.赋值重载

运算符重载

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其 返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

函数名字为:关键字operator后面接需要重载的运算符符号。 函数原型:返回值类型 operator操作符(参数列表)

自定义类型不能直接使用运算操作符 内置类型是语法定义，而自定义类型为人为定义，编译器并不知道该如何进行比较，这便出现了operator用函数完成

运算符重载：自定义类型对象可以使用运算符

函数重载：支持函数名相同，参数不同的函数

 
#include <iostream>
 using namespace std;
 ​
 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;
     }
 ​
     // d1==d2 -> d1.operator==(d2)
     bool operator==(const Date &d)
     {
         return _year == d._year && _month == d._month && _day == d._day;
         //    this->_year==d.year
     }
 ​
 private:
     // 成员变量
     int _year;
     int _month;
     int _day;
 };
 ​
 int main()
 {
     Date d1(2077, 2, 4);
     Date d2(2077, 2, 4);
 ​
     // d1==d2;
     cout << d1.operator==(d2) << endl;
     cout << (d1 == d2) << endl;
 ​
     return 0;
 }

注意:

  • 不能通过连接其他符号来创建新的操作符:比如operator

  • 重载操作符必须有一个类类型参数

  • 用于内置类型的运算符，其含义不能改变，例如:内置的整型+，不能改变其含义

  • 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐 藏的this现。

  • 注意以下5个运算符不能重载

     .*   ::  sizeof  ?:   .

== <= < >= > !=
// d1==d2 -> d1.operator==(d2)
     bool operator==(const Date &d)
     {
         return _year == d._year && _month == d._month && _day == d._day;
         //    this->_year==d.year
     }
 ​
     // bool operator<(const Date &d)
     // {
     //     if (_year < d._year)
     //     {
     //         return true;
     //     }
     //     else if (_year == d._year && _month < d._month)
     //     {
     //         return true;
     //     }
     //     else if (_year == d._year && _month == d._month && _day < d._day)
     //     {
     //         return true;
     //     }
     //     else
     //         return false;
     // }
 ​
     // d1<d2
     bool operator<(const Date &d)
     {
         return _year < d._year && (_year == d._year && 
        _month < d._month) && (_year == d._year && 
        _month == d._month && _day < d._day);
     }

任何一个类都适用于，当写了一个>=或<=那其他的就可以进行复用

     // d1<=d2
     bool operator<=(const Date &d)
     {
         return *this < d || *this == d;//*this就是d1
     }

这个地方对operator<(const Date &d)进行了复用。operator<=(const Date &d)中的表达式*this < d调用了operator<(const Date &d)来判断两个日期对象的大小关系。同时，operator<=(const Date &d)还利用operator==(const Date &d)来判断两个日期对象是否相等。通过这样的复用方式，可以简化代码并提高代码的可读性

     // d1>d2
     bool operator>(const Date &d)
     {
         return !(*this<= d);
     }
 ​
     //d1>=d2
     bool operator>=(const Date& d)
     {
         return !(*this<d);
     }
 ​
     //d1!=d2
     bool operator!=(const Date& d)
     {
         return !(*this ==d);
     }

当然赋值运算符不使用&并不会无限循环

    // d1<=d2
     bool operator<=(const Date d)
     {
         return *this < d || *this == d;
     }

当然可以不用，但是最好还是加上

连续赋值

d3 = d1 = d2

     // 因为Date operator=(const Date &d) 出了该函数的作用域*this/d1 还在此时返回的*this是临时拷贝，需要进行拷贝重新开空间造成浪费，不如直接进行&
     Date operator=(const Date &d)//&d 引用
     {
         if (this != &d)//防止d1=d1进行赋值 此处的&为去地址 ，若this与d的地址一样则无需赋值
         {
             _year = d._year;
             _month = d._month;
             _day = d._day;
         }
 ​
         return *this; //*this就是d1
     }                 // 返回值为了支持连续赋值，保持运算符特性  d3=d1=d2;

当然要注意，赋值重载是针对已经创造的对象

 Date d5=d1;//拷贝构造

像这样就是拷贝构造

同样作为默认成员函数，可以不用手动写

源码：

 #include <iostream>
 using namespace std;
 ​
 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;
     }
   
     // d1==d2 -> d1.operator==(d2)
     bool operator==(const Date &d)
     {
         return _year == d._year && _month == d._month && _day == d._day;
         //    this->_year==d.year
     }
 ​
     // d1<d2
     bool operator<(const Date &d)
     {
         return _year < d._year && (_year == d._year && _month < d._month) && (_year == d._year && _month == d._month && _day < d._day);
     }
 ​
     // d1<=d2
     bool operator<=(const Date &d)
     {
         return *this < d || *this == d; //*this就是d1
     }
 ​
     // d1>d2
     bool operator>(const Date &d)
     {
         return !(*this <= d);
     }
 ​
     // d1>=d2
     bool operator>=(const Date &d)
     {
         return !(*this < d);
     }
 ​
     // d1!=d2
     bool operator!=(const Date &d)
     {
         return !(*this == d);
     }
 ​
     // // 因为Date operator=(const Date &d) 出了该函数的作用域*this/d1 还在此时返回的*this是临时拷贝，需要进行拷贝重新开空间造成浪费，不如直接进行&
     // Date operator=(const Date &d)//&d 引用
     // {
     //     if (this != &d)//防止d1=d1进行赋值 此处的&为去地址 ，若this与d的地址一样则无需赋值
     //     {
     //         _year = d._year;
     //         _month = d._month;
     //         _day = d._day;
     //     }
 ​
     //     return *this; //*this就是d1
     // }                 // 返回值为了支持连续赋值，保持运算符特性  d3=d1=d2;
 ​
 private:
     // 成员变量
     int _year;
     int _month;
     int _day;
 };
 ​
 int main()
 {
     Date d1(2077, 2, 4);
     Date d2(2222, 3, 2);
     Date d3(2078, 2, 4);
 ​
     cout << (d1 < d2) << endl;
     // d3 = d1 = d2;
 ​
     d1 = d2;
     d1.Print();
 ​
     return 0;
 }

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

tomcat9~10猫闪退个人经验

tomcat9~10猫闪退个人经验

java版本17与8 8版本有jre&#xff0c;java17没有jre 所以在java8版本中将jre和jdk路径一同添加环境是不会出现闪退的&#xff0c;tomcat9没有闪退 但是在10就闪退了&#xff0c;因为java版本太低 java17没有jre&#xff0c;但是可以通过一种方法添加jre到java17的目录 完…
阅读更多...
数学与经济管理

数学与经济管理

数学与经济管理&#xff08;2-4分&#xff09; 章节概述 最小生成树问题 答案&#xff1a;23 讲解地址&#xff1a;74-最小生成树问题_哔哩哔哩_bilibili 最短路径问题 答案&#xff1a;81 讲解地址&#xff1a;75-最短路径问题_哔哩哔哩_bilibili 网络与最大流量问题 真题 讲解…
阅读更多...
基于引力搜索算法的无人机航迹规划-附代码

基于引力搜索算法的无人机航迹规划-附代码

基于引力搜索算法的无人机航迹规划 文章目录 基于引力搜索算法的无人机航迹规划1.引力搜索搜索算法2.无人机飞行环境建模3.无人机航迹规划建模4.实验结果4.1地图创建4.2 航迹规划 5.参考文献6.Matlab代码 摘要&#xff1a;本文主要介绍利用引力搜索算法来优化无人机航迹规划。 …
阅读更多...
前端伪进度条实现(仿antd message使用react组件静态方法)

前端伪进度条实现(仿antd message使用react组件静态方法)

文章目录 背景实现方法(一) react组件静态方法(二) 通过静态方法改变组件的状态(三) 指定进度条的步幅规则(四) 成功和失败的状态改变1. 成功2. 失败 (五) 组件消失(六) 背景遮罩 最终实现及代码组件代码模拟调用进度条组件的代码 可能遇到的问题静态方法调不到/报错组件渲染两…
阅读更多...
帆软report JS实现填报控件只能填写一次

帆软report JS实现填报控件只能填写一次

效果 方法&#xff1a; 代码&#xff1a; if(this.getValue()!"")//判断这个控件框是否有值&#xff0c;这里是不为空{this.setEnable(false)}//不为空&#xff0c;则不能再修改else{this.setEnable(true)}//为空&#xff0c;可以编辑
阅读更多...
Perl爬虫程序

Perl爬虫程序

以下是一个使用Perl爬虫程序&#xff0c;用于爬取图像。每行代码的中文解释如下&#xff1a; #!/usr/bin/perl ​ use strict; use warnings; use Mojo::UserAgent; use JSON; ​ # 创建一个Mojo::UserAgent实例 my $ua Mojo::UserAgent->new; ​ # 使用获取代理 my $prox…
阅读更多...
计算机网络重点概念整理-第三章 数据链路层【期末复习|考研复习】

计算机网络重点概念整理-第三章 数据链路层【期末复习|考研复习】

第三章 数据链路层 【期末复习|考研复习】 计算机网络系列文章传送门&#xff1a; 第一章 计算机网络概述 第二章 物理层 第三章 数据链路层 第四章 网络层 第五章 传输层 第六章 应用层 第七章 网络安全 计算机网络整理-简称&缩写 文章目录 第三章 数据链路层 【期末复习…
阅读更多...
两数和的目标 python （初学者vs程序员）

两数和的目标 python （初学者vs程序员）

题目描述 1&#xff09;给定一个整数列表&#xff0c;在列表中&#xff0c;从前向后查找两个元素使其相加之和等于目标数&#xff0c;并返回两个整数在列表中的下标。如果没有符合条件的数字&#xff0c;输出False&#xff0c;本题假设题目的解唯一。‬‪‬‪‬‪‬‪‬‮‬‪…
阅读更多...
AT32固件库外设使用，ArduinoAPI接口移植，模块化

AT32固件库外设使用，ArduinoAPI接口移植，模块化

目录 一、ArduinoAPI移植一、通用定时器使用1.计时1.2.ETR外部时钟计数4.ArduinoAPI - timer 三、ADC1.ADC初始化&#xff08;非DMA&#xff09;2.ADC_DMA 规则通道扫描 六、USB HID IAP1.准备好Bootloader和app2.配置好时钟&#xff0c;一定要打开USB3.将生成的时钟配置复制到…
阅读更多...
《Attention Is All You Need》阅读笔记

《Attention Is All You Need》阅读笔记

论文标题 《Attention Is All You Need》 XXX Is All You Need 已经成一个梗了&#xff0c;现在出现了很多叫 XXX Is All You Need 的文章&#xff0c;简直标题党啊&#xff0c;也不写方法&#xff0c;也不写结果&#xff0c;有点理解老师扣论文题目了。 作者 这个作者栏太…
阅读更多...
vue源码分析（五）——vue render 函数的使用

vue源码分析（五）——vue render 函数的使用

文章目录 前言一、render函数1、render函数是什么&#xff1f; 二、render 源码分析1.执行initRender方法2.vm._c 和 vm.$createElement 调用 createElement 方法详解&#xff08;1&#xff09;区别&#xff08;2&#xff09;代码 3、原型上的_render方法&#xff08;1&#xf…
阅读更多...
视频特效制作软件 After Effects 2023 mac中文版介绍说明

视频特效制作软件 After Effects 2023 mac中文版介绍说明

After Effects 2023 mac是一款专业视频特效和动态图形设计软件。ae2023被广泛应用于电影、电视节目、广告和网络媒体等领域&#xff0c;可以创建各种令人惊叹的视觉效果。 在After Effects 2023中&#xff0c;用户可以使用强大的工具和功能来制作复杂的特效和动画。新版本引入了…
阅读更多...
数据库简史：多主数据库架构的由来和华为参天引擎的机遇

数据库简史：多主数据库架构的由来和华为参天引擎的机遇

注&#xff1a;本文发表后&#xff0c;收到了很多后台反馈&#xff0c;其中关于大型机的早期成就不容省略。微调重发本文&#xff0c;纯属个人观点&#xff0c;错谬之处&#xff0c;仍然期待指正。 2023年10月13日&#xff0c;在北京举办的“2023金融业数据库技术大会"上&…
阅读更多...
GPT的广泛应用会对互联网公司造成挑战吗？——探讨GPT在实际使用中的应用和影响

GPT的广泛应用会对互联网公司造成挑战吗？——探讨GPT在实际使用中的应用和影响

文章目录 前言GPT 技术的背景和发展历程GPT 技术对互联网行业的影响GPT 技术在互联网行业中的应用GPT 技术对于用户隐私和数据安全的威胁GPT 技术对于人类工作岗位的影响加强 AI 伦理和监管加强 AI 安全性和隐私保护推动 AI 创新和发展&#xff0c;避免过度依赖 AIGPT 技术是一…
阅读更多...
HIT_OS_LAB1 调试分析 Linux 0.00 引导程序

HIT_OS_LAB1 调试分析 Linux 0.00 引导程序

操作系统实验一 姓名&#xff1a;董帅学号&#xff1a;2021111547班级&#xff1a;21R0312 1.1 实验目的 熟悉实验环境掌握如何手写Bochs虚拟机的配置文件掌握Bochs虚拟机的调试技巧掌握操作系统启动的步骤 1.2 实验内容 1.2.1 掌握如何手写Bochs虚拟机的配置文件 boot: f…
阅读更多...
2.MySQL的调控按钮——启动选项和系统变量

2.MySQL的调控按钮——启动选项和系统变量

2.MySQL的调控按钮——启动选项和系统变量 1.启动选项和配置文件1.1 在命令行上使用选项1.2 配置文件中使用选项1.2.1 配置文件路径1.2.2 配置文件的内容1.2.3 特定 MySQL 版本的专用选项组1.2.4 配置文件的优先级1.2.5 同一个配置文件中多个组的优先级1.2.6 defaults-file 的使…
阅读更多...
回归预测 | MATLAB实现BO-BiLSTM贝叶斯优化双向长短期神经网络多输入单输出回归预测

回归预测 | MATLAB实现BO-BiLSTM贝叶斯优化双向长短期神经网络多输入单输出回归预测

回归预测 | MATLAB实现BO-BiLSTM贝叶斯优化双向长短期神经网络多输入单输出回归预测 目录 回归预测 | MATLAB实现BO-BiLSTM贝叶斯优化双向长短期神经网络多输入单输出回归预测效果一览基本介绍模型搭建程序设计参考资料 效果一览 基本介绍 MATLAB实现BO-BiLSTM贝叶斯优化双向长…
阅读更多...
mysql源码安装

mysql源码安装

Linux环境 1、mysql下载地址&#xff1a;https://dev.mysql.com/downloads/mysql/5.7.html#downloads 下载参考&#xff1a; 2、把下载的 MySQL 压缩包上传到 Linux 服务器 3、解压mysql-5.7.39-linux-glibc2.12-x86_64.tar.gz tar -zxvf mysql-5.7.39-linux-glibc2.12-x86…
阅读更多...
【Linux】解决缓存锁问题：无法获得锁 /var/lib/dpkg/lock-frontend

【Linux】解决缓存锁问题：无法获得锁 /var/lib/dpkg/lock-frontend

今天在运行apt-get update更新软件包后&#xff0c;突然发现安装新的软件出现了这个报错&#xff1a;正在等待缓存锁&#xff1a;无法获得锁 /var/lib/dpkg/lock-frontend。锁正由进程 1855&#xff08;unattended-upgr&#xff09;持有。如图。 这个错误通常是由于其他进程正在…
阅读更多...
Word批量删除文档属性和个人信息方法图解

Word批量删除文档属性和个人信息方法图解

投标文件中设计敏感信息&#xff0c;在投标前必须删除&#xff0c;Word批量删除文档属性和个人信息方法图解&#xff1a; 右键word文件属性--详细信息&#xff0c;可以查看如下信息&#xff1b; 删除上述信息的办法&#xff1a; 1.打开word文件---文件 2.检查文档、检查文档 检…
阅读更多...
最新文章

Copyright @ 2022~2023