【C++基础】类与对象(中):默认成员函数、构造函数、析构函数、拷贝构造、赋值重载函数……

在这里插入图片描述

​👻内容专栏: C/C++编程
🐨本文概括: C++基础语法。六大默认构造函数简介、构造函数、析构函数、拷贝构造函数、赋值重载函数、const成员函数、取地址重载等。
🐼本文作者: 阿四啊
🐸发布时间:2023.9.7

类的六个默认成员函数

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

构造函数

我们在写好一个类的时候,比如说栈(Stack),创建了一个对象st,但偶然地却忘记Init初始化,然后去做各种各样的PushPop操作,没有初始化,那么我们的数据就是随机值,那么运行就很可能会导致程序奔溃。下面我们就有了构造函数的概念。

构造函数概念

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

特性

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

  1. 函数名与类名相同
  2. 无返回值(不需要写void)。
  3. 对象实例化时编译器自动调用对应的构造函数
  4. 构造函数可以重载(可以写多种构造函数,提供多种初始化方式。)

以Date日期类为例,演示无参带参两种构造函数。

#include <iostream>
using namespace std;class Date
{
public://1.无参构造函数Date(){_year = 1;_month = 1;_day = 1;}//2.带参构造函数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 d1(),编译器会误认为成函数	Date d1;d1.Print();//带参构造Date d2(2023, 9, 6);d2.Print();return 0;
}

打印上述代码结果:

1/1/1
2023/9/6

提示:大家可以试着写一段日期的代码,然后写一个构造函数,利用F10调试起来,发现编译器确实会调用构造函数。

编译器生成的默认构造函数的特点

🤔关于编译器生成的默认成员函数,很多童鞋会有疑惑:不实现构造函数的情况下,编译器会生成默认的构造函数。但是看起来默认构造函数又没什么用?d对象调用了编译器生成的默认构造函数,但是d对象_year/_month/_day,依旧是随机值。也就说在这里编译器生成的默认构造函数并没有什么用?

💡C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类型,如/int/char/任意指针类型…,自定义类型就是我们使用class/struct/union等自己定义的类型,看看下面的程序,就会发现编译器生成默认的构造函数会对自定类型成员去调用的它的默认构造函数(如果没有默认构造函数,就会出现报错,这里解决的方案有个语法叫做初始化列表,会在类和对象(下)讲解)。

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;
}

总结

  1. 类中显式定义了构造函数,编译器将不再生成;
  2. 对于内置类型的成员不做处理(不是特定的标准,有的编译器会做初始化。在C++11语法中,成员变量声明支持给予缺省值。), 自定义类型的成员才会处理,会去调用这个成员的默认构造函数(注意:如果没有默认构造函数,就会出现报错,这里解决的方案有个语法叫做初始化列表,会在类与对象(下)讲解)。
  3. 一般情况下都需要我们自己写构造函数,决定初始化方式,成员变量全是自定义类型,可以考虑不写构造函数。
  4. 无参的构造函数和全缺省的构造函数都称为默认构造函数,并且默认构造函数只能有一个。
    • 无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数,都可以认为是默认构造函数。
    • 不用传递任何参数就可以调用,就是默认构造。

析构函数

析构函数概念

通过前面构造函数的学习,我们知道一个对象是怎么来的,那一个对象又是怎么没呢的?

析构函数:与构造函数功能相反,析构函数不是完成对对象本身的销毁,局部对象销毁工作是由
编译器完成的。而对象在销毁时会自动调用析构函数,完成对象中资源的清理工作。

特性

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

  1. 析构函数名是在类名前加上字符 ~
  2. 无参数无返回值类型。
  3. 一个类只能有一个析构函数。若未显式定义,系统会自动生成默认的析构函数(内置类型的成员,不做处理,自定义类型的成员,会去调用它的析构函数)。⚠️注意:析构函数不能重载
  4. 对象生命周期结束时,C++编译系统系统自动调用析构函数。
