C++类的引入

news2025/1/12 3:30:26

C++中类的前身

1> 面向对象三大特征：封装、继承、多态

2> 封装：将能够实现某一事物的所有万事万物都封装到一起，包括成员属性（成员变量），行为（功能函数）都封装在一起，我们称之为类。并向外部提供公共的接口，用户可以通过该接口来控制该类实例化的对象。

3> 只需将C++中的结构体的struct改成class就是类的定义

4> 类的定义格式

class 类名 { 访问权限： 成员； };

类的说明

1> 类中的访问权限有三种：public、protected、private

public:该权限下的成员，可以在类内、子类中以及类外被访问

protected：该权限下的成员，可以在类内、子类中被访问，类外不能被访问

private：该权限下的成员只能被类内访问，类外、子类中都不能被访问

在类中，默认的访问权限是private

2> 类中可以有成员属性和成员函数，一般成员属性设置成私有、成员变量设置成公共的

3> 类中的成员函数可以访问类中所有权限下的成员，包括私有成员

4> 每种访问权限，可以在类中出现多次，每个访问权限从关键字开始，到下一个关键字为止或者整个类体结束。

5> 一般将同一权限下的所有成员放在一起

6> 如果非要在类外对私有成员或受保护的成员进行读取或者写入，需要在类内提供相关公共的接口来完成

7> 类的访问权限是针对于类体而言，而不是针对于类对象而言

#include <iostream>

using namespace std;

//定义一个 Person 类
class Person
{
public:
    string name = "张三";
    char sex;             //性别

private:
    int age = 18;

protected:
    int money;

public:

    //定义展示函数
    void show()
    {
        cout<<"name = "<<name<<endl;          //公共权限下的成员，类内可以被访问
        cout<<"sex = "<<sex<<endl;            //公共权限下的成员，类内可以被访问
        cout<<"age = "<<age<<endl;            //私有权限下的成员，类内可以被访问
        cout<<"money = "<<money<<endl;        //受保护权限下的成员，类内可以被访问
    }

    //定义设置年龄函数
    void set_age(int a)
    {
        if(a<0)
        {
            cout<<"设置失败"<<endl;
            return;
        }

        age = a;
    }

    //定义获取年龄的函数
    int get_age()
    {
        return age;
    }

};





int main()
{
    //class Person p1;       //使用类定义一个变量
    Person p1;              //使用类，定义一个变量   ---> 使用Person类实例化一个对象
    p1.name = "二狗";           //类中公共权限下的成员，类外可以被访问
    p1.sex = 'M';               //类中公共权限下的成员，类外可以被访问
    //p1.age = 18;               //类中私有权限下的成员，类外无法被访问
    //p1.money = 1000000;          //类中受保护的成员，类外无法被访问

    p1.show();                //类中公共权限下的成员，类外可以被访问

    //设置年龄
    p1.set_age(118);
    cout<<"p1.age = "<<p1.get_age()<<endl;

    return 0;
}

练习：定义一个矩形（Rectangle）类，拥有私有成员属性：宽度(width)、高度(hight)

公共成员函数：

初始化函数：void init(int w, int h)

获取宽度函数：get_w();

设置宽度函数：set_w(int w);

获取高度函数：get_h();

设置高度函数：set_h(int h);

获取周长函数：get_perimeter();

获取面积函数：get_area();

在主程序中实例化对象，并测试下相关函数

#include <iostream>

using namespace std;


class Rectangle            //定义一个矩形类
{
    //私有成员属性
private:
    int width;       //矩形的宽度
    int hight;        //矩形的高度
public:
    //初始化函数
    void init(int w,int h)
    {
        if(w<=0 || h<=0)
        {
            cout<<"初始化失败"<<endl;
            return;
        }
        width=w;
        hight=h;
    }

    //设置宽度函数
    void set_w(int w)
    {
        width=w;
    }
    //设置高度函数
    void set_h(int h)
    {
        hight=h;
    }
    //获取宽度
    int get_w()
    {
        return width;
    }
    //获取周长
    int get_peri()
    {
        return 2*width+2*hight;
    }
    //获取面积
    int get_area()
    {
        return width*hight;
    }
};

