cpp_07_类型转换构造_析构函数_深拷贝_静态成员

1  类型转换构造函数

1.1  why?

        基本类型之间的转换，编译器内置转换规则：int -> double

        类类型之间的转换，编译器不知道转换规则，需要用户提供：Cat -> Dog

// consconv_why.cpp 为什么需要自定义转换
#include <iostream>
using namespace std;class Cat {
public:Cat( const char* name ) : m_name(name) {//【string m_name(name);】}void talk( ) {cout << m_name << ": 喵喵~~~" << endl;}
private:string m_name;
};class Dog {
public:Dog( const char* name ) : m_name(name) {//【string m_name(name);】}void talk( ) {cout << m_name << ": 汪汪~~~" << endl;}
private:string m_name;
};
// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
int main( void ) {Cat smallwhite("小白");smallwhite.talk( );Dog bigyellow = smallwhite; // Cat --> Dogreturn 0;
}

1.2  理论

        class   目标类型 {

                   目标类型 ( const  源类型&  src ) { ... }  // 类型转换构造函数

                    };

        用于：

        1）利用一个已定义的对象，来定义另一个不同类型的对象

        2）实现从源类型到目标类型的隐式类型转换 

        通过explicit关键字，可以强制  这种通过类型转换构造函数实现的类型转换  必须通过静态转换显示地进行：

        class  目标类型 {

                explicit  目标类型 ( const  源类型&  src ) { ... };

        };

// consconv.cpp
// 类型转换构造函数 -- 指定 源类型 到 目标类型 的 转换规则
#include <iostream>
using namespace std;class Cat {
public:explicit Cat( const char* name ) : m_name(name) { // 类型转换构造函数//【string m_name(name);】cout << "Cat类的类型转换构造函数被调用" << endl;}void talk( ) {cout << m_name << ": 喵喵~~~" << endl;}
private:string m_name;friend class Dog; // 友元声明
};class Dog {
public:Dog( const char* name ) : m_name(name) { // 类型转换构造函数//【string m_name(name);】}explicit Dog( const Cat& c ) : m_name(c.m_name) { // 类型转换构造函数(Cat-->Dog的转换规则)//【string m_name=c.m_name;】cout << "Dog类的类型转换构造函数被调用" << endl;}void talk( ) {cout << m_name << ": 汪汪~~~" << endl;}
private:string m_name;
};
// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
int main( void ) {
//  Cat smallwhite("小白"); // 定义smallwhite,利用smallwhite.Cat("小白")->类型转换构造函数//  Cat smallwhite = "小白"; // 定义 匿名Cat类对象,利用 匿名Cat类对象.Cat("小白")->隐式转换// Cat smallwhite=匿名Cat类对象-->克隆Cat smallwhite = static_cast<Cat>("小白"); // 定义 匿名Cat类对象,利用 匿名Cat类对象.Cat("小白")->静态转换// Cat smallwhite=匿名Cat类对象-->克隆smallwhite.talk( );//    Dog bigyellow(smallwhite); // 定义bigyellow,利用bigyellow.Dog(smallwhite)->类型转换构造函数//    Dog bigyellow = smallwhite; // 定义 匿名Dog类对象,利用 匿名Dog类对象.Dog(smallwhite)->隐式类型转换// Dog bigyellow = 匿名Dog类对象-->克隆Dog bigyellow = static_cast<Dog>(smallwhite); // 定义 匿名Dog类对象,利用 匿名Dog类对象.Dog(smallwhite)->静态类型转换// Dog bigyellow = 匿名Dog类对象-->克隆bigyellow.talk( );return 0;
}

2  析构函数

2.1  理论

        析构函数的函数名就是在类名前面加“~”，没有返回类型也没有参数，不能重载。

        在销毁对象之前一刻自动被调用，且仅被调用一次 ：

                - 对象离开作用域

                - delete操作符

        作用：销毁  对象的各个成员变量 

        如果一个类没有定义析构函数，那么编译器会为其提供一个默认的析构函数：

                - 对基本类型的成员变量，什么也不做。

                - 对类类型的成员变量，调用相应类型的析构函数。

                - 销毁 对象的各个成员变量 

2.2  析构过程

        

        对象的销毁过程：

        1）调用析构函数

                - 执行自己在析构函数中书写的代码 

                - 利用类成员变量调用相应的析构函数 

                - 释放对象的各成员变量所占内存空间 

        2）释放整个对象所占用的内存空间 

// 析构函数
#include <iostream>
using namespace std;class Human {
public:
//  如果类没有提供任何构造函数,编译器将提供一个无参的构造函数
/*  Human() {【int m_age;】定义m_age,初值为随机数【string m_name;】定义m_name,利用m_name.string()}*/Human( int age=0, const char* name="无名" ) : m_age(age),m_name(name) {//【int m_age=age;】定义m_age,初值为age//【string m_name(name);】定义m_name,利用m_name.string(name)cout << "Human类缺省构造函数被调用" << endl;}
//  如果类没有提供拷贝构造函数,编译器将提供一个默认的拷贝构造函数
/*  Human( const Human& that ) { 【int m_age=that.m_age;】定义m_age,初值为that.m_age【string m_name(that.m_name);】定义m_name,利用m_name.string(that.m_name)-->string类拷贝构造函数}*/Human( const Human& that ) : m_age(that.m_age), m_name(that.m_name) { //【int m_age=that.m_age;】定义m_age,初值为that.m_age//【string m_name(that.m_name);】定义m_name,利用m_name.string(that.m_name)cout << "Human类拷贝构造函数被调用" << endl;}
//  如果类没有提供拷贝赋值函数,编译器将提供一个默认的拷贝赋值函数
/*  Human& operator=( const Human& that ) {this->m_age = that.m_age;this->m_name = that.m_name; // this->m_name.operator=(that.m_name)-->string类的拷贝赋值函数return *this;}*/Human& operator=( const Human& that ) {// 编译器不会再拷贝赋值函数中塞任何操作cout << "Human类的拷贝赋值函数被调用" << endl;this->m_age = that.m_age;this->m_name = that.m_name; // this->m_name.operator=(that.m_name)-->string类的拷贝赋值函数return *this;}
//  如果类没有提供析构函数,编译器将提供一个默认的析构函数
/*  ~Human() {对于基本类型成员变量m_age,什么都不做对于类类型成员变量m_name,利用 m_name.~string()释放 m_age/m_name 本身所占内存空间}*/~Human() {cout << "Human类的析构函数被调用" << endl;// 对于基本类型成员变量m_age,什么都不做// 对于类类型成员变量m_name,利用 m_name.~string()// 释放 m_age/m_name 本身所占内存空间}void getinfo( ) {cout << "姓名: " << m_name << ", 年龄: " << m_age << endl;}
private:int m_age; // 基本类型的成员变量string m_name; // 类类型的成员变量
};// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
int main( void ) {Human h; // 定义h,利用h.Human()-->h维护的内容为(无名,0)h.getinfo( );Human h2(22,"张飞"); // 定义h2,利用h2.Human(22,"张飞")-->h2维护的内容为(张飞,22)h2.getinfo();Human h3(h2); // = h2; // 定义h3,利用h3.Human(h2)-->触发拷贝构造函数h3.getinfo();Human h4; // 定义h4,利用h4.Human()-->h4维护的内容为(无名,0)cout << "h4被赋值前---";h4.getinfo();h4 = h3; // h4.operator=(h3)-->触发拷贝赋值函数cout << "h4被赋值后---";h4.getinfo();cout << "------------main will be over----------------" << endl;return 0;
} //(1) h.~Human() h2.~Human() h3.~Human() h4.~Human() (2)释放h/h2/h3/h4本身所占的内存空间

2.3  has to

        通常情况下，若对象在其声明周期的最终时刻，并不持有任何动态分配的资源，可以不定义析构函数。

        若对象在其声明周期的最终时刻，持有动态资源，则必须定义析构函数，释放对象所持有的动态资源。

// hastodes必须自己写析构函数的情况 -- 对象临死时，持有动态资源
#include <iostream>
using namespace std;class A {
public:A(int i) : m_i(i), m_p(new int), m_f(open("./file", O_CREAT|O_RDWR,0644)) {//【int m_i=i;】定义m_i,初值为i//【int* m_p=new int;】定义m_p,初值为指向一块堆内存(动态资源)//【int m_f=open(...);】定义m_f,初值为文件描述符-->文件表等内核结构(动态资源)}~A() {delete m_p;close( m_f ); // 动态资源需要自己写代码释放// 释放m_i / m_p / m_f 本身所占内存空间}/* 默认析构函数~A() {释放m_i / m_p / m_f 本身所占内存空间}*/
private:int m_i;int* m_p;int m_f;
};
// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
int main( void ) {A a; // 定义a,利用a.A()return 0;
} // a.~A()  释放a本身所占内存空间

        析构函数的功能并不局限在释放资源上，它还可以执行  我们希望在  对象被释放之前  执行的任何操作。 

3  深拷贝

3.1  浅拷贝缺陷

        如果类不提供拷贝构造，编译器将提供默认的拷贝构造。

        无论是  拷贝构造  还是  拷贝赋值，其默认实现，对任何类型的指针成员都是简单地复制地址，而并不复制地址指向的数据，这种情况称为浅拷贝。（左图）

        为了获得完整意义上的对象副本，必须自己定义  拷贝构造  和  拷贝赋值，针对指针型成员变量做深拷贝。（右图）

           

// copybytes_pre.cpp 类中有指针成员，默认拷贝构造 会有浅拷贝缺陷
#include <iostream>
#include <cstring>
using namespace std;
// 模拟C++标准的string类 实现自己的String类
class String {
public:String( const char* psz="" ) : m_psz(new char[strlen(psz)+1]) {//【char* m_psz=new char[strlen(psz)+1];】// 动态资源strcpy( m_psz, psz );}~String( /* String* this */ ) {delete[] this->m_psz;// 释放 m_psz 本身所占内存空间}char* c_str() { return m_psz; }
//  默认的拷贝构造
/*  String( const String& that ) {【char* m_psz = that.m_psz;】只复制了地址，没有复制地址指向的数据-->浅拷贝}*/ 
private:char* m_psz;
};
// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
int main( void ) {String s1("hello");cout << "s1:" << s1.c_str() << ", s1中的m_psz指向的堆内存的地址: " << (void*)s1.c_str() << endl;String s2(s1); // = s1; 定义s2,利用s2.String(s1)-->拷贝构造函数cout << "s2:" << s2.c_str() << ", s2中的m_psz指向的堆内存的地址: " << (void*)s2.c_str() << endl;return 0;
} // s1.~String()  s2.~String()

        相对于拷贝构造，拷贝赋值需要做更多的工作：

                - 避免自赋值

                - 分配新资源

                - 拷贝新内容

                - 释放旧资源

                - 返回自引用

// copybytes.cpp 类中有指针成员，默认拷贝构造 会有浅拷贝缺陷
#include <iostream>
#include <cstring>
using namespace std;
// 模拟C++标准的string类 实现自己的String类
class String {
public:String( const char* psz="" ) : m_psz(new char[strlen(psz)+1]) {//【char* m_psz=new char[strlen(psz)+1];】// 动态资源strcpy( m_psz, psz );}~String( /* String* this */ ) {delete[] this->m_psz;// 释放 m_psz 本身所占内存空间}char* c_str() { return m_psz; }
//  默认的拷贝构造
/*  String( const String& that ) {【char* m_psz = that.m_psz;】只复制了地址，没有复制地址指向的数据-->浅拷贝}*/// 深拷贝构造函数String( const String& that ) : m_psz(new char[strlen(that.m_psz)+1]) {//【char* m_psz = new char[strlen(that.m_psz)+1];】strcpy( m_psz, that.m_psz ); // 不复制地址，复制地址指向的数据-->深拷贝}/* 默认拷贝赋值函数String& operator=( const String& that ) {this->m_psz = that.m_psz; // 只复制了地址，没有复制地址指向的数据-->浅拷贝return *this;}*/// 深拷贝赋值函数String& operator=( const String& that ) {if( this != &that ) { // 防止自赋值delete[] this->m_psz; // 释放旧资源this->m_psz = new char[strlen(that.m_psz)+1]; // 分配新资源strcpy( this->m_psz, that.m_psz ); // 拷贝新内容}return *this; // 返回自引用}
private:char* m_psz;
};
// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
int main( void ) {String s1("hello");cout << "s1:" << s1.c_str() << ", s1中的m_psz指向的堆内存的地址: " << (void*)s1.c_str() << endl;String s2(s1); // = s1; 定义s2,利用s2.String(s1)-->拷贝构造函数cout << "s2:" << s2.c_str() << ", s2中的m_psz指向的堆内存的地址: " << (void*)s2.c_str() << endl;String s3; // 定义s3，利用s3.String()-->s3维护一个字节堆内存('\0')s3 = s2; // s3.operator=(s2)cout << "s3:" << s3.c_str() << ", s3中的m_psz指向的堆内存的地址: " << (void*)s3.c_str() << endl;return 0;
} // s1.~String()  s2.~String()

3.2  建议

        1）只有类中有指针型成员变量，才会涉及深浅拷贝的问题，因此应尽量避免使用指针型成员变量。

        2）如果确实无法实现完整意义上的  深拷贝拷贝构造  和  深拷贝拷贝赋值，可将它们私有化，禁止用户使用。

4  静态成员

4.1  静态成员变量

        静态成员变量  不属于对象  而  属于类：

                - 静态成员变量不包含在对象中，进程级生命期

                - 静态成员变量的定义和初始化，只能在  类的外部  而不能在构造函数中进行。

                - 静态成员变量依然受  类作用域  和  访问控制限定符  的约束。

                - 访问静态成员变量，既可以通过  类  也可以通过  对象。

                - 静态成员变量为该类的所有对象实例所共享。

// static.cpp 类的静态成员变量
#include <iostream>
using namespace std;// 普通成员变量:属于对象,对象的生命期      静态成员变量:不属于对象,进程级生命期
class A {
public:A() {//【int m_i;】}int m_i; // 声明static int m_si; // 声明
};
int A::m_si = 0; // 全局域中定义-->进程级生命期
// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
int main( void ) {A a, b; // 静态成员变量没有保存在对象内部-->不属于对象cout << "a对象的大小:" << sizeof(a) << endl; // 4cout << "b对象的大小:" << sizeof(b) << endl; // 4A::m_si = 888; // 静态成员受到类作用域的约束 也受到访问控制限定符的约束-->属于类a.m_si = 999; // A::m_si=999;cout << "b.m_si=" << b.m_si << endl; // A::m_si// 类的静态成员变量，被该类的所有对象共享return 0;
}

4.2  静态成员函数

        静态成员函数  不属于对象  而  属于类：

                - 静态成员函数没有this指针，也没有常属性  

                - 静态成员函数依然受  类作用域  和  访问控制限定符的约束

                - 访问静态成员函数，既可以通过  类  也可以通过  对象。

                -静态成员函数只能访问静态成员，而非静态成员函数可以访问所有成员。

// static.cpp 类的 静态成员变量 和 静态成员函数
#include <iostream>
using namespace std;// 普通成员函数：必须利用对象来调用      静态成员函数：不是必须利用对象来调用
class A {
public:int m_i; // 普通成员变量void foo( /* const A* this */ ) const { // 普通成员函数cout << "foo is invoked" << endl;cout << m_i << endl; // okcout << m_si << endl;// okbar();               // ok
//      以上三行代码证明 非静态成员函数 即可访问非静态成员 也可访问 静态成员(不挑食)}static int m_si; //静态成员变量static void bar( /*无this指针*/ ) /*const*/ { // 静态成员函数cout << "bar is invoked" << endl;cout << m_si << endl; // ok
//      cout << m_i << endl;  // error
//      foo();                // error
//      以上三行代码证明 静态成员函数 只能访问 静态成员，不能访问非静态的普通成员(挑食)}
};
int A::m_si = 0; // 全局域中定义-->进程级生命期
// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
int main( void ) {A a, b;a.foo(); // foo(&a);b.foo(); // foo(&b);A::bar(); // 受到类作用域的约束 也受到访问控制限定符的约束-->属于类a.bar(); // A::bar();b.bar(); // A::bar();return 0;
}

4.3  总结

                                                

        事实上，类的静态成员变量和静态成员函数，更像是普通的全局变量和全局函数，

        只是多了一层类作用域和访问控制限定符的约束，

        相当于  具有成员访问属性的全局变量和全局函数。

5  类  扩充

        空类对象的大小是1个字节。

        类中不能包含  本类对象  作为  普通成员变量；

        类中可以包含  本类对象  作为  静态成员变量。

// class_add
#include <iostream>
using namespace std;
/*
class A { // 空类
};
int main( void ) {A a; // 空类对象占1个字节内存(1个字节的垃圾数据)A& ra = a;cout << "空类对象a的大小: " << sizeof(a) << endl;return 0;
}
*/class A {
public:int m_i;
//  A m_a; // errorstatic A m_sa; // ok
};
int main( void ) {A a; // 定义a(给a分配内存空间)cout << "对象a的大小: " << sizeof(a) << endl;return 0;
}

6  单例模式

        要求：设计一个类，要求用户在使用这个类时仅有一个实例（只能出现一个对象）:

        class  Singleton {

                // 设计这个类

        };

        int  main(void) {

                // 用户这里只能出现一个Singleton类对象，不能出现第二个

                return  0;

        }

        

        实现方法：

        1）将  包括类的拷贝构造函数在内的所有构造函数 私有化，防止user在类的外部创建对象。

        2）唯一的对象由类的设计者来创建

        3）提供公有静态成员函数getInstance()使用户可以获取到唯一对象。

        单例分类：

        1）饿汉式：无论用不用，程序启动即创建  hungry.cpp

        2）懒汉式：用的时候创建，不用了即销毁  lazy.cpp

// hungry_singleton.cpp
// 单例模式--要求设计一个类型，用户在使用这个类时只能出现一个对象
#include <iostream>
using namespace std;
// 恶汉式单例
class Singleton {
public://4        //5static Singleton& getInstance( ) {return s_instance;}
private:Singleton( ) {} // 1Singleton( const Singleton& that ) {} // 6static Singleton s_instance; // 2 唯一对象
};Singleton Singleton::s_instance; // 3// 以上代码模拟类的设计者
// -----------------------
// 以下代码模拟类的使用者
int main( void ) {Singleton& s1 = Singleton::getInstance( );Singleton& s2 = Singleton::getInstance( );Singleton& s3 = Singleton::getInstance( );cout << "&s1: " << &s1 << ", &s2: " << &s2 << ", &s3: " << &s3 << endl;return 0;
}

// lazy_singleton.cpp
// 单例模式:设计一个类，保证用户在使用这个类时，只能出现一个对象
#include <iostream>
using namespace std;
// 懒汉式单例:单例高级实现手法
class Singleton {
public:static Singleton& getInstance( ) {if( s_instance==NULL ) {s_instance = new Singleton; // 唯一的对象cout << "创建了唯一的对象" << endl;}++s_counter;return *s_instance;}void releaseInstance( ) {if( --s_counter == 0 ) {delete s_instance;s_instance = NULL;cout << "销毁了唯一的对象" << endl;}}
private:Singleton() {} Singleton( const Singleton& that ) {} static Singleton* s_instance; // 并不是唯一对象,仅仅是一个指针而已static int s_counter; // 计数功能
};Singleton* Singleton::s_instance = NULL; // 程序刚刚时，唯一的对象不存在 
int Singleton::s_counter = 0;// 以上的代码模拟类的设计者(例如:类库、被人设计的类、自己的设计的类)
// -------------------------------------
// 以下的代码模拟用户(使用类的人)
int main( void ) {Singleton& s1 = Singleton::getInstance(); // 第一次调用getInstance函数时,创建唯一的对象Singleton& s2 = Singleton::getInstance(); // 以后再调用getInstance函数时,返回第一次调用时创建的对象Singleton& s3 = Singleton::getInstance(); // ...cout << "&s1: " << &s1 << ", &s2: " << &s2 << ", &s3: " << &s3 << endl;s1.releaseInstance( ); //s2.releaseInstance( ); // s3.releaseInstance( ); // 最后一次调用releaseInstance才将对象销毁return 0;
}

​​​​​​​

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

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

相关文章

记一次修复外网无法访问vmware里面的虚拟机的网络端口的问题

记一次修复外网无法访问vmware里面的虚拟机的网络端口的问题

发现一个奇怪的网络问题&#xff0c;vmware里一个程序的端口通过vmnat穿透出来&#xff0c;然后这个端口就能够通过局域网被其他机器访问&#xff0c;但是另一个网段就没法访问这个端口。使用主机上的其他程序使用开启同样的端口&#xff0c;另一个网段的机器却可以访问。我想不…
阅读更多...
HarmonyOS栅格布局---GridRow

HarmonyOS栅格布局---GridRow

题外话&#xff1a;栅格布局最初是在web 端应用的&#xff0c;为了解决一个系统在不同的屏幕&#xff0c;和不同的设备上可以不进行多次开发的问题&#xff0c;希望一次开发可以最大化的适配用户的不同类型设备&#xff0c;解决方案&#xff1a;将屏幕采用断点的方式进行布局分…
阅读更多...
创新驱动数字经济发展，融云获评「2023 数字经济隐形独角兽」

创新驱动数字经济发展，融云获评「2023 数字经济隐形独角兽」

近期&#xff0c;由北京市大兴区经济和信息化局、北京大兴经济开发区管理委员会、北京隐形独角兽信息科技院联合主办的“2023 数字经济独角兽大会”在北京成功举行。关注【融云 RongCloud】&#xff0c;了解协同办公平台更多干货。 作为专注耕耘通信赛道、掌握关键核心技术、具…
阅读更多...
LDO线性稳压器与开关电源的原理

LDO线性稳压器与开关电源的原理

线性稳压器LDO典型代表&#xff1a;LM7805 ,AMS1117&#xff0c;还有一下性能比较好的LDO&#xff1a; 开关稳压器典型代表&#xff1a;LM2596&#xff0c;MP1584,TPS5430&#xff0c;MP2315S LDO靠发热分散能量&#xff0c;纹波较小一般在30mv以下&#xff1b;DCDC通过开关开断…
阅读更多...
最新国内使用GPT4教程，GPT语音对话使用，Midjourney绘画，ChatFile文档对话总结+DALL-E3文生图

最新国内使用GPT4教程，GPT语音对话使用，Midjourney绘画，ChatFile文档对话总结+DALL-E3文生图

一、前言 ChatGPT3.5、GPT4.0、GPT语音对话、Midjourney绘画&#xff0c;文档对话总结DALL-E3文生图&#xff0c;相信对大家应该不感到陌生吧&#xff1f;简单来说&#xff0c;GPT-4技术比之前的GPT-3.5相对来说更加智能&#xff0c;会根据用户的要求生成多种内容甚至也可以和…
阅读更多...
Ubuntu安装K8S的dashboard（管理页面）

Ubuntu安装K8S的dashboard（管理页面）

原文网址&#xff1a;Ubuntu安装k8s的dashboard&#xff08;管理页面&#xff09;-CSDN博客 简介 本文介绍Ubuntu安装k8s的dashboard&#xff08;管理页面&#xff09;的方法。 Dashboard的作用有&#xff1a;便捷操作、监控、分析、概览。 相关网址 官网地址&#xff1a;…
阅读更多...
电路设计（8）——计时器的multism仿真

电路设计（8）——计时器的multism仿真

1.功能设计 这是一个计时电路&#xff0c;在秒脉冲的驱动下&#xff0c;计时器开始累加&#xff0c;6个数码管分别显示计时的 时&#xff1a;分&#xff1a;秒。 仿真图如下所示&#xff1a; 左边的运放构成了振荡电路&#xff0c;可以产生脉冲波。这个脉冲波给计时电路提供基准…
阅读更多...
0.1+0.2≠0.3，揭秘Python自带的Bug

0.1+0.2≠0.3，揭秘Python自带的Bug

朋友们&#xff0c;问一个简单的问题&#xff1a;0.10.2&#xff1f; 你肯定会说&#xff1a;中国人不骗中国人&#xff0c;0.10.20.3。 但是在Python里&#xff0c;0.10.2≠0.3 &#xff0c;我们今天一起来看看这个&#xff0c;并且看一下解决办法。 离奇的错误 在python里…
阅读更多...
【日志系列】什么是分布式日志系统？

【日志系列】什么是分布式日志系统？

✔️什么是分布式日志系统&#xff1f; 现在&#xff0c;很多应用都是集群部署的&#xff0c;一次请求会因为负载均衡而被路由到不同的服务器上面&#xff0c;这就导致一个应用的日志会分散在不同的服务器上面。 当我们要向通过日志做数据分析&#xff0c;问题排查的时候&#…
阅读更多...
60辆苏州金龙氢能物流车打造长三角绿色运营新范本

60辆苏州金龙氢能物流车打造长三角绿色运营新范本

近日&#xff0c;在广泰氢能杭州湾运营中心&#xff0c;一辆辆苏州金龙18吨氢能物流车来回穿梭&#xff0c;它们从运营中心出发&#xff0c;将不同类型的汽车零配件从物流园区运往整车制造厂。司机李师傅表示&#xff0c;这条路线他跑了几个月&#xff0c;每天四趟。和他一样&a…
阅读更多...
GPT分区格式

GPT分区格式

GPT分区格式 [rootlocalhost ~]# gdisk /dev/sdb -bash: gdisk: 未找到命令 [rootlocalhost ~]# yum -y install gdisk- gdisk命令用于查看磁盘使用情况和磁盘分区&#xff08;GPT分区格式&#xff09; - 命令格式&#xff1a;gdisk [选项...] [设备路径] - 常用选项&…
阅读更多...
Flink项目实战篇 基于Flink的城市交通监控平台（下）

Flink项目实战篇 基于Flink的城市交通监控平台（下）

系列文章目录 Flink项目实战篇 基于Flink的城市交通监控平台&#xff08;上&#xff09; Flink项目实战篇 基于Flink的城市交通监控平台&#xff08;下&#xff09; 文章目录 系列文章目录4. 智能实时报警4.1 实时套牌分析4.2 实时危险驾驶分析4.3 出警分析4.4 违法车辆轨迹跟…
阅读更多...
redis中根据通配符删除key

redis中根据通配符删除key

redis中根据通配符删除key 我们是不是在redis中keys user:*可以获取所有key&#xff0c;但是 del user:*却不行这里我提供的命令主要是SCANSCAN 0 MATCH user:* COUNT 100使用lua保证原子性 SCAN参数描述 在示例中&#xff0c;COUNT 被设置为 100。这是一个防止一次性获取大…
阅读更多...
TiDB 7.1 多租户在中泰证券中的应用

TiDB 7.1 多租户在中泰证券中的应用

本文详细介绍了中泰证券在系统国产化改造项目中采用 TiDB 多租户技术的实施过程。文章分析了中泰证券数据库系统现状以及引入 TiDB 资源管控技术的必要性&#xff0c;探讨了 TiDB 多租户的关键特性&#xff0c;并阐述了在实际应用中的具体操作步骤。通过该技术的应用&#xff0…
阅读更多...
JMeter逻辑控制器之ForEach控制器

JMeter逻辑控制器之ForEach控制器

1. 背景 前段时间在对某项目进行测试&#xff0c;存在一个需要遍历所有组织机构后给每个组织下新增部门的场景&#xff0c;其实也可以通过在数据库中直接添加数据这种方式来实现&#xff0c;但是有点风险&#xff0c;可能会生成脏数据&#xff0c;后期也不好排查&#xff0c;最…
阅读更多...
linux系统 CentOS Tomcat 部署论坛

linux系统 CentOS Tomcat 部署论坛

jdk安装命令&#xff1a;yum -y install java-1.8.0-openjdk-devel.x86_64 结尾上显示下图为成功 检查jdk环境是否配置成功命令&#xff1a;java -version或javac 显示版本 显示信息 mysql安装&#xff1a; 检查是否存mariadb数据库&#xff1a;rpm -qa | grep mariad 卸载ma…
阅读更多...
企业计算机服务器中了360后缀勒索病毒如何处理，勒索病毒应对步骤

企业计算机服务器中了360后缀勒索病毒如何处理，勒索病毒应对步骤

网络技术的应用与发展&#xff0c;为企业的生产运营提供了有力保障&#xff0c;但也为网络安全威胁埋下隐患。近期&#xff0c;网络上的勒索病毒非常嚣张&#xff0c;严重影响了企业的生产运营。近日&#xff0c;云天数据恢复中心接到很多企业的求助&#xff0c;企业的计算机服…
阅读更多...
嵌入式单片机的存储区域与堆和栈

嵌入式单片机的存储区域与堆和栈

一、单片机存储区域 如图所示位STM32F103ZET6的参数&#xff1a; 单片机的ROM&#xff08;内部FLASH&#xff09;&#xff1a;512KB&#xff0c;用来存放程序代码的空间。 单片机的RAM&#xff1a;64KB&#xff0c;一般都被分配为堆、栈、变量等的空间。 二、堆和栈的概念 …
阅读更多...
HBase 例行灾备方案：快照备份与还原演练

HBase 例行灾备方案：快照备份与还原演练

博主历时三年精心创作的《大数据平台架构与原型实现&#xff1a;数据中台建设实战》一书现已由知名IT图书品牌电子工业出版社博文视点出版发行&#xff0c;点击《重磅推荐&#xff1a;建大数据平台太难了&#xff01;给我发个工程原型吧&#xff01;》了解图书详情&#xff0c;…
阅读更多...
秋招复习篇之代码规范

秋招复习篇之代码规范

目录 前言 1、变量命名 2、代码空格 1&#xff09;操作符左右一定有空格&#xff0c; 2&#xff09;分隔符&#xff08;, 和;&#xff09;前一位没有空格&#xff0c;后一位保持空格&#xff0c;例如&#xff1a; 3&#xff09;大括号和函数保持同一行&#xff0c;并有一个空格…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023