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 --> Dog

    return 0;
}

1.2  理论

        定义：1）单参构造                            (同于拷贝构造函数)   

                   2）参数类型与类类型不同      (异于拷贝构造函数)

        (单参构造就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  理论

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

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

                - 对象离开作用域   （栈对象离开main函数）

                - 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本身所占的内存空间
  //(1) 删馅                                           (2)删皮

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; // 4
    cout << "b对象的大小:" << sizeof(b) << endl; // 4

    A::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; // ok
        cout << m_si << endl;// ok
        bar();               // 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; // error
    static 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        //5
    static Singleton& getInstance( ) {
        return s_instance;
    }
private:
    Singleton( ) {} // 1
    Singleton( const Singleton& that ) {} // 6
    static 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;
}

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

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

相关文章

ARM CCA机密计算软件架构之RMI领域管理接口与RSI领域服务接口

ARM CCA机密计算软件架构之RMI领域管理接口与RSI领域服务接口

领域管理接口 领域管理接口&#xff08;RMI&#xff09;是RMM与正常世界主机之间的接口。 RMI允许正常世界虚拟机监视器向RMM发出指令&#xff0c;以管理领域。 RMI使用来自主机虚拟机监视器的SMC调用&#xff0c;请求RMM的管理控制。 RMI使得对领域管理的控制成为可能&…
阅读更多...
STM32 基础知识（探索者开发板）--93讲 PWM

STM32 基础知识（探索者开发板）--93讲 PWM

预分频器相当于一个计数器&#xff0c;2分频就是接收2个脉冲传递一个脉冲&#xff0c;3分频就是接收3个脉冲传递一个脉冲&#xff0c;最高65535分频&#xff0c;那么总计时间能达到65535*65535*1/72MHZ 约59秒&#xff0c;没有分频器只能计数最高0.09秒 PWM配置步骤 1.配置定时…
阅读更多...
Vue : Object.defineProperty()

Vue : Object.defineProperty()

给对象添加属性: <script>let person {name : 张三,sex : 男}Object.defineProperty(person,age,{value : 18})console.log(person)</script> 控制台查看: 但是添加的属性是不能被遍历的: 但是如果你想又使用defineProperty添加属性, 又想遍历, 那么就在这个def…
阅读更多...
阿里云oss拷贝（包含移动的代码）文件并返回下载地址

阿里云oss拷贝（包含移动的代码）文件并返回下载地址

oss拷贝文件官方地址&#xff1a; https://help.aliyun.com/zh/oss/developer-reference/java-copy-objects?spma2c4g.11186623.0.0.16f76083xr3lKM 步骤1&#xff1a;oss的Maven依赖 <!-- OSS --><dependency><groupId>com.aliyun.oss</groupId>&l…
阅读更多...
GIT如何重新生成ssh密钥过程

GIT如何重新生成ssh密钥过程

GIT如何重新生成ssh密钥过程 一、生成密钥前需要把之前的密钥删除吆 第一步&#xff1a;重新配置用户名和邮箱&#xff08; Git Bash 或命令窗口&#xff09; 1、配置用户命令&#xff1a;git config --global user.name “xxxxx” 2、配置邮箱命令&#xff1a;git config …
阅读更多...
laravel5.8中实现验证码组件的安装和验证

laravel5.8中实现验证码组件的安装和验证

本篇文章主要讲解使用laravel5.8自带的验证码库实现验证码验证的效果教程。通过本教程你可以快速接入到自己的项目中开发相应的验证功能。 作者&#xff1a;任聪聪 (rccblogs.com) 日期&#xff1a;2023年12月17日 实际效果 安装步骤 步骤一、输入命令 composer require mews…
阅读更多...
来看看这个技术，这才是UPS监控的最好方式！

来看看这个技术，这才是UPS监控的最好方式！

在现代社会中&#xff0c;信息技术的持续发展使得机房UPS监控变得至关重要。机房是企业信息系统的核心&#xff0c;UPS监控系统能够确保在电力故障或其他问题发生时&#xff0c;机房设备能够持续稳定运行&#xff0c;从而保障数据的安全性和可用性。 客户案例 金融机构 河北某…
阅读更多...
物流标签，2028 年将以5.2%左右的复合年增长率增长

物流标签，2028 年将以5.2%左右的复合年增长率增长

近年来&#xff0c;在供应链中对产品和货物的跟踪和识别需求不断增长的推动下&#xff0c;物流标签市场出现了显着增长。预计该市场将继续以稳定的速度增长&#xff0c;无论是在全球还是在中国市场。 全球市场分析&#xff1a;全球物流标签市场预计从 2021 年到 2028 年将以 5.…
阅读更多...
Mac系统如何安装rosetta？

Mac系统如何安装rosetta？

目录​​​​​​​ 什么是rosetta&#xff1f; 如何安装rosetta&#xff1f; 如何用rosetta打开指定应用&#xff1f; 什么是rosetta&#xff1f; Rosetta是苹果公司开发的一个程序&#xff0c;用于让建立在特定处理器架构之上的旧版软件在新的处理器架构上运行。这个功能…
阅读更多...
搜维尔科技：经脉腧穴虚拟针灸VR虚拟教学平台AcuMap软件案例分享

搜维尔科技：经脉腧穴虚拟针灸VR虚拟教学平台AcuMap软件案例分享