int main()
{
    Rectangle r1;       //实例化一个矩形对象
    r1.init(3,5);         //初始化矩形
    cout<<"矩形的周长为："<<r1.get_peri()<<endl;
    cout<<"矩形的面积为："<<r1.get_area()<<endl;

    //重新设置矩形的宽度
    r1.set_w(10);
    cout<<"矩形的周长为："<<r1.get_peri()<<endl;
    cout<<"矩形的面积为："<<r1.get_area()<<endl;


    return 0;
}

练习：在上面的案例上面加一个功能：比较两个矩形框是否相等 bool judge()

判断两个矩形相等的原则：width==width && heigh==heigh

全局函数版本： bool judge(Rectangle r1, Rectangle r2);

#include <iostream>

using namespace std;


class Rectangle            //定义一个矩形类
{
    //私有成员属性
private:
    int width;       //矩形的宽度
    int hight;        //矩形的高度
public:
    //初始化函数
    void init(int w,int h)
    {
        if(w<=0 || h<=0)
        {
            cout<<"初始化失败"<<endl;
            return;
        }
        width=w;
        hight=h;
    }

    //设置宽度函数
    void set_w(int w)
    {
        width=w;
    }
    //设置高度函数
    void set_h(int h)
    {
        hight=h;
    }
    //获取宽度
    int get_w()
    {
        return width;
    }
    //获取周长
    int get_peri()
    {
        return 2*width+2*hight;
    }
    //获取面积
    int get_area()
    {
        return width*hight;
    }

    //获取矩形框高度
    int get_h()
    {
        return hight;
    }

    //定义成员函数，比较两个矩形是否相等
    bool judge(Rectangle &r1, Rectangle &r2)
    {
        //比较逻辑
        if(r1.width==r2.width && r1.hight==r2.hight)
        {
            return true;
        }

        return false;
    }

    //定义成员函数，比较当前矩形框和其他传入的矩形框是否相等
    bool judge(Rectangle &other)
    {
        //比较逻辑
        if(width==other.width && hight==other.hight)
        {
            return true;
        }

        return false;
    }
};


//定义全局函数完成求两个矩形框是否相等
bool judge(Rectangle &r1, Rectangle &r2)
{
    //比较逻辑
    if(r1.get_w()==r2.get_w() && r1.get_h()==r2.get_h())
    {
        return true;
    }

    return false;
}




int main()
{
    Rectangle r1;       //实例化一个矩形对象
    r1.init(3,5);         //初始化矩形
    cout<<"矩形的周长为："<<r1.get_peri()<<endl;
    cout<<"矩形的面积为："<<r1.get_area()<<endl;

    //重新设置矩形的宽度
    r1.set_w(10);
    cout<<"矩形的周长为："<<r1.get_peri()<<endl;
    cout<<"矩形的面积为："<<r1.get_area()<<endl;

    //实例化另一个矩形框
    Rectangle r2;
    r2.init(10,10);

    //判断两个矩形框是否相等
    /*
    if(judge(r1,r2))        //调用全局函数
    {
        cout<<"两个矩形框相等"<<endl;
    }else
    {
        cout<<"两个矩形框不相等"<<endl;
    }
    */
    /*调用成员函数判断两个矩形框是否相等
    if(r1.judge(r1, r2))
    {
        cout<<"两个矩形框相等"<<endl;
    }else
    {
        cout<<"两个矩形框不相等"<<endl;
    }*/

    if(r1.judge(r2))
    {
        cout<<"两个矩形框相等"<<endl;
    }else
    {
        cout<<"两个矩形框不相等"<<endl;
    }


    return 0;
}

分文件编译

头文件

#ifndef RECANTLE_H
#define RECANTLE_H

#include <iostream>
using namespace std;


class Rectangle            //定义一个矩形类
{
    //私有成员属性
private:
    int width;       //矩形的宽度
    int hight;        //矩形的高度
public:
    //初始化函数
    void init(int w,int h);

