C++深度解析教程笔记9-静态成员变量，静态成员函数，二阶构造，友元，函数重载，操作符重载

news2024/12/26 23:41:23

C++深度解析教程笔记9

  • 第25课 - 类的静态成员变量
    • 实验-数对象个数（失败）
    • 实验-静态变量
    • 小结
  • 第26课 - 类的静态成员函数
    • 实验-修改对象的静态变量数值
    • 实验-利用静态成员函数
    • 实验-静态变量+静态函数实现统计对象个数
    • 小结
  • 第27课 - 二阶构造模式
    • 实验-初始化是否成功
    • 实验-二阶构造例子
    • 实验-二阶构造数组类
    • 小结
  • 第28课 - 友元的尴尬能力
    • 实验-友元
    • 实验-友元不具有传递性
    • 小结
  • 第29课 - 类中的函数重载
    • 实验
    • 实验
    • 实验
    • 小结
  • 第30课 - 操作符重载的概念
    • 实验-友元实现复数相加
    • 实验-操作符重载
    • 实验
    • 小结
  • 第31课 - 完善的复数类
    • 实验
    • 小结

本文学习自狄泰软件学院 唐佐林老师的 C++深度解析教程，图片全部来源于课程PPT，仅用于个人学习记录

第25课 - 类的静态成员变量

成员变量不能在对象间共享，是专属的，可通过对象名访问public成员变量
需求

在这里插入图片描述

实验-数对象个数（失败）

#include <stdio.h>

class Test
{
private:
    int mCount;
public:
    Test() : mCount(0)
    {
        mCount++;
    }
    ~Test()
    {
        --mCount;
    }
    int getCount()
    {
        return mCount;
    }
};

Test gTest;

int main()
{
    Test t1;
    Test t2;
    
    printf("count = %d\n", gTest.getCount());
    printf("count = %d\n", t1.getCount());
    printf("count = %d\n", t2.getCount());
    
    return 0;
}
/*
期望输出1 2 3,实际输出：
count = 1
count = 1
count = 1
*/

在这里插入图片描述
在这里插入图片描述

实验-静态变量

#include <stdio.h>

class Test
{
private:
    static int cCount;//静态
public:
    Test()
    {
        cCount++;
    }
    ~Test()
    {
        --cCount;
    }
    int getCount()
    {
        return cCount;
    }
};

int Test::cCount = 0;

Test gTest;

int main()
{
    Test t1;
    Test t2;
    
    printf("count = %d\n", gTest.getCount());
    printf("count = %d\n", t1.getCount());
    printf("count = %d\n", t2.getCount());
    
    Test* pt = new Test();
    
    printf("count = %d\n", pt->getCount());
    
    delete pt;
    
    printf("count = %d\n", gTest.getCount());
    
    return 0;
}
/*
count = 3
count = 3
count = 3
count = 4
count = 3

*/

小结

类中可以通过static关键定义静态成员变量
静态成员变量
在这里插入图片描述

第26课 - 类的静态成员函数

问题：不能随时获取当前对象的数据，没有安全性，使用了全局变量
在这里插入图片描述

实验-修改对象的静态变量数值

#include <stdio.h>

class Test
{
public:
    static int cCount;
public:
    Test()
    {
        cCount++;
    }
    ~Test()
    {
        --cCount;
    }
    int getCount()
    {
        return cCount;
    }
};

int Test::cCount = 0;