typedef int DataType;
class Stack
{
public:Stack(size_t capacity = 3){_array = (DataType*)malloc(sizeof(DataType) * capacity);if (nullptr == _array){perror("malloc申请空间失败!!!");return;}_capacity = capacity;_size = 0;}void Push(DataType data){// CheckCapacity();_array[_size] = data;_size++;}// 其他方法...~Stack(){if (_array){free(_array);_array = nullptr;_capacity = 0;_size = 0;}}
private:DataType* _array;int _capacity;int _size;
};
int main()
{Stack s1;s1.Push(1);s1.Push(2);Stack s2;s2.Push(3);s2.Push(4);return 0;
}

⚠️注意:s1s2都在函数栈帧里面,栈帧的规则通常遵循后进先出,所以编译器会先调用s2的析构函数再调用s1的析构函数。

  1. 关于编译器自动生成的析构函数,是否会完成一些事情呢?下面的程序我们会看到,编译器生成的默认析构函数,对自定类型成员调用它的析构函数。
class Time
{
public:~Time(){cout << "~Time()" << endl;}
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;
}
// 程序运行结束后输出:~Time()
// 在main方法中根本没有直接创建Time类的对象,为什么最后会调用Time类的析构函数?
// 因为:main方法中创建了Date对象d,而d中包含4个成员变量,其中_year, _month,
//_day三个是内置类型成员,销毁时不需要资源清理,最后系统直接将其内存回收即可;而_t是Time类对
//象,所以在d销毁时,要将其内部包含的Time类的_t对象销毁,所以要调用Time类的析构函数。但是:
//main函数中不能直接调用Time类的析构函数,实际要释放的是Date类对象,所以编译器会调用Date
//类的析构函数,而Date没有显式提供,则编译器会给Date类生成一个默认的析构函数,目的是在其内部
//调用Time类的析构函数,即当Date对象销毁时,要保证其内部每个自定义对象都可以正确销毁
//main函数中并没有直接调用Time类析构函数,而是显式调用编译器为Date类生成的默认析构函数
// 注意:创建哪个类的对象则调用该类的析构函数,销毁那个类的对象则调用该类的析构函数
  1. 如果类中没有申请资源时,析构函数可以不写,直接使用编译器生成的默认析构函数,比如
    Date类;有资源申请时,一定要写,否则会造成资源泄漏,比如Stack类。

拷贝构造函数

利用stack对象拷贝会出现程序奔溃

我们在C语言学习时期,知道结构体可以拷贝,下面是一份日期类Date的拷贝:

class Date
{
public://1.无参构造函数Date(){_year = 1;_month = 1;_day = 1;}//2.带参构造函数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;
};
void func(Date d)
{d.Print();
}
int main()
{Date d1(2023, 9, 1);func(d1);
}

func函数内打印对象d,可以成功打印:

2023/9/1

但是,对于栈Stack这个类去拷贝给另一个类,就会出问题了!

class Stack
{
public:Stack(size_t n = 4){if (n == 0){_array = nullptr;_top = _capacity = 0;}else{_array = (int*)malloc(sizeof(int) * n);if (!_array){perror("malloc fail\n");exit(-1);}_top = 0;_capacity = n;}}void Push(int x){_array[_top++] = x;}~Stack(){if (_array){free(_array);_array = nullptr;_capacity = _top = 0;}}
private:int* _array;int _top;int _capacity;};
void func2(Stack s2)
{s2.Push(1);
}
int main()
{Stack s1;func2(s1);return 0;
}
运行此代码,最后导致程序崩溃。

什么原因呢?
其实是调用了两次析构函数,_array指向的空间被释放了两次。

s1对象在拷贝给s2对象时,不仅会把_top_capacity拷贝给它,更核心的是,会把_array指向的空间给s2,这样导致s2对象的_array指向的空间与s1对象的_array指向的空间一致,那么在main函数结束前,编译器会先调用s2的析构函数(此时,_array所指向的空间已经被释放了),再去调用s1的析构函数,那么s1再去释放_array就是一个野指针问题了!
在这里插入图片描述

解决方案:

引用传递参数

void func2(Stack& s2)
{s2.Push(1);
}

我们给形参添加上‘&’引用,问题可以得到解决,但是s2.Push不就是给s1对象本身也压入了数据吗?那么如果不想要更改s1的数据呢?让我们看看第二种方案,那就是拷贝构造!接下来,让拷贝构造闪亮登场吧!

拷贝构造函数概念

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

int main()
{Stack s1;Stack s2(s1);//拷贝构造 return 0;
}

拷贝构造函数特征

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