    //设置宽度函数
    void set_w(int w);
    //设置高度函数
    void set_h(int h);
    //获取宽度
    int get_w();
    //获取周长
    int get_peri();
    //获取面积
    int get_area();

    //获取矩形框高度
    int get_h();

    //定义成员函数，比较两个矩形是否相等
    bool judge(Rectangle &r1, Rectangle &r2);

    //定义成员函数，比较当前矩形框和其他传入的矩形框是否相等
    bool judge(Rectangle &other);
};

//全局函数的声明
bool judge(Rectangle &r1, Rectangle &r2);

#endif // RECANTLE_H

源文件

#include "recantle.h"


//初始化函数
void Rectangle::init(int w,int h)
{
    if(w<=0 || h<=0)
    {
        cout<<"初始化失败"<<endl;
        return;
    }
    width=w;
    hight=h;
}

//设置宽度函数
void  Rectangle::set_w(int w)
{
    width=w;
}
//设置高度函数
void  Rectangle::set_h(int h)
{
    hight=h;
}
//获取宽度
int  Rectangle::get_w()
{
    return width;
}
//获取周长
int  Rectangle::get_peri()
{
    return 2*width+2*hight;
}
//获取面积
int  Rectangle::get_area()
{
    return width*hight;
}

//获取矩形框高度
int  Rectangle::get_h()
{
    return hight;
}

//定义成员函数，比较两个矩形是否相等
bool  Rectangle::judge(Rectangle &r1, Rectangle &r2)
{
    //比较逻辑
    if(r1.width==r2.width && r1.hight==r2.hight)
    {
        return true;
    }

    return false;
}

//定义成员函数，比较当前矩形框和其他传入的矩形框是否相等
bool  Rectangle::judge(Rectangle &other)
{
    //比较逻辑
    if(width==other.width && hight==other.hight)
    {
        return true;
    }

    return false;
}




//定义全局函数完成求两个矩形框是否相等
bool judge(Rectangle &r1, Rectangle &r2)
{
    //比较逻辑
    if(r1.get_w()==r2.get_w() && r1.get_h()==r2.get_h())
    {
        return true;
    }

    return false;
}

测试文件

#include"recantle.h"        //引入自定义的头文件


int main()
{
    Rectangle r1;       //实例化一个矩形对象
    r1.init(3,5);         //初始化矩形
    cout<<"矩形的周长为："<<r1.get_peri()<<endl;
    cout<<"矩形的面积为："<<r1.get_area()<<endl;

    //重新设置矩形的宽度
    r1.set_w(10);
    cout<<"矩形的周长为："<<r1.get_peri()<<endl;
    cout<<"矩形的面积为："<<r1.get_area()<<endl;

    //实例化另一个矩形框
    Rectangle r2;
    r2.init(10,10);

    //判断两个矩形框是否相等
    /*
    if(judge(r1,r2))        //调用全局函数
    {
        cout<<"两个矩形框相等"<<endl;
    }else
    {
        cout<<"两个矩形框不相等"<<endl;
    }
    */
    /*调用成员函数判断两个矩形框是否相等
    if(r1.judge(r1, r2))
    {
        cout<<"两个矩形框相等"<<endl;
    }else
    {
        cout<<"两个矩形框不相等"<<endl;
    }*/

    if(r1.judge(r2))
    {
        cout<<"两个矩形框相等"<<endl;
    }else
    {
        cout<<"两个矩形框不相等"<<endl;
    }


    return 0;
}

this指针

1> this指针是类中系统为所有非静态成员函数提供的一个隐藏的形参指针，指代当前对象的起始地址

2> 指代当前对象，哪个对象使用我，我就指向哪个对象

3> 在非静态成员函数中，如果调用了类中的成员（成员函数、成员变量），即使没有加this，系统也默认加了this。

局部名称屏蔽成员名称除外

4> this的原型： 类名 * const this;

5> 必须使用this的情况：

1、当形参名和成员名同名时，可以使用this用于区分

2、在拷贝赋值函数中，用于返回自身引用时，必须使用this（后期讲）

#include <iostream>

using namespace std;