int main()
{
    printf("count = %d\n", Test::cCount);//count = 0

    
    Test::cCount = 1000;//可以修改数值，安全性问题
    
    printf("count = %d\n", Test::cCount);//count = 1000
    
    return 0;
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

实验-利用静态成员函数

#include <stdio.h>

class Demo
{
private:
    int i;
public:
    int getI();
    static void StaticFunc(const char* s);//静态函数
    static void StaticSetI(Demo& d, int v);//静态函数
};

int Demo::getI()
{
    return i;
}

void Demo::StaticFunc(const char* s)
{
    printf("StaticFunc: %s\n", s);
}

void Demo::StaticSetI(Demo& d, int v)
{
    d.i = v;
}

int main()
{
    Demo::StaticFunc("main Begin...");//不需要对象，通过类直接调用
    
    Demo d;
    
    Demo::StaticSetI(d, 10);
    
    printf("d.i = %d\n", d.getI());
    
    Demo::StaticFunc("main End...");
    
    return 0;
}
/*
StaticFunc: main Begin...
d.i = 10
StaticFunc: main End...

*/

在这里插入图片描述

实验-静态变量+静态函数实现统计对象个数

#include <stdio.h>

class Test
{
private:
    static int cCount;
public:
    Test()
    {
        cCount++;
    }
    ~Test()
    {
        --cCount;
    }
    static int GetCount()
    {
        return cCount;
    }
};

int Test::cCount = 0;

int main()
{
    printf("count = %d\n", Test::GetCount());
    
    Test t1;
    Test t2;
    
    printf("count = %d\n", t1.GetCount());
    printf("count = %d\n", t2.GetCount());
    
    Test* pt = new Test();
    
    printf("count = %d\n", pt->GetCount());
    
    delete pt;
    
    printf("count = %d\n", Test::GetCount());
    
    return 0;
}
/*

count = 0
count = 2
count = 2
count = 3
count = 2
*/

小结

在这里插入图片描述

第27课 - 二阶构造模式

在这里插入图片描述
在这里插入图片描述

实验-初始化是否成功

#include <stdio.h>

class Test
{
    int mi;
    int mj;
    bool mStatus;//记录初始化是否成功
public:
    Test(int i, int j) : mStatus(false)
    {
        mi = i;
        
        return;//end
        
        mj = j;
        
        mStatus = true;
    }
    int getI()
    {
        return mi;
    }
    int getJ()
    {
        return mj;
    }
    int status()//获取状态
    {
        return mStatus;
    }
};

int main()
{  
    Test t1(1, 2);

      // printf("t1.mi = %d\n", t1.getI());
        //printf("t1.mj = %d\n", t1.getJ());//不成功
    
    if( t1.status() )
    {
        printf("t1.mi = %d\n", t1.getI());
        printf("t1.mj = %d\n", t1.getJ());
    
    }
    
    return 0;
}

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述



IntArray::IntArray(int len)
{
    //m_pointer = 0;//new int[len];case1
    m_pointer = new int[len];//case2
    if(m_pointer)
    {
    for(int i=0; i<len; i++)
    {
        m_pointer[i] = 0;
    }
    }
    m_length = len;
}

int main()
{
    IntArray a(5);
    a.set(2, 3);    
    printf("%d\n", a.length());    
    a.free(); 
    return 0;
}
cyz@cyz-virtual-machine:~/桌面/testcpp$ g++ main.cpp IntArray.cpp
cyz@cyz-virtual-machine:~/桌面/testcpp$ ./a.out
段错误 (核心已转储)
cyz@cyz-virtual-machine:~/桌面/testcpp$ g++ main.cpp IntArray.cpp
cyz@cyz-virtual-machine:~/桌面/testcpp$ ./a.out
5

实验-二阶构造例子

#include <stdio.h>

class TwoPhaseCons 
{
private:
    TwoPhaseCons() // 第一阶段构造函数
    {  
    //与系统资源无关的初始化 
    }
    bool construct() // 第二阶段构造函数
    { 
    //与系统资源相关关的初始化
        return true; 
    }
public:
    static TwoPhaseCons* NewInstance(); // 对象创建函数
};

TwoPhaseCons* TwoPhaseCons::NewInstance() 
{
    TwoPhaseCons* ret = new TwoPhaseCons();

    // 若第二阶段构造失败，返回 NULL    
    if( !(ret && ret->construct()) ) 
    {
        delete ret;//删除半成品
        ret = NULL;
    }
        
    return ret;
}


int main()
{
    TwoPhaseCons* obj = TwoPhaseCons::NewInstance();
    
    printf("obj = %p\n", obj);//obj = 0000000002521CB0

    delete obj;
    
    return 0;
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

实验-二阶构造数组类

//h文件 修改
class IntArray
{
private:
    int m_length;
    int* m_pointer;
    IntArray(int len) ;// 第一阶段构造函数
    bool construct() ;// 第二阶段构造函数
    IntArray(const IntArray& obj);
    
public:
static IntArray* NewInstance(int length); // 对象创建函数 静态成员函数
    //IntArray(int len);//构造函数改为私有 作为第一阶段构造函数
    int length();
    bool get(int index, int& value);
    bool set(int index ,int value);
    ~IntArray();
};
//IntArray.cpp
IntArray::IntArray(int len)//第一阶段构造函数
{
    
    m_length = len;
}
bool IntArray::construct() // 第二阶段构造函数
    { 
    bool ret=true;
    m_pointer = new int[m_length];
    //与系统资源相关关的初始化
    
    if(m_pointer)
    {
	    for(int i=0; i<m_length; i++)
	    {
		m_pointer[i] = 0;
	    }
    }
    else
    {
    	ret=false;
    
    }
        return ret; 
 }
IntArray* IntArray::NewInstance(int length)// 对象创建函数
{
    IntArray* ret = new IntArray(length);//new 第一阶段构造函数 

    // 若第二阶段构造失败，返回 NULL    
    if( !(ret && ret->construct()) ) 
    {
        delete ret;//删除半成品
        ret = 0;
    }
        
    return ret;
}
IntArray::~IntArray()
{
    delete[]m_pointer;
    //printf("~IntArray()\n");
}

//main.cpp
 IntArray* a = IntArray::NewInstance(5);    
    
    printf("a.length = %d\n", a->length());
    
    a->set(0, 1);
    
    for(int i=0; i<a->length(); i++)
    {
        int v = 0;
        
        a->get(i, v);
        
        printf("a[%d] = %d\n", i, v);
    }
    
    delete a;

小结

在这里插入图片描述

第28课 - 友元的尴尬能力

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

实验-友元

#include <stdio.h>
#include <math.h>

class Point
{
    double x;
    double y;
public:
    Point(double x, double y)
    {
        this->x = x;
        this->y = y;
    }
    
    double getX()
    {
        return x;
    }
    
    double getY()
    {
        return y;
    }
       
    friend double func(Point& p1, Point& p2);//友元 实现访问类
//friend double func(Point& p1, Point& p2);//注释后 error: 'double Point::y' is private within this context
};

double func(Point& p1, Point& p2)
{
    double ret = 0;
    
    ret = (p2.y - p1.y) * (p2.y - p1.y) +
          (p2.x - p1.x) * (p2.x - p1.x);
          
    ret = sqrt(ret);
    
    return ret;
}

int main()
{
    Point p1(1, 2);
    Point p2(10, 20);
    
    printf("p1(%f, %f)\n", p1.getX(), p1.getY());//p1(1.000000, 2.000000)

    printf("p2(%f, %f)\n", p2.getX(), p2.getY());//p2(10.000000, 20.000000)

    printf("|(p1, p2)| = %f\n", func(p1, p2));//|(p1, p2)| = 20.124612
    
    
    return 0;
}

在这里插入图片描述

在这里插入图片描述

实验-友元不具有传递性

#include <stdio.h>

class ClassC
{
    const char* n;
public:
    ClassC(const char* n)
    {
        this->n = n;
    }
    
    friend class ClassB;//B可以访问C的成员
};

class ClassB
{
    const char* n;
public:
    ClassB(const char* n)
    {
        this->n = n;
    }
    
    void getClassCName(ClassC& c)
    {
        printf("c.n = %s\n", c.n);
    }
    
    friend class ClassA;//A可以访问B的成员
};
//无传递性，A不可以访问C的成员
class ClassA
{
    const char* n;
public:
    ClassA(const char* n)
    {
        this->n = n;
    }
    
    void getClassBName(ClassB& b)
    {
        printf("b.n = %s\n", b.n);
    }
    /*
    void getClassCName(ClassC& c)//error: 'const char* ClassC::n' is private within this context
    {
        printf("c.n = %s\n", c.n);
    }*/
    
};

int main()
{
    ClassA A("A");
    ClassB B("B");
    ClassC C("C");
    
    A.getClassBName(B);//b.n = B

    B.getClassCName(C);//c.n = C
    
    return 0;
}

小结

在这里插入图片描述

第29课 - 类中的函数重载

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

实验

#include <stdio.h>

class Test
{
    int i;
public:
    Test()
    {
        printf("Test::Test()\n");
        this->i = 0;
    }
    
    Test(int i)
    {
        printf("Test::Test(int i)\n");
        this->i = i;
    }
    
    Test(const Test& obj)
    {
        printf("Test(const Test& obj)\n");
        this->i = obj.i;
    }
    
    static void func()
    {
        printf("void Test::func()\n");
    }
    
    void func(int i)
    {
        printf("void Test::func(int i), i = %d\n", i);
    }
    
    int getI()
    {
        return i;
    }
};

void func()//全局函数1
{
    printf("void func()\n");
}

void func(int i)//全局函数2
{
    printf("void func(int i), i = %d\n", i);
}

int main()
{
    func();
    func(1);
    
    Test t;        // Test::Test()
    Test t1(1);    // Test::Test(int i)
    Test t2(t1);   // Test(const Test& obj)
    
    func();        // void func()
    Test::func();  // void Test::func()
    
    func(2);       // void func(int i), i = 2;
    t1.func(2);    // void Test::func(int i), i = 2
    t1.func();     // void Test::func()
    
    return 0;
}
/*
void func()
void func(int i), i = 1
Test::Test()
Test::Test(int i)
Test(const Test& obj)
void func()
void Test::func()
void func(int i), i = 2
void Test::func(int i), i = 2
void Test::func()

*/

在这里插入图片描述

实验

#include <stdio.h>
#include <string.h>

char* strcpy(char* buf, const char* str, unsigned int n)
{
    return strncpy(buf, str, n);
}

int main()
{
    const char* s = "D.T.Software";
    char buf[8] = {0};
    
    //strcpy(buf, s);//报错，放不下字符串
    strcpy(buf, s, sizeof(buf)-1);//利用重载扩展原有函数的功能
    
    printf("%s\n", buf);//D.T.Sof
    
    return 0;
}

在这里插入图片描述
在这里插入图片描述

实验

在这里插入代码片

小结

在这里插入图片描述

第30课 - 操作符重载的概念

在这里插入图片描述

实验-友元实现复数相加

#include <stdio.h>

class Complex 
{
    int a;
    int b;
public:
    Complex(int a = 0, int b = 0)
    {
        this->a = a;
        this->b = b;
    }
    
    int getA()
    {
        return a;
    }
    
    int getB()
    {
        return b;
    }
    
    friend Complex Add(const Complex& p1, const Complex& p2);
};

Complex Add(const Complex& p1, const Complex& p2)
{
    Complex ret;
    
    ret.a = p1.a + p2.a;
    ret.b = p1.b + p2.b;
    
    return ret;
}

int main()
{

    Complex c1(1, 2);
    Complex c2(3, 4);
    Complex c3 = Add(c1, c2); // c1 + c2
    
    printf("c3.a = %d, c3.b = %d\n", c3.getA(), c3.getB());//c3.a = 4, c3.b = 6
    
    return 0;
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

实验-操作符重载

#include <stdio.h>

class Complex 
{
    int a;
    int b;
public:
    Complex(int a = 0, int b = 0)
    {
        this->a = a;
        this->b = b;
    }
    
    int getA()
    {
        return a;
    }
    
    int getB()
    {
        return b;
    }
    
    friend Complex operator + (const Complex& p1, const Complex& p2);
};

Complex operator + (const Complex& p1, const Complex& p2)
{
    Complex ret;
    
    ret.a = p1.a + p2.a;
    ret.b = p1.b + p2.b;
    
    return ret;
}

int main()
{

    Complex c1(1, 2);
    Complex c2(3, 4);
    Complex c3 = operator+(c1, c2);
    //Complex c3 = c1 + c2;  
    
    printf("c3.a = %d, c3.b = %d\n", c3.getA(), c3.getB());//c3.a = 4, c3.b = 6
    
    return 0;
}

在这里插入图片描述

实验

#include <stdio.h>

class Complex 
{
    int a;
    int b;
public:
    Complex(int a = 0, int b = 0)
    {
        this->a = a;
        this->b = b;
    }
    
    int getA()
    {
        return a;
    }
    
    int getB()
    {
        return b;
    }
    
    Complex operator + (const Complex& p)
    {
        Complex ret;
        printf("Complex operator + (const Complex& p)\n");
        ret.a = this->a + p.a;
        ret.b = this->b + p.b;
        
        return ret;
    }
    
    friend Complex operator + (const Complex& p1, const Complex& p2);
};

Complex operator + (const Complex& p1, const Complex& p2)
{
    Complex ret;
    printf("Complex operator + (const Complex& p1, const Complex& p2)\n");
    ret.a = p1.a + p2.a;
    ret.b = p1.b + p2.b;
    
    return ret;
}

int main()
{

    Complex c1(1, 2);
    Complex c2(3, 4);
    Complex c3 = c1 + c2; // c1.operator + (c2)
    
    printf("c3.a = %d, c3.b = %d\n", c3.getA(), c3.getB());
    
    return 0;
}
/*
Complex operator + (const Complex& p)
c3.a = 4, c3.b = 6
*/
编译器优先调用类中的函数，其次才是全局函数

小结

在这里插入图片描述

第31课 - 完善的复数类

在这里插入图片描述
在这里插入图片描述

实验

#ifndef _COMPLEX_H_
#define _COMPLEX_H_

class Complex
{
private:
    double a;
    double b;
public:
    Complex(double a=0,double b=0);
    double getA();
    double getB();
    double getmodulus();

    Complex operator+(const Complex& c);
    Complex operator-(const Complex& c);
    Complex operator*(const Complex& c);
    Complex operator/(const Complex& c);

    bool operator==(const Complex& c);
    bool operator!=(const Complex& c);
    Complex& operator=(const Complex& c);




};
#endif // _COMPLEX_H_


#include "Complex.h"
#include "math.h"

Complex::Complex(double a,double b)
{
    this->a=a;
    this->b=b;
}
double Complex::getA()
{
    return a;
}
double Complex::getB(){
    return b;
}
double Complex::getmodulus()
{
    double res=sqrt(a*a+b*b);
    return res;
}

Complex Complex::operator+(const Complex& c)
{
    double na=a+c.a;
    double nb=b+c.b;
    Complex res=Complex(na,nb);
    return res;
}
Complex Complex::operator-(const Complex& c)
{
    double na=a-c.a;
    double nb=b-c.b;
    Complex res=Complex(na,nb);
    return res;

}
Complex Complex::operator*(const Complex& c)
{
    double na=a*c.a-b*c.b;
    double nb=a*c.b+b*c.a;
    Complex res=Complex(na,nb);
    return res;

}
Complex Complex::operator/(const Complex& c)
{
    double m=c.a*c.a+c.b*c.b;
    double na=(a*c.a+b*c.b)/m;
    double nb=(-a*c.b+b*c.a)/m;
    Complex res=Complex(na,nb);
    return res;

}

bool Complex::operator==(const Complex& c){
    return a==c.a&&b==c.b;

}
bool Complex::operator!=(const Complex& c)
{
    return !(a==c.a&&b==c.b);

}
Complex& Complex::operator=(const Complex& c){
    if(this!=&c)
    {
        a=c.a;
        b=c.b;
    }
    return *this;

}

//main.cpp
#include <stdio.h>
#include "Complex.h"

int main()
{
    Complex a1(1,2);
    Complex a2(3,4);
    Complex a3=a1+a2;
    printf("%f %f\n",a3.getA(),a3.getB());
    printf("a3.getmodulus()=%f\n",a3.getmodulus());
    a3=a1-a2;
    printf("a1-a2 %f %f\n",a3.getA(),a3.getB());
    a3=a1*a2;
    printf("a1*a2%f %f\n",a3.getA(),a3.getB());
    a3=a1/a2;
    printf("a1/a2%f %f\n",a3.getA(),a3.getB());

    Complex a4=a1;
    printf("%f %f\n",a4.getA(),a4.getB());
    printf("a4==a1 %d  a4!=a1 %d\n",a4==a1,a4!=a1);


    return 0;
}

在这里插入图片描述

小结

在这里插入图片描述

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

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

相关文章

【JavaEE】HTTP(2)

【JavaEE】HTTP(2)

&#x1f921;&#x1f921;&#x1f921;个人主页&#x1f921;&#x1f921;&#x1f921; &#x1f921;&#x1f921;&#x1f921;JavaEE专栏&#x1f921;&#x1f921;&#x1f921; &#x1f921;&#x1f921;&#x1f921;下一篇文章&#xff1a;【JavaEE】HTTP协议(…
阅读更多...
C++——类和对象(下)

C++——类和对象(下)

文章目录 一、再探构造函数——初始化列表二、 类型转换三、static成员静态成员变量静态成员函数 四、 友元友元函数友元类 五、内部类六、匿名对象 一、再探构造函数——初始化列表 之前我们实现构造函数时&#xff0c;初始化成员变量主要使⽤函数体内赋值&#xff0c;构造函…
阅读更多...
【读点论文】ASAM: Boosting Segment Anything Model with Adversarial Tuning，对抗学习提升性能

【读点论文】ASAM: Boosting Segment Anything Model with Adversarial Tuning，对抗学习提升性能

ASAM: Boosting Segment Anything Model with Adversarial Tuning Abstract 在不断发展的计算机视觉领域&#xff0c;基础模型已成为关键工具&#xff0c;对各种任务表现出卓越的适应性。其中&#xff0c;Meta AI 的 Segment Anything Model (SAM) 在图像分割方面表现突出。然…
阅读更多...
第十一届MathorCup高校数学建模挑战赛-C题：海底数据中心的散热优化设计(续)（附MATLAB代码实现）

第十一届MathorCup高校数学建模挑战赛-C题：海底数据中心的散热优化设计(续)（附MATLAB代码实现）

目录 5.3 问题三的求解 5.3.1 数据分析 5.3.2 数据处理 5.3.4 得出结论 5.4 问题四的求解 5.4.1 数据分析 5.4.2 算法分析 5.5 问题五的求解 六、模型评价与推广 6.1 模型的优点 6.2 模型的缺点 6.3 模型的推广 七、参考文献 代码实现 8.1 图 4 的代码 8.2 图 5 的代码 8.3 图…
阅读更多...
旗晟巡检机器人的应用场景有哪些？

旗晟巡检机器人的应用场景有哪些？

巡检机器人作为现代科技的杰出成果&#xff0c;已广泛应用于各个关键场景。从危险的工业现场到至关重要的基础设施&#xff0c;它们的身影无处不在。它们以精准、高效、不知疲倦的特性&#xff0c;担当起保障生产、守护安全的重任&#xff0c;为行业发展注入新的活力。那么&…
阅读更多...
VMware安装CentOS 7

VMware安装CentOS 7

在虚拟机中安装无论是Windows还是Linux其实都差不多&#xff0c;主要还是需要熟悉VMware的使用&#xff0c;多新增几次就熟悉了&#xff0c;可以反复删除再新增去练习… 如下是安装CentOS 7 安装过程&#xff1a; VMare Workstation 16 PRO 中安装CentOS 7 CentOS 7 下载推荐…
阅读更多...
PTA - 嵌套列表求和

PTA - 嵌套列表求和

使用递归函数对嵌套列表求和 函数接口定义&#xff1a; def sumtree(L) L是输入的嵌套列表。 裁判测试程序样例&#xff1a; /* 请在这里填写答案 */L eval(input()) print(sumtree(L)) # 调用函数 输入样例&#xff1a; 在这里给出一组输入。例如&#xff1a; [1,[2…
阅读更多...
数据结构-C语言-排序（1）

数据结构-C语言-排序（1）

代码位置&#xff1a;test-c-2024: 对C语言习题代码的练习 (gitee.com) 一、前言&#xff1a; 1.1-排序定义&#xff1a; 排序就是将一组杂乱无章的数据按照一定的规律&#xff08;升序或降序&#xff09;组织起来。 1.2-排序分类&#xff1a; 常见的排序算法&#xff1a; 插…
阅读更多...
业务终端动态分配IP-DHCP技术、DHCP中继技术

业务终端动态分配IP-DHCP技术、DHCP中继技术

一、为什么需要DHCP？ 1、许多设备（主机、无线WiFi终端等）需要动态地址的分配； 2、人工手工配置任务繁琐、容易出错，比如：IP地址冲突； 3、网络规模扩大、复杂度提高，网络配置越来越复杂，计算机的位置变化和数量超过可分配IP地址的数量，造成IP地址变法频繁以及IP地址…
阅读更多...
【精品资料】大数据可视化平台数据治理方案（626页WORD）

【精品资料】大数据可视化平台数据治理方案（626页WORD）

引言&#xff1a;大数据可视化平台的数据治理方案是一个综合性的策略&#xff0c;旨在确保大数据的质量、安全性、可访问性和合规性&#xff0c;从而支持高效的数据分析和可视化过程。 方案介绍&#xff1a; 大数据可视化平台的数据治理方案是一个综合性的策略&#xff0c;旨在…
阅读更多...
SimMIM：一个类BERT的计算机视觉的预训练框架

SimMIM：一个类BERT的计算机视觉的预训练框架

1、前言 呃…好久没有写博客了&#xff0c;主要是最近时间比较少。今天来做一期视频博客的内容。本文主要讲SimMIM&#xff0c;它是一个将计算机视觉&#xff08;图像&#xff09;进行自监督训练的框架。 原论文&#xff1a;SimMIM&#xff1a;用于掩码图像建模的简单框架 (a…
阅读更多...
设计模式-UML类图

设计模式-UML类图

1.UML概述 UML-统一建模语言&#xff0c;用来设计软件的可视化建模语言&#xff1b; 1.1 UML分类 静态结构图&#xff1a;类图、对象图、组件图、部署图动态行为图&#xff1a;状态图、活动图、时序图、协作图、构件图等 类图&#xff1a;反应类与类结构之间的关系&#xff0…
阅读更多...
【46 Pandas+Pyecharts | 当当网畅销图书榜单数据分析可视化】

【46 Pandas+Pyecharts | 当当网畅销图书榜单数据分析可视化】

文章目录 &#x1f3f3;️‍&#x1f308; 1. 导入模块&#x1f3f3;️‍&#x1f308; 2. Pandas数据处理2.1 读取数据2.2 查看数据信息2.3 去除重复数据2.4 书名处理2.5 提取年份 &#x1f3f3;️‍&#x1f308; 3. Pyecharts数据可视化3.1 作者图书数量分布3.2 图书出版年份…
阅读更多...
2-36 基于matlab的流行学习算法程序

2-36 基于matlab的流行学习算法程序

基于matlab的流行学习算法程序。通过GUI的形式将MDS、PCA、ISOMAP、LLE、Hessian LLE、Laplacian、Dissusion MAP、LTSA八种算法。程序以可视化界面进行展示&#xff0c;可直接调用进行分析。多种案例举例说明八种方法优劣&#xff0c;并且可设置自己数据进行分析。程序已调通&…
阅读更多...
podman 替代 docker ？ centos Stream 10 已经弃用docker，开始用podman了！

podman 替代 docker ？ centos Stream 10 已经弃用docker，开始用podman了！

&#x1f468;‍&#x1f393;博主简介 &#x1f3c5;CSDN博客专家   &#x1f3c5;云计算领域优质创作者   &#x1f3c5;华为云开发者社区专家博主   &#x1f3c5;阿里云开发者社区专家博主 &#x1f48a;交流社区&#xff1a;运维交流社区 欢迎大家的加入&#xff01…
阅读更多...
前端vue项目打镜像并拉取镜像包

前端vue项目打镜像并拉取镜像包

前端vue项目打镜像并拉取镜像包 如图需要准备三部分的内容 1.前置要求 linux 环境 docker环境2.vue打包后的静态文件&#xff0c;需要自行打包 npm run build 打包后上传到服务器3.nginx配置&#xff08;default.conf文件配置&#xff09; server {listen 80;serve…
阅读更多...
浅谈Visual Studio 2022

浅谈Visual Studio 2022

Visual Studio 2022&#xff08;VS2022&#xff09;提供了众多强大的功能和改进&#xff0c;旨在提高开发者的效率和体验。以下是一些关键功能的概述&#xff1a;12 64位支持&#xff1a;VS2022的64位版本不再受内存限制困扰&#xff0c;主devenv.exe进程不再局限于4GB&#xf…
阅读更多...
SQL Server的视图

SQL Server的视图

SQL Server的视图 一、基础 SQL 视图&#xff08;Views&#xff09;是一种虚拟表&#xff0c;是基于 SQL 查询结果生成的。这些虚拟表可以包含来自一个或多个表的数据&#xff0c;并且可以像表一样查询&#xff1b;视图是一个表中的数据经过某种筛选后的显示方式&#xff0c;或…
阅读更多...
在 Linux 系统中安装MySQL 8.x（Ubuntu和CentOS）

在 Linux 系统中安装MySQL 8.x（Ubuntu和CentOS）

文章目录 0. 前言1. 查看 Linux 的发行版本2. 在 Ubuntu 中安装MySQL 8.x2.1 更新包索引2.1.1 更改 Ubuntu 的镜像源2.1.2 更新软件包、升级软件包&#xff08;耗时可能较长&#xff09;2.1.3 可能遇到的问题 2.2 安装MySQL2.3 安全配置2.3.1 密码安全级别2.3.2 删除匿名用户2.…
阅读更多...
昇思25天学习打卡营第25天|GAN图像生成

昇思25天学习打卡营第25天|GAN图像生成

学AI还能赢奖品&#xff1f;每天30分钟&#xff0c;25天打通AI任督二脉 (qq.com) GAN图像生成 模型简介 生成式对抗网络(Generative Adversarial Networks&#xff0c;GAN)是一种生成式机器学习模型&#xff0c;是近年来复杂分布上无监督学习最具前景的方法之一。 GAN论文逐…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023