  1. 拷贝构造函数是构造函数的一个重载形式。
  2. 拷贝构造函数的参数只有一个且必须是同类型对象的引用,使用传值方式编译器直接报错,因为会引发无穷递归调用。
class Date
{
public:Date(int year = 1900, int month = 1, int day = 1){_year = year;_month = month;_day = day;}//Date d2(d1)// Date(const Date d) // 错误写法:编译报错,会引发无穷递归Date(const Date& d) // 正确写法{_year = d._year;_month = d._month;_day = d._day;}
private:int _year;int _month;int _day;
};
int main()
{Date d1;Date d2(d1);return 0;
}

这里有一点难得理解,拷贝构造函数参数必须是同类型对象的引用,否则会出现无穷递归的情况,Date d2(d1)需要调用拷贝构造函数,若将d2的地址传递给this指针,d1传递给d,发现是值传递,会去一直调用拷贝构造,会形成死递归的情况,所以我们需要在拷贝构造形参部分,给同类型对象加上引用。
在这里插入图片描述


那么对于前面的程序奔溃的问题,我们就需要用拷贝构造函数来修改它。由原来的浅拷贝改为深拷贝即可,给被拷贝的对象再malloc一个和拷贝对象一样大的空间,利用memcpy()函数将数据也同时拷贝过来。

Stack(const Stack& s)
{//深拷贝_array = (int*)malloc(sizeof(int)*s._capacity);if (!_array){perror("malloc fail\n");exit(-1);}memcpy(_array, s._array, sizeof(int)*s._top);_top = s._top;_capacity = s._capacity;
}

  1. 若未显式定义,编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝,这种拷贝叫做浅拷贝,或者值拷贝。
class Time
{
public:Time(){_hour = 1;_minute = 1;_second = 1;}Time(const Time& t){_hour = t._hour;_minute = t._minute;_second = t._second;cout << "Time::Time(const Time&)" << endl;}
private:int _hour;int _minute;int _second;
};
class Date
{
private:// 基本类型(内置类型)int _year = 1970;int _month = 1;int _day = 1;// 自定义类型Time _t;
};
int main()
{Date d1;// 用已经存在的d1拷贝构造d2,此处会调用Date类的拷贝构造函数// 但Date类并没有显式定义拷贝构造函数,则编译器会给Date类生成一个默认的拷贝构//造函数Date d2(d1);return 0;
}

⚠️注意:在编译器生成的默认拷贝构造函数中,内置类型是按照字节方式直接拷贝的,而自定义类型是调用其拷贝构造函数完成拷贝的。

总结:类中如果没有涉及资源申请时,拷贝构造函数是否写都可以;一旦涉及到资源申请时,则拷贝构造函数是一定要写的,否则就是浅拷贝。(像Date日期这样的类不需要我们实现拷贝构造,自己生成就可以;像Stack栈这样的类需要我们实现拷贝构造,否则就会出问题)。

  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;
}

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

赋值运算符重载

运算符重载

C++为了增强代码的可读性引入了运算符重载,运算符重载是具有特殊函数名的函数,也具有其返回值类型,函数名字以及参数列表,其返回值类型与参数列表与普通的函数类似。
函数名字为:关键字operator后面接需要重载的运算符符号。
函数原型:返回值类型 operator操作符(参数列表)