class Stu
{
    string name = "zhangsan";
    int age = 18;

public:
    //非静态成员函数
    void show()
    {
        cout<<"show::this = "<<this<<endl;
        //cout<<"name = "<<name<<"    age = "<<age<<endl;
        cout<<"name = "<<this->name<<"    age = "<<this->age<<endl;
    }

    //定义设置函数
    void set_data(string name, int a)         //this形参的原型： Stu * const this;
    {
        cout<<"set_data::this = "<<this<<endl;
        this->name = name;              //将形参name，赋值给成员变量name
        this->age = a;                  //可以通过this改变指针指向的内存空间中的值
        //this = NULL;                   //不能通过this改变指针的值

        this->show();             //成员函数中调用另一个成员函数
    }
    
   
};

类的大小

1> 一个空类的大小为 1 字节，用于占位作用，后期如果有成员变量，就会将该1字节空间分配给成员使用

2> 类中的成员函数不占类体的大小，成员函数只有被调用时，才会分配空间

3> 只有类的成员属性才占内存空间，其类的大小要遵循字节对齐原则

4> 如果类中有虚函数，则会多一个虚指针的空间 （后期讲）

#include <iostream>

using namespace std;

//一个空类的大小为 1字节
class A
{};

//成员 变量占内存空间，要符合字节对齐原则
class B
{
    int value_a;
    char value_b;
    short value_c;
    char value_d;
    double value_e;
    short value_f;        //11112033400000005555555566000000
};

//定义一个类，既有成员属性也有成员变量,类的成员函数是不占类体的空间的
class C
{
    int a;

    void show()
    {
        int b;
        cout<<"b = "<<b<<"   a = "<<a<<endl;
    }

    void display()
    {
        this->show();
    }
};

//当类中出现虚函数时，系统会给类默认提供一个虚指针，无论有多少虚函数，都只提供一个虚函数指针
class D
{
    int value_a;      //成员变量

    //非虚函数
    void show()
    {}

    //定义虚函数
    virtual void diaplay()
    {}

    //虚函数       
    virtual void fun()
    {}
};



int main()
{
    cout << sizeof(A) << endl;            // 1

    cout << sizeof(B) << endl;            // 32

    cout << sizeof(C) << endl;            // 4

    cout << sizeof(D) << endl;            // 16

    return 0;
}

类中特殊成员函数

1> 当定义一个空类时，即使没有手动定义某些函数，C++系统会默认自动为其提供一些特殊成员函数

2> 这些函数也可以程序员手动定义，当手动定义后，系统就不再提供默认的了

3> 这些函数也无需程序员手动调用，在特殊时期，C++系统会自动调用

4> 种类：构造函数、析构函数、拷贝构造函数、拷贝赋值函数、移动构造函数、移动赋值函数、取地址运算符重载函数

构造函数

1> 构造函数是在使用类实例化对象时，用于给类对象分配内存空间以及对成员进行初始化工作时使用

2> 定义格式

1、构造函数没有返回值，不需要写返回值类型 2、函数名与类同名 3、可以有参，也可以无参 4、一般为公共权限 5、格式： 类名(形参列表){函数体内容}

3> 调用时机：无需程序员手动调用，当使用一个类实例化对象时，系统自动调用构造函数

4> 调用格式：

无参构造： 类名 对象名；

例如：string s1;

有参构造： 类名 对象名（实参列表）;

例如：string s2("hello a");

string s3(5, 'A');

5> 一个类中可以定义多个构造函数，要求参数必须不同，这些构造函数构成重载关系

虽然一个类中可以定义多个构造函数，但是一个类对象的只能使用一个构造函数构造出来

6> 一个类中，如果没有显性定义任何构造函数，那么系统会默认提供一个无参构造函数

但凡类中提供任意一个构造函数，系统就不再提供默认的无参构造函数了，如果非要使用无参构造函数，需要程序员手动定义无参构造函数

7> 构造函数的形参列表也可以设置默认参数，但是要注意是否跟其他重载的函数冲突

8> 构造函数的初始化工作是在初始化列表中完成的。