北京中医药大学经脉腧穴VR虚拟教学平台案例 主要产品 HTCvive &#xff0c;AcuMap&#xff1b; 实施内容 一、项目说明 &#xff08;1&#xff09;穴位取穴与体表解剖标志关系&#xff1b;&#xff08;2&#xff09;穴下层次解剖及周围解剖结构展示&#xff1b; &#xf…
阅读更多...
FileZilla的使用以及FileZilla的主动模式和被动模式（详细案例分析附思维导图）

FileZilla的使用以及FileZilla的主动模式和被动模式（详细案例分析附思维导图）

目录 前言 一.FileZilla的简介 1.1 主要功能 二.FileZilla的使用&#xff08;案例&#xff09; 2.1 虚拟机里面安装 2.2 案例 三.FileZilla的主动模式和被动模式 3.1 主动模式&#xff08;Active Mode&#xff09; 3.2 被动模式&#xff08;Passive Mode&#xff09; …
阅读更多...
postman入门使用

postman入门使用

前言 对于postman的基础其实很容易上手实现&#xff0c;也有很多教程。 对于小编我来说&#xff0c;也基本可以实现开发任务。 但是今年我们的高级测试&#xff0c;搞了一下postman&#xff0c;省去很多工作&#xff0c;让我感觉很有必要学一下 这篇文章是在 高级测试工程师ht…
阅读更多...
数据结构第0章 初识

数据结构第0章 初识

名人说&#xff1a;莫听穿林打叶声&#xff0c;何妨吟啸且徐行。—— 苏轼《定风波莫听穿林打叶声》 本篇笔记整理&#xff1a;Code_流苏(CSDN)&#xff08;一个喜欢古诗词和编程的Coder&#x1f60a;&#xff09; 目录 0、思维导图1、数据结构1&#xff09;数据结构是什么&am…
阅读更多...
九州金榜｜家庭教育高中孩子沟通小技巧，拉进亲子关系更融洽

九州金榜｜家庭教育高中孩子沟通小技巧，拉进亲子关系更融洽

高中是孩子由少年期逐步走向青少年也就是我们说的青春期。这个阶段孩子也是孩子压力最大的时候&#xff0c;不止是心理、生理方面&#xff0c;更是来自于学习压力&#xff0c;高中是孩子人生关键的三年&#xff0c;这三年决定孩子未来的出路。 高中是学业最为繁忙的阶段&#…
阅读更多...
FinalShell连接虚拟机遇到的问题

FinalShell连接虚拟机遇到的问题

在下载好VM后也安装好了虚拟机&#xff08;我这里使用Centos7.5&#xff09;&#xff0c;但是当使用FinalShell连接虚拟机的时候&#xff0c;一直提示连接超时。。。。 后来找了半天&#xff0c;发现是有次校园网和VM虚拟机冲突&#xff0c;就把虚拟机的网络连接给关了&#x…
阅读更多...
Ubuntu安装和配置Nextcloud并结合内网穿透实现远程访问

Ubuntu安装和配置Nextcloud并结合内网穿透实现远程访问

文章目录 摘要1. 环境搭建2. 测试局域网访问3. 内网穿透3.1 ubuntu本地安装cpolar3.2 创建隧道3.3 测试公网访问 4 配置固定http公网地址4.1 保留一个二级子域名4.1 配置固定二级子域名4.3 测试访问公网固定二级子域名 摘要 Nextcloud,它是ownCloud的一个分支,是一个文件共享服…
阅读更多...
深入浅出图解C#堆与栈 C# Heap(ing) VS Stack(ing) 第五节 引用类型复制问题及用克隆接口ICloneable修复

深入浅出图解C#堆与栈 C# Heap(ing) VS Stack(ing) 第五节 引用类型复制问题及用克隆接口ICloneable修复

深入浅出图解C#堆与栈 C# Heaping VS Stacking 第五节 引用类型复制问题及用克隆接口ICloneable修复 [深入浅出图解C#堆与栈 C# Heap(ing) VS Stack(ing) 第一节 理解堆与栈](https://mp.csdn.net/mdeditor/101021023)[深入浅出图解C#堆与栈 C# Heap(ing) VS Stack(ing) 第二节…
阅读更多...
JavaGUI+Mysql工资管理系统

JavaGUI+Mysql工资管理系统

环境说明&#xff1a; JDK1.8 Mysql5.7 开发工具Eclipse或IDEA 代码获取联系方式&#xff1a; QQ:850698824 主要代码 /** To change this template, choose Tools | Templates* and open the template in the editor.*//** MainFrame.java** Created on 2013-6-…
阅读更多...
Python之JSON函数介绍

Python之JSON函数介绍

JSON函数 使用 JSON 函数需要导入 json 库&#xff1a;import json。 举例说明&#xff0c;如下&#xff1a; a.json内容格式&#xff1a; {"car":{"price":1100,"color":"red"},"mac":{"price":7999,"col…
阅读更多...
自定义docker镜像，ubuntu安装命令并导出

自定义docker镜像，ubuntu安装命令并导出

文章目录 问题现象解决步骤相关命令详细介绍docker save 与 docker loaddocker import 与 docker exportdocker commit 问题现象 我们的通讯服务&#xff0c;需要监测前端设备的在线情况&#xff08;是否在线、丢包率、延迟等&#xff09;&#xff0c;使用ping命令去实现此功能…
阅读更多...
最新文章

Copyright @ 2022~2023