注意:

  • 不能通过连接其他符号来创建新的操作符:比如operator@
  • 重载操作符必须有一个类类型参数
  • 用于内置类型的运算符,其含义不能改变,例如:内置的整型+,不能改变其含义
  • 作为类成员函数重载时,其形参看起来比操作数数目少1,因为成员函数的第一个参数为隐藏的this
    .*::sizeof?:. 注意这5个运算符不能重载。

👇重载为全局函数:

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

👇重载为类成员函数

// 全局的operator==
class Date
{
public:Date(int year = 2023, int month = 9, int day = 1){_year = year;_month = month;_day = day;}//d1 < d2//d1.operator < (d2)//这里需要注意的是,左操作数是this,指向调用函数的对象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;}}
private:int _year;int _month;int _day;
};

赋值运算符重载

🔗赋值概念:使用已存在对象赋值(复制)给另一个已存在的对象。

  • 赋值运算符重载格式
    • 参数类型:const T&,传递引用可以提高传参效率
    • 返回值类型:T&,返回引用可以提高返回的效率,有返回值目的是为了支持连续赋值
    • 检测是否自己给自己赋值
    • 返回*this :要复合连续赋值的含义
class Date
{
public :
//构造函数
Date(int year = 1900, 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;
}
//赋值重载函数
//参数可以不用添加引用,但是需要调用一次拷贝构造,需要重新开辟一段空间
//传递引用可以提高传参效率
//Date& operator=(const Date d)
Date& operator=(const Date& d)
{if(this != &d){_year = d._year;_month = d._month;_day = d._day;}return *this;
}
private:int _year;int _month;int _day;
  • 赋值运算符只能重载成类的成员函数不能重载成全局函数
class Date
{
public:
Date(int year = 1900, int month = 1, int day = 1)
{_year = year;_month = month;_day = day;}int _year;int _month;int _day;
};
// 赋值运算符重载成全局函数,注意重载成全局函数时没有this指针了,需要给两个参数
Date& operator=(Date& left, const Date& right)
{if (&left != &right){left._year = right._year;left._month = right._month;left._day = right._day;}return left;
}
// 编译失败:
// error C2801: “operator =”必须是非静态成员

💡原因:赋值运算符如果不显式实现,编译器会生成一个默认的。此时用户再在类外自己实现一个全局的赋值运算符重载,就和编译器在类中生成的默认赋值运算符重载冲突了,故赋值运算符重载只能是类的成员函数。

《C++ primer 第5版》500页 `Note`:我们可以重新赋值运算符。不论形参的类型什么,赋值运算符都必须定义为成员函数。
  • 用户没有显式实现时,编译器会生成一个默认赋值运算符重载,以值的方式逐字节拷贝。
    注意:内置类型成员变量是直接赋值的(浅拷贝),而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值(深拷贝)。
class Time
{
public:Time(){_hour = 1;_minute = 1;_second = 1;}
Time& operator=(const Time& t)
{if (this != &t){_hour = t._hour;_minute = t._minute;_second = t._second;}return *this;
}
private:int _hour;int _minute;int _second;
};
class Date
{private:// 基本类型(内置类型)int _year = 1970;int _month = 1;int _day = 1;// 自定义类型Time _t;
};
int main()
{Date d1;Date d2;d1 = d2;return 0;
}

既然编译器生成的默认赋值运算符重载函数已经可以完成字节序的值拷贝了,还需要自己实现吗?当然像日期类这样的类是没必要的。那么对于Stack栈这样的类,用到赋值重载函数,运行和拷贝构造函数一样,会造成程序崩溃。

//这里没写赋值重载函数,编译器就会生成默认的赋值运算符重载函数,只能完成浅拷贝,最后调用析构函数,会释放两次空间,导致程序崩溃!
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;
};

在这里插入图片描述

所以,和拷贝构造函数一样,如果类中未涉及到资源管理,赋值运算符是否实现都可以;一旦涉及到资源管理则必须要实现。

前置++后置++ 重载