初始化列表：在构造函数函数头部后面，由冒号引出，完成初始化工作

格式： 类名(形参类型1 形参1， 形参类型2 形参2，。。。， 形参类型n 形参n) : 成员变量1（形参1），成员变量2（形参2），。。。，成员变量n(形参n) {}

#include <iostream>

using namespace std;


//定义一个类
class Stu
{
private:
    const string name;           //如果类中有const修饰的成员变量，必须使用初始化列表完成对其进行初始化工作
    int age;

public:

    //无参构造函数
    Stu():name("二狗")
    {
        //this->name = "二狗";
        this->age = 100;

        cout<<"Stu::无参构造"<<endl;
    }


    //定义有参构造函数
    Stu(string n) :name(n)
    {
        //this->name = n;
        cout<<"Stu::有参构造1"<<endl;
    }

    //定义有参构造
    //Stu(string n="大毛", int a=20)         //带默认参数的构造函数
    Stu(string name, int age) :name(name), age(age)              //使用初始化列表完成对成员的初始化工作
    {
        //此处是给成员变量赋值，而不是初始化
        //this->name = n;
        //this->age = a;
        cout<<"Stu::有参构造2"<<endl;
    }


    //定义展示函数
    void show()
    {
        cout<<"name = "<<name<<"    gae = "<<age<<endl;
    }


};





int main()
{
    Stu s1;           //系统会自动调用该类中的无参构造函数
    s1.show();
    cout<<"***************************\n";
    Stu s2("张三");        //调用自定义的有参构造
    s2.show();
    cout<<"***************************\n";
    Stu s3("张三", 18);        //调用自定义的有参构造
    s3.show();


    return 0;
}

9> 必须使用构造函数的初始化列表的情况

1、如果类的成员变量中有常成员变量，对该成员的初始化工作，必须使用初始化列表完成

2、如果类中有引用成员，那么对该成员也必须使用初始化列表完成

3、如果构造函数的形参名和成员变量同名时，可以使用初始化列表来解决

4、如果一个类中，有另一个类的对象，对该成员对象的初始化工作需要在初始化列表中显性定义该成员对象的有参构造，否则系统会自动调用其无参构造

#include <iostream>

using namespace std;

//定义一个汽车类
class Car
{
private:
    string name;
    string color;
public:
    Car() {cout<<"Car::无参构造"<<endl;}
    Car(string n, string c):name(n), color(c)
    {cout<<"Car::有参构造"<<endl;}
};



//定义一个类
class Stu
{
private:
    const string name;           //如果类中有const修饰的成员变量，必须使用初始化列表完成对其进行初始化工作
    int age;
    int &score;            //引用成员 必须在构造函数的初始化列表中进行初始化工作
    Car c;

public:


    //无参构造函数
    Stu():name("二狗"), score(*new int(520)), c("擎天柱","red")
    {
        //this->name = "二狗";
        this->age = 100;

        cout<<"Stu::无参构造"<<endl;
    }


    //定义有参构造函数
    Stu(string n, int &score) :name(n), score(score)
    {
        //this->name = n;
        cout<<"Stu::有参构造1"<<endl;
    }

    //定义有参构造
    //Stu(string n="大毛", int a=20)         //带默认参数的构造函数
    Stu(string name, int age, int &score) :name(name), age(age), score(score)              //使用初始化列表完成对成员的初始化工作
    {
        //此处是给成员变量赋值，而不是初始化
        //this->name = n;
        //this->age = a;
        cout<<"Stu::有参构造2"<<endl;
    }


    //定义展示函数
    void show()
    {
        cout<<"name = "<<name<<"    gae = "<<age<<endl;
    }



};





int main()
{
    Stu s1;           //系统会自动调用该类中的无参构造函数
    s1.show();
    cout<<"***************************\n";
    int s = 99;
    Stu s2("张三", s);        //调用自定义的有参构造
    s2.show();
    cout<<"***************************\n";
    Stu s3("张三", 18, s);        //调用自定义的有参构造
    s3.show();


    return 0;
}

使用C++手动封装一个顺序表，包含成员指针变量，成员变量N个