我们前面实现的一些操作符重载,一般都是两个参数,但是对于前置++后置++,都是一个参数,那么我们想写一个操作符重载函数,如何去区分前置++后置++呢?

C++规定:前置++和后置++都是一元运算符,为了让前置++与后置++形成能正确重载,后置++重载时多增加了一个int类型的参数,与前置++构成函数重载,以区分前置++,但调用函数时该参数不用传递,编译器自动传递。

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;
};
int main()
{Date d;Date d1(2023, 1, 1);d = d1++; // d: 2023,1,1 d1:2023,1,2d = ++d1; // d: 2023,1,3 d1:2023,1,3return 0;
}

实现日期类

具体实现我已经总结为另一篇博客啦😜,👉【传送门】

const成员

将const修饰的“成员函数”称之为const成员函数const修饰类成员函数,实际修饰该成员函数隐含的this指针,表明在该成员函数中不能对类的任何成员进行修改

⚠️注意:因为this指针是隐含的,所以我们给成员函数加上const,需要在函数的()后添加。
📌如下所示:

//相当于void Print(const Date* this)
void Print() const
{//打印日期……
}

在这里插入图片描述
来看看下面这段代码:

class Date
{
public:
Date(int year, int month, int day)
{_year = year;_month = month;_day = day;
}
//Print与const修饰的Print构成函数重载
void Print()
{cout << "Print()" << endl;cout << "year:" << _year << endl;cout << "month:" << _month << endl;cout << "day:" << _day << endl << endl;
}
void Print() const
{cout << "Print()const" << endl;cout << "year:" << _year << endl;cout << "month:" << _month << endl;cout << "day:" << _day << endl << endl;
}
private:int _year; // 年int _month; // 月int _day; // 日
};
void Test()
{Date d1(2022,1,13);d1.Print(); //权限的缩小const Date d2(2022,1,13);d2.Print();//权限的平移
}

const修饰的对象只能调用const成员函数,非const修饰的对象对于const成员函数和非const成员函数,会去调用最匹配的,即非const成员函数,如果非const成员函数不存在,则调用const成员函数。
⚠️:那么const成员函数的意义何在呢?现在大家观察不出来,我们后面在STL的vector部分会深刻感受到。

这里简单理解一下:
这里有一个operator[]操作符重载函数,可以理解为数组访问操作符_a[0],对于不同的场景,会有读或者写的权限,对于写的场景,比如_a[2] = 10,编译器就会调用非const修饰的成员函数,对于读的场景,我们不希望会被修改,那么编译器就会调用const修饰的成员函数。
在这里插入图片描述
📌那么,对于只读函数我们可以加上const修饰,因为不涉及对类的成员进行修改。但是并不是所有的成员函数我们都添加const。

💡那么,思考一下下面的几个问题:

  1. const对象可以调用非const成员函数吗?
    • 不可以,属于权限的放大
  2. 非const对象可以调用const成员函数吗?
    • 可以,属于权限的缩小
  3. const成员函数内可以调用其它的非const成员函数吗?
    • 不可以,属于权限的放大
  4. 非const成员函数内可以调用其它的const成员函数吗?
    • 可以,属于权限的缩小

取地址及const取地址操作符

这两个默认成员函数一般不用重新定义 ,编译器默认会生成。

class Date
{
public :Date* operator&(){return this ;}const Date* operator&()const{return this ;}
private :int _year ; // 年int _month ; // 月int _day ; // 日
};

这两个运算符一般不需要重载,使用编译器生成的默认取地址的重载即可,只有特殊情况,才需
要重载,比如不想让他人取到有效地址。

Date* operator&()
{return nullptr;
}const Date* operator&() const
{return nullptr;
}

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

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

相关文章

K8S:kubeadm搭建K8S+Harbor 私有仓库