#include <iostream>

using namespace std;
//类型重命名
using datatype = int;     //typedef int datatype;

//定义一个顺序表类
class SeqList
{
    private:
        datatype *data;                //指向堆区空间的指针
        int size = 0;                      //数组的大小
        int len = 0;                     //顺序表实际长度


     public:
         //无参构造
        /*SeqList():data(new datatype[10]), size(10), len(0)
        {
            cout<<"无参构造"<<endl;
        }*/
        //有参构造
        SeqList(int s):data(new datatype[s]), size(s), len(0)
        {
            cout<<"有参构造"<<endl;
        }
        
         //要实现的函数


         //判空函数
         bool empty()
         {
             return len==0;
         }
         //判满函数
         bool full()
         {
             return len==size;
         }
         //添加数据函数
         bool add(datatype e)
         {
             if(full())
             {
                 return false;
             }
             len++;
             data[len] = e;
             return true;
         }
         //求当前顺序表的实际长度
         int length()
         {
             return len;
             
         }
         //任意位置插入函数
         bool insert_pos(int pos, datatype e)
         {
             if(full()||pos<0||pos>len)
             {
                 return false;
             }
             for(int i=len;i>pos;i--)
             {
                 data[i]=data[i-1];
                 
             }
             data[pos]=e;
             len++;
             return true;
         }
         //任意位置函数函数
         bool delete_pos(int pos)
         {
         if(empty()||pos<0||pos>=len)
         {
             return false;
         }
         for(int i=pos;i<len-1;i++)
         {
             data[i]=data[i+1];
             
         }
         len--;
         return true;
         
         }
         
         //访问容器中任意一个元素 at
         datatype &at(int index)
         {
             if(index<0||index>=len)
             {
                 return data[-1];
             }
             return data[index];
             
         }
         
         //君子函数：二倍扩容
         void expend()
         {
             size *=2;
             datatype *newdata =new datatype[size];
             for(int i=0;i<len;i++)
             {
                 newdata[i] = data[i];
              
             }delete []data;
             data = newdata;
             
         }
         
         //释放顺序表
         void seqfree()
         {
             delete[]data;
             data =NULL;
             size = 0;
             len = 0;          
         }
};

int main()
{
    SeqList S(5);
    S.add(1);
    S.add(2);
    S.insert_pos(1,3);
    cout <<"长度 = "<<S.length()<<endl;
    
    
    return 0;
}

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

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

相关文章

Postman配置环境变量

Postman配置环境变量

&#x1f345; 点击文末小卡片 &#xff0c;免费获取软件测试全套资料&#xff0c;资料在手&#xff0c;涨薪更快 Postman是一套比较方便的接口测试工具&#xff0c;但我们在使用过程中&#xff0c;可能会出现创建了API请求&#xff0c;但API的URL会随着服务器IP地址的变化而改…
阅读更多...
新能源网站提升用户体验的关键

新能源网站提升用户体验的关键

新能源网站的用户体验对于吸引和留住访问者至关重要。一个优秀的用户体验可以增加用户的满意度&#xff0c;提高他们对网站的忠诚度。在设计新能源网站时&#xff0c;关键在于简洁明了的界面和易于导航的布局。用户应该能够轻松找到他们需要的信息&#xff0c;而不会感到困惑或…
阅读更多...
【Unity3D日常开发】Unity3D中适用WEBGL打开Window文件对话框打开/上传文件

【Unity3D日常开发】Unity3D中适用WEBGL打开Window文件对话框打开/上传文件

推荐阅读 CSDN主页GitHub开源地址Unity3D插件分享QQ群&#xff1a;398291828小红书小破站 大家好&#xff0c;我是佛系工程师☆恬静的小魔龙☆&#xff0c;不定时更新Unity开发技巧&#xff0c;觉得有用记得一键三连哦。 一、前言 Unity3D发布的WEBGL程序是不支持直接的I/O操…
阅读更多...
ElasticSearch内存占用率过高怎么办？

ElasticSearch内存占用率过高怎么办？

文章目录 1&#xff0c;先用top看看各个进程的内存占用情况2&#xff0c;不能简单的杀死进程&#xff0c;然后再重启。3&#xff0c;查看一下ElasticSearch进程的具体启动情况4&#xff0c;修改Elasticsearch 的Java堆内存 1&#xff0c;先用top看看各个进程的内存占用情况 先…
阅读更多...
DC/AC并网逆变器模型与仿真MATLAB

DC/AC并网逆变器模型与仿真MATLAB

DC/AC并网逆变器是一种将直流电&#xff08;DC&#xff09;转化为交流电&#xff08;AC&#xff09;&#xff0c;并将其与电网并联的设备。它的核心功能是实现直流电源&#xff08;如光伏电池板或储能电池&#xff09;与电网的有效连接&#xff0c;同时保证输出电能质量满足电网…
阅读更多...
Flink三种集群部署模型

Flink三种集群部署模型

这里写自定义目录标题 Flink 集群剖析Flink 应用程序执行Flink Session 集群&#xff08;Session Mode&#xff09;Flink Job 集群&#xff08;以前称为per-job&#xff09;Flink Application 集群&#xff08;Application Mode&#xff09; 参考 Flink 集群剖析 Flink 运行时…
阅读更多...
JVM实战—12.OOM的定位和解决

JVM实战—12.OOM的定位和解决

大纲 1.如何对系统的OOM异常进行监控和报警 2.如何在JVM内存溢出时自动dump内存快照 3.Metaspace区域内存溢出时应如何解决(OutOfMemoryError: Metaspace) 4.JVM栈内存溢出时应如何解决(StackOverflowError) 5.JVM堆内存溢出时应该如何解决(OutOfMemoryError: Java heap s…
阅读更多...
一文读懂「LoRA」：大型语言模型的低秩适应

一文读懂「LoRA」：大型语言模型的低秩适应

LoRA: Low-Rank Adaptation of Large Language Models 前言 LoRA作为大模型的微调框架十分实用&#xff0c;在LoRA出现以前本人都是通过手动修改参数、优化器或者层数来“炼丹”的&#xff0c;具有极大的盲目性&#xff0c;但是LoRA技术能够快速微调参数&#xff0c;如果LoRA…
阅读更多...
IT面试求职系列主题-人工智能（一）

IT面试求职系列主题-人工智能（一）

想成功求职&#xff0c;必要的IT技能一样不能少&#xff0c;再从人工智能基础知识来一波吧。 1&#xff09;您对人工智能的理解是什么&#xff1f; 人工智能是计算机科学技术&#xff0c;强调创造能够模仿人类行为的智能机器。这里智能机器可以定义为能够像人一样行动、像人一…
阅读更多...
浏览器报错：您的连接不是私密连接，Kubernetes Dashboard无法打开

浏览器报错：您的连接不是私密连接，Kubernetes Dashboard无法打开

问题描述 部署完成Kubernetes Dashboard后&#xff0c;打开HTTPS的web页面&#xff0c;Chrome和Edge浏览器都无法正常加载页面&#xff0c;会提示您的连接不是私密连接的报错。 ​​​​​​​​​​​​ 原因&#xff1a; 浏览器不信任这些自签名的ssl证书&#xff0c;为了…
阅读更多...
【Unity插件】解决移动端UI安全区问题 - Safe Area Helper

【Unity插件】解决移动端UI安全区问题 - Safe Area Helper

在移动端设计界面时&#xff0c;必须要考虑的就是UI的安全区。 Unity本身也提供了Safearea的API。 但在asset store时已经有人提供了免费的插件&#xff08;Safe Area Helper&#xff09;&#xff0c;我们可以直接使用。 插件链接&#xff1a; https://assetstore.unity.com/p…
阅读更多...
ffmpeg7.0 aac转pcm

ffmpeg7.0 aac转pcm

#pragma once #define __STDC_CONSTANT_MACROS #define _CRT_SECURE_NO_WARNINGSextern "C" { #include "libavcodec/avcodec.h" }//缓冲区大小&#xff08;缓存5帧数据&#xff09; #define AUDIO_INBUF_SIZE 40960 /*name depthu8 8s16 …
阅读更多...
USRP X310 Windows 烧录镜像

USRP X310 Windows 烧录镜像

说明 USRP-X 系列设备包含两个用于两个以太网通道的 SFP 端口。由于 SFP 端口支持 1 千兆 (SFP) 和 10 千兆 (SFP) 收发器&#xff0c;因此 UHD 附带了多个 FPGA 图像&#xff0c;以确定上述接口的行为。 注意&#xff1a;Aurora 图像需要从 FPGA 源代码手动构建。 FPGA 图像…
阅读更多...
新型物联网智能断路器功能参数介绍

新型物联网智能断路器功能参数介绍

安科瑞刘鸿鹏 摘要 智能断路器作为现代配电系统的重要组成部分&#xff0c;以其实时监测、多重保护和远程操控的智能化功能&#xff0c;显著提升了电力系统的运行效率和安全性。本文以ASCB1系列智能断路器为例&#xff0c;探讨其技术特点和在工业、商业及民用建筑中的应用价…
阅读更多...
119.使用AI Agent解决问题：Jenkins build Pipeline时，提示npm ERR! errno FETCH_ERROR

119.使用AI Agent解决问题：Jenkins build Pipeline时，提示npm ERR! errno FETCH_ERROR

目录 1.Jenkins Build时的错误 2.百度文心快码AI智能体帮我解决 提问1&#xff1a;jenkins中如何配置npm的源 提问2&#xff1a;jenkins pipeline 类型为pipeline script from SCM时&#xff0c;如何配置npm源 3.最终解决方法-Jenkinsfile的修改 4.感触 1.Jenkins Build时…
阅读更多...
pytest+allure 入门

pytest+allure 入门

使用allure如何生成自动化测试报​​​​​​告 &#xff1f;一文详解allure的使用 。_allure测试报告-CSDN博客 例子&#xff1a; import allure import pytest import osallure.epic("闹钟") allure.feature("闹钟增删") class TestSchedule():def setu…
阅读更多...
【FPGA】时序约束与分析

【FPGA】时序约束与分析

设计约束 设计约束所处环节&#xff1a; 约束输入 分析实现结果 设计优化 设计约束分类&#xff1a; 物理约束&#xff1a;I/O接口约束&#xff08;例如引脚分配、电平标准设定等物理属性的约束&#xff09;、布局约束、布线约束以及配置约束 时序约束&#xff1a;设计FP…
阅读更多...
【Vim Masterclass 笔记09】S06L22：Vim 核心操作训练之 —— 文本的搜索、查找与替换操作（第一部分）

【Vim Masterclass 笔记09】S06L22：Vim 核心操作训练之 —— 文本的搜索、查找与替换操作（第一部分）

文章目录 S06L22 Search, Find, and Replace - Part One1 从光标位置起&#xff0c;正向定位到当前行的首个字符 b2 从光标位置起&#xff0c;反向查找某个字符3 重复上一次字符查找操作4 定位到目标字符的前一个字符5 单字符查找与 Vim 命令的组合6 跨行查找某字符串7 Vim 的增…
阅读更多...
win32汇编环境，窗口程序中对按钮控件常用操作的示例

win32汇编环境，窗口程序中对按钮控件常用操作的示例

;运行效果 ;win32汇编环境&#xff0c;窗口程序中对按钮控件常用操作的示例 ;常用的操作&#xff0c;例如创建按钮控件&#xff0c;使其无效&#xff0c;改变文本&#xff0c;得到文本等。 ;将代码复制进radasm软件里&#xff0c;直接就可以编译运行。重点部分加备注。 ;>&g…
阅读更多...
继承（7）

继承（7）

大家好&#xff0c;今天我们继续来学习一下继承的知识&#xff0c;这方面需要大家勤动脑才能理解&#xff0c;那么我们来看。 1.9 protected关键字 在类和对象章节中&#xff0c;为了实现封装特性,java中引入访向限定符,主要限定:类或者类中成员能否在类外和其他包中被访问. …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023