文章目录 一.部署规划1.主机规划2.部署流程 二.kubeadm搭建K8S1.环境准备2.安装docker3. 安装kubeadm&#xff0c;kubelet和kubectl4.部署K8S集群&#xff08;1&#xff09;初始化&#xff08;2&#xff09;部署网络插件flannel&#xff08;3&#xff09;创建 pod 资源 5.部署 …

网络编程套接字,Linux下实现echo服务器和客户端

目录 1、一些网络中的名词 1.1 IP地址 1.2 端口号port 1.3 "端口号" 和 "进程ID" 1.4 初始TCP协议 1.5 UDP协议 2、socket编程接口 2.1 socket 常见API 2.2 sockaddr结构 3、简单的网络程序 3.1 udp实现echo服务器和客户端 3.1.1 echo服务器实…

C++ 数组

C 数组 C 支持数组数据结构&#xff0c;它可以存储一个固定大小的相同类型元素的顺序集合。数组是用来存储一系列数据&#xff0c;但它往往被认为是一系列相同类型的变量。 数组的声明并不是声明一个个单独的变量&#xff0c;比如 number0、number1、...、number99&#xff0…

爬虫逆向实战(30)-某查查股东关联公司(HmacSHA512)

一、数据接口分析 主页地址&#xff1a;某查查 1、抓包 通过抓包可以发现数据接口是api/people/getRelatCompany 2、判断是否有加密参数 请求参数是否加密&#xff1f; 无 请求头是否加密&#xff1f; 通过查看“标头”可以发现&#xff0c;请求头中有一个key和value都是…

记一次生产环境服务卡死排查记录

接现场运维报告某java服务CPU狂飙&#xff0c;服务处于卡死无响应状态 询问现场运维什么场景造成的&#xff0c;答复是偶发现象&#xff0c;没有规律&#xff0c;和请求高峰期并没有关系。 因为服务是负载均衡的&#xff08;A、B两台&#xff09;&#xff0c;临时处理让运维重…

【网络通信 -- WebRTC】FlexFec 基本知识点总结概述

【网络通信 -- WebRTC】FlexFec 基本知识点总结概述 【1】FlexFec 的保护方案 假设存在一组源数据包(D L)&#xff0c;其序列号从 1 开始运行到 D L 一维非交错行 FEC(1-D Non-interleaved Row FEC) : 一种连续的源数据包进行保护的方案&#xff0c;可用于恢复按行分组的源…

LaTeX总结-2023年9月8日

1. LaTeX总结 文章目录 1. LaTeX总结1.1. 定义作者&#xff0c;通讯作者&#xff0c;地址&#xff0c;宏包1.1.1. Example 11.1.2. Example 21.1.3. 特殊符号——作者标注注 1.2. 调整字体1.2.1. 数学模式下使用正体1.2.2. LaTeX内使用中文1.2.3. 正文文字 1.3. 常用符号及字母…

专业游戏翻译公司怎么选择比较合适

近年来&#xff0c;游戏行业持续繁荣&#xff0c;市场需求也在不断扩大&#xff0c;其中游戏翻译的需求越来越旺盛。无论是引进游戏还是让游戏走向国际市场&#xff0c;都需要专业的翻译公司来帮忙。那么&#xff0c;怎么选择合适的游戏翻译公司呢&#xff1f;让我们一起来看看…

大数据技术之Hadoop:HDFS存储原理篇(五)

目录 一、原理介绍 1.1 Block块 1.2 副本机制 二、fsck命令 2.1 设置默认副本数量 2.2 临时设置文件副本大小 2.3 fsck命令检查文件的副本数 2.4 block块大小的配置 三、NameNode元数据 3.1 NameNode作用 3.2 edits文件 3.3 FSImage文件 3.4 元素据合并控制参数 …

论文笔记:一分类及其在大数据中的潜在应用综述

0 概述 论文&#xff1a;A literature review on one‑class classification and its potential applications in big data 发表&#xff1a;Journal of Big Data 在严重不平衡的数据集中&#xff0c;使用传统的二分类或多分类通常会导致对具有大量实例的类的偏见。在这种情况…

小白备战大厂算法笔试(三)——栈、队列、双向队列

文章目录 栈栈常用操作栈的实现基于链表的实现基于数组的实现 两种实现对比栈典型应用 队列队列常用操作队列实现基于链表的实现基于数组的实现 队列典型应用 双向队列双向队列常用操作双向队列实现基于双向链表的实现基于数组的实现 双向队列应用 栈 栈是一种遵循先入后出的逻…

CVE-2017-12149

春秋云镜 CVE-2017-12149 JBoss反序列化漏洞 靶标介绍 2017年8月30日&#xff0c;厂商Redhat发布了一个JBOSSAS 5.x 的反序列化远程代码执行漏洞通告。该漏洞位于JBoss的HttpInvoker组件中的 ReadOnlyAccessFilter 过滤器中&#xff0c;其doFilter方法在没有进行任何安全检查…

算法通关村第十三关——溢出问题处理模板

前言 溢出问题是面试当中输出涉及到数字的一个需要特别注意的地方&#xff0c;典型的题目有三个&#xff1a;数字反转&#xff0c;将字符串转成数字和回文数。 1.整数反转 力扣7题&#xff0c;给你一个 32 位的有符号整数 x &#xff0c;返回将 x 中的数字部分反转后的结果。…

rk3399 linux 5.10 usb 2.0设备上电概率性注册失败

多次开关机&#xff0c;发现usb hub和4G都通信失败了&#xff0c;这就有点奇怪了&#xff0c;按理说usb驱动是没啥问题的 先查看usb log rootlinaro-alip:/# dmesg | grep usb [ 1.723797] usbcore: registered new interface driver usbfs [ 1.723828] usbcore: regis…

在很多公司里面会使用打tag的方式保留版本

&#xff1a;git tag|grep "xxx-dev“等分支来查看 2&#xff1a;git cherry-pick XXXXX 然后就是查看有冲突这些 git status 会出现相关的异常 然后解决相关的冲突 git add . git cherry-pick --continue git push XXX HEAD:refs/for/XXX 第一&#xff1a;git ta…

【LeetCode-中等题】17. 电话号码的字母组合

文章目录 题目方法一&#xff1a;递归回溯 题目 方法一&#xff1a;递归回溯 参考讲解&#xff1a;还得用回溯算法&#xff01;| LeetCode&#xff1a;17.电话号码的字母组合 首先可以画出树图&#xff1a; 先将数字对应的字符集合 加入到一个map集合 这里需要一个index来控…

伪静态web.config常见规则写法与参数介绍说明

伪静态web.config常见规则写法与参数介绍说明. 示例1&#xff1a; <?xml version"1.0" encoding"UTF-8"?> <configuration><system.webServer><rewrite><rules><rule name"规则 1" stopProcessing"tru…

【AI理论学习】语言模型:从Word Embedding到ELMo

语言模型&#xff1a;从Word Embedding到ELMo ELMo原理Bi-LM总结参考资料 本文主要介绍一种建立在LSTM基础上的ELMo预训练模型。2013年的Word2Vec及2014年的GloVe的工作中&#xff0c;每个词对应一个vector&#xff0c;对于多义词无能为力。ELMo的工作对于此&#xff0c;提出了…

Go 接口和多态

在讲解具体的接口之前&#xff0c;先看如下问题。 使用面向对象的方式&#xff0c;设计一个加减的计算器 代码如下&#xff1a; package mainimport "fmt"//父类&#xff0c;这是结构体 type Operate struct {num1 intnum2 int }//加法子类&#xff0c;这是结构体…

MySQL——数据库以及数据表的创建

创建数据库 回到刚才创建数据库的问题&#xff0c;我们在创建数据库的时候可以通过添加一个参数&#xff0c;这个参数的意义在于当我们创建的数据库已经存在的时候则不会创建&#xff0c;也不会报错&#xff0c;如果不使用这个参数&#xff0c;则我们在重复创建一个已经存在的…