2023/9/13 -- C++/QT

news2024/11/28 2:37:08

作业：

1> 将之前定义的栈类和队列类都实现成模板类

栈：

#include <iostream>
#define MAX 40
using namespace std;

template <typename T>
class Stack{
private:
    T *data;
    int top;
public:
    Stack();
    ~Stack();
    Stack(const Stack &other);
    Stack &operator=(const Stack &other);
    //判空
    bool empty();
    //判满
    bool full();
    //获取栈的大小
    int size();
    //入栈
    void push();
    //出栈
    void pop();
    //获取栈顶元素
    T get_top();
};

template <typename T>
Stack<T>::Stack():data(new T[MAX]),top(-1){
    cout<<"无参构造"<<endl;
}
template <typename T>
Stack<T>::~Stack(){
    delete []data;
    cout<<"析构函数"<<endl;
}
template <typename T>
Stack<T>::Stack(const Stack &other){
    top = other.top;
    data = new T[MAX];
    memcpy(data,other.data,sizeof(other.data[0])*(other.top+1));
    cout<<"拷贝构造"<<endl;
}
template <typename T>
Stack<T>&Stack<T>::operator=(const Stack &other){
    top = other.top;
    memcpy(data,other.data,sizeof(other.data[0])*(other.top+1));
    cout<<"拷贝赋值"<<endl;
}
//判空
template <typename T>
bool Stack<T>::empty(){
    return top == -1;
}
//判满
template <typename T>
bool Stack<T>::full(){
    return top == MAX-1;
}
//获取栈的大小
template <typename T>
int Stack<T>::size(){
    return top+1;
}
//入栈
template <typename T>
void Stack<T>::push(){
    if(full()){
        cout<<"栈满!入栈失败!"<<endl;
        return;
    }
    T value;
    cout<<"请输入入栈的元素：";
    cin>>value;
    top++;
    data[top] = value;
    cout<<value<<" 入栈成功"<<endl;
}
//出栈
template <typename T>
void Stack<T>::pop(){
    if(empty()){
        cout<<"栈空!出栈失败!"<<endl;
        return;
    }
    T temp = data[top--];
    cout<<temp<<" 出栈成功"<<endl;
}
//获取栈顶元素
template <typename T>
T Stack<T>::get_top(){
    return data[top];
}

int main()
{
    Stack<int> s;
    s.push();
    s.push();
    s.push();
    cout<<"s.size = "<<s.size()<<endl;
    s.pop();
    cout<<"s.get_top = "<<s.get_top()<<endl;
    s.pop();
    s.pop();
    s.pop();
    return 0;
}

队列：

#include <iostream>
#define MAX 40
using namespace std;

template<typename T>
class Queue{
private:
    T *data;
    int front;
    int back;
public:
    Queue();
    ~Queue();
    Queue(const Queue &other);
    Queue &operator=(const Queue &other);
    //判空
    bool empty();
    //判满
    bool full();
    //获取队列大小
    int size();
    //入队
    void push();
    //出队
    void pop();
};
template <typename T>
Queue<T>::Queue():data(new T[MAX]),front(0),back(0){
    cout<<"无参构造"<<endl;
}
template <typename T>
Queue<T>::~Queue(){
    delete []data;
    cout<<"析构函数"<<endl;
}
template <typename T>
Queue<T>::Queue(const Queue &other){
    front = other.front;
    back = other.back;
    data = new T[MAX];
    memcpy(data,other.data,sizeof(other.data[0])*((other.back+MAX-other.front)%MAX));
    cout<<"拷贝构造"<<endl;
}
template <typename T>
Queue<T>&Queue<T>::operator=(const Queue &other){
    front = other.front;
    back = other.back;
    memcpy(data,other.data,sizeof(other.data[0])*((other.back+MAX-other.front)%MAX));
    cout<<"拷贝赋值"<<endl;
}
//判空
template <typename T>
bool Queue<T>::empty(){
    return front == back;
}
//判满
template <typename T>
bool Queue<T>::full(){
    return (back+1)%MAX == front;
}
//获取队列大小
template <typename T>
int Queue<T>::size(){
    return (back+MAX-front)%MAX;
}
//入队
template <typename T>
void Queue<T>::push(){
    if(full()){
        cout<<"队满!入队失败!"<<endl;
        return;
    }
    T value;
    cout<<"请输入要入队的元素：";
    cin>>value;
    data[back] = value;
    back = (back+1)%MAX;
    cout<<value<<" 入队成功"<<endl;
}
//出队
template <typename T>
void Queue<T>::pop(){
    if(empty()){
        cout<<"队空!出队失败!"<<endl;
        return;
    }
    T temp = data[front];
    front = (front+1)%MAX;
    cout<<temp<<" 出队成功"<<endl;
}

int main()
{
    Queue<int> q;
    q.push();
    q.push();
    q.push();
    cout<<"q.size = "<<q.size()<<endl;
    q.pop();
    q.pop();
    q.pop();
    q.pop();
    cout<<"q.size = "<<q.size()<<endl;
    return 0;
}

 

2> 将继承和多态的课堂代码敲一遍

一、继承过程中的特殊成员函数

1.1 构造函数

1> 父子类中的构造函数不是同一个构造函数，父子类中拥有各自的构造函数

2> 需要在子类的构造函数初始化列表中，显性调用父类的有参构造完成对子类从父类中继承下来成员的初始化，否则系统会自动调用父类的无参构造来完成对其初始化，此时，如果父类中没有无参构造，则子类的构造函数会报错

3> 构造顺序：先构造父类再构造子类

1.2 析构函数

1> 父子类中会拥有各自的析构函数

2> 无需在子类的析构函数中显性调用父类的析构函数，当子类对象消亡时，系统会自动调用父类的析构函数，完成对子类从父类继承下来成员的内存回收工作，

3> 析构顺序：先析构子类再析构父类

1.3 拷贝构造

1> 父子类中拥有各自的拷贝构造函数

2> 需要在子类的拷贝构造函数初始化列表中，显性调用父类的拷贝构造函数完成对子类从父类中继承下来成员的初始化，如果没有显性调用父类的拷贝构造函数，系统会自动调用父类的无参构造来完成对其进行初始化工作，如果父类中没有无参构造，则子类的拷贝构造会报错

3> 如果父类中有指针成员指向堆区空间，则父类的拷贝构造需要使用深拷贝，如果子类有指针成员指向堆区空间，则子类需要使用深拷贝

1.4 拷贝赋值

1> 父子类中拥有给中的拷贝赋值函数

2> 需要在子类的拷贝赋值函数体内，显性调用父类的拷贝赋值函数，来完成对子类从父类中继承下来成员的赋值，如果没有显性调用父类的拷贝赋值函数，则系统啥也不干，子类从父类继承下来的成员的值保持不变。

3> 拷贝赋值也涉及深浅拷贝问题

二、多重继承

2.1 含义

所谓多重继承，就是可以由多个类共同派生出一个子类，该子类会继承所有父类的特征

2.2 继承格式

class  子类名:继承方式1 父类1，继承方式2 父类2，。。。，继承方式n 父类n
{
    //子类拓展成员
}

三、虚继承

3.1 菱形继承（钻石继承）问题

                                             A               -->    公共基类
                                           /   \
                                          B     C            -->    中间子类
                                           \   /
                                             D               -->    汇聚子类

在继承过程中，由一个公共基类，派生出多个中间子类，再由这若干个子类的一部分共同派生出一个汇聚子类，就会导致汇聚子类中保留多份由公共基类传下来的成员，使得子类内存冗余、并且访问起来也比较麻烦

3.2 虚继承

1> 为了解决以上的菱形继承问题，我们可以引入虚继承：就是在生成中间子类时，在继承方式前加关键字virtual，那么，再由这些中间子类生成汇聚子类时，汇聚子类中就只保留一份公共基类传下来的数据

2> 一般的继承，需要在子类的构造函数初始化列表中，显性调用直接父类的构造函数，完成对继承下来成员的初始化。但是，在虚继承中，由于汇聚子类中只有一份公共基类的成员，不能确定由哪个直接父类对公共基类继承下来成员进行初始化，索性不使用直接父类对其进行初始化工作，直接调用公共基类的构造函数来完成对从公共基类中继承下来成员的初始化工作，如果没有显性调用公共基类的有参构造，那么系统会自动调用公共基类的无参构造完成初始化工作，此时，如果公共基类中没有无参构造，则汇聚子类的构造函数会报错。

#include <iostream>


using namespace std;


class A
{
protected:
    int value_a;
public:
    A() {cout<<"A::无参构造"<<endl;}
    A(int a):value_a(a) {cout<<"A::有参构造"<<endl;}
};


//虚继承格式：再生成中间子类时，继承方式前加virtual关键字
class B:virtual public A
{
protected:
    int value_b;
public:
    B() {cout<<"B::无参构造"<<endl;}
    B(int a, int b):A(a), value_b(b){cout<<"B::有参构造"<<endl;}
};


class C:virtual public A
{
protected:
    int value_c;
public:
    C() {cout<<"C::无参构造"<<endl;}
    C(int a, int c):A(a), value_c(c){cout<<"C::有参构造"<<endl;}
};


//由中间子类生成汇聚子类
class D:public B, public C
{
private:
    int value_d;
public:
    D() {}
    D(int a1, int a2, int b, int c, int d):A(a2),B(a1,b), C(a2,c), value_d(d) {cout<<"D::有参构造"<<endl;}


    void show()
    {
        cout<<"value_b = "<<value_b<<endl;
        cout<<"value_c = "<<value_c<<endl;
        cout<<"value_d = "<<value_d<<endl;
//        cout<<"value_a = "<<B::value_a<<endl;
//        cout<<"value_a = "<<C::value_a<<endl;
        cout<<"value_a = "<<value_a<<endl;
    }
};

四、多态

4.1 概念

所谓多态，就是一种形式的多种状态，多态是实现泛型编程的重要部分，能够实现“一条语句多用”

泛型编程：试图以不变的程序执行可变的功能

4.2 多态实现条件

1> 继承：没有继承就没有多态

2> 虚函数：实现函数重写，保证父子类中使用同一个函数

3> 父类指针或引用指向子类对象，调用子类中重写的父类的虚函数

4.3 虚函数

1> C++中可以将成员函数定义成虚函数，定义格式：在定义成员函数前加关键字virtual

2> 作用：以保证父类空间能够寻找到子类中重写的跟父类函数原型相同的函数

4.4 虚函数的底层实现

4.5 虚析构函数

1> 引入目的：正确引导delete关键字，在释放父类指针空间时，将子类空间一并释放

2> 定义格式：在析构函数前面加关键字virtual

3> 如果类中某个函数设置成虚函数，那么该类的子子孙孙类中的该函数都是虚函数

4> 在特殊的成员函数中，只有析构函数能设置成虚函数

5> 在定义类的时候，要养成将析构函数定义成虚析构函数，以便于内存的管理工作

#include <iostream>


using namespace std;


class Father
{
protected:
    string name;
    int age;


public:
    Father() {}
    Father(string n, int a):name(n), age(a) {cout<<"Father::有参构造"<<endl;}
    virtual ~Father() {cout<<"Father::析构函数"<<endl;}
};






class Son:public Father
{
private:
    string toy;


public:
    Son(){}
    Son(string n, int a, string t):Father(n,a), toy(t) {cout<<"Son::有参构造"<<endl;}
    ~Son(){cout<<"Son::析构函数"<<endl;}
};




int main()
{
    //定义父类指针，指向堆区的子类对象
    Father *p = new Son("张三", 18, "car");


    //释放堆区空间
    delete p;


    return 0;
}

4.6 纯虚函数

1> 引入背景：对于一个类而言，某些函数没有实现的必要，或者实现这些函数没有意义。定义这些函数，纯粹为了让子类对其进行重写，以便于后期可以使用父类的指针或引用指向子类对象，去调用子类中重写的该函数，此时就可以将该函数定义成纯虚函数

2> 纯虚函数的定义格式：将虚函数的函数体去掉，用=0进行替换：virtual 函数类型 函数名（形参列表） = 0;

3> 包含纯虚函数的类称为抽象类，抽象类不能实例化对象

4> 纯虚函数必须由子类进行重写，如果子类中没有重写纯虚函数，那么在子类中该函数还依然是纯虚函数，子类也是抽象类

#include <iostream>

using namespace std;

class Shape
{
protected:
    double perimeter;
    double area;


public:
    Shape():perimeter(0), area(0) {}


    //定义两个虚函数
    virtual double get_p() = 0;         //该函数就是纯虚函数


    virtual double get_a() = 0;


};


//定义圆形类
class Circle:public Shape
{
private:
    double radius;
public:
    Circle(double r = 0):radius(r){}


    //重写父类中提供的虚函数
    double get_a() override
    {
        area = 3.14*radius*radius;
        return area;
    }


    double get_p() override
    {


        perimeter = 2*radius*3.14;
        return perimeter;
    }
};




//定义矩形类
class Rectangle:public Shape
{
private:
    double width;
    double height;
public:
    Rectangle(double w=0, double h=0):width(w), height(h){}


    //重写父类中提供的虚函数
    double get_a() override
    {
        area = width*height;
        return area;
    }


    double get_p() override
    {
        perimeter = 2*(width+height);
        return perimeter;
    }
};


//定义全局函数输出给定图形的周长和面积
void show(Shape &s)
{
    cout<<"周长 = "<<s.get_p()<<"   面积 = "<<s.get_a()<<endl;
    //cout<<"周长 = "<<s.Shape::get_p()<<"   面积 = "<<s.Shape::get_a()<<endl;
}


int main()
{
    //实例化一个圆形
    Circle c1(2);
    show(c1);


    Rectangle r1(3,4);
    show(r1);
    cout<<"*******************************"<<endl;
    
    //Shape s;                 //包含纯虚函数的类称为抽象类，抽象类不能实例化对象


    return 0;
}

五、泛型编程之模板（template）

模板是能够将数据类型进一步抽象，我们之前所接触的抽象，都是完成对数据的相关抽象

模板分为模板函数、模板类

5.1 模板函数

1> 程序员有时定义函数时，会因为函数参数类型不同，导致同一功能的函数需要定义多个，即使有函数重载，系统会自动匹配相应的函数，也会造成代码的冗余

2> C++提供函数模板机制：使用函数时，形参的类型也由实参进行传递，定义模板函数时，模板函数的参数，不仅能接收实参的值，也能接收实参的类型

3> 定义格式

template <typename 类型形参1，typename 类型形参2，。。。，typename 类型形参n>
函数返回值类型  函数名（形参列表）{函数体内容}

注意
template是定义模板的关键字
<>:中是类型的参数，用于接收实参传递的类型
typename:用于定义类型形参变量的，也可以使用class
函数体中，可以使用模板中的类型作为函数返回值、函数形参、局部变量的类型

4> 调用方式

1、隐式调用：调用时跟普通函数调用一样，系统会自动根据传进来的实参类型，推导出模板的类型参数

2、显式调用：在函数名后，实参括号前，加<>，传递类型形参的值，调用原则：尖找尖、圆找圆

3、一般模板函数要求显式调用

5> 注意事项

一个模板下面只能定义一个函数，如果要定义多个模板函数，需要定义多个模板

#include <iostream>


using namespace std;


//定义一个模板函数
template<typename T>
T sum(T m, T n)
{
    return m+n;
}


//定义新的模板函数，不能多个模板函数共同使用一个模板
template<typename T>
T div(T m, T n)
{
    return m-n;
}






int main()
{
    cout << sum<int>(3.3,5) << endl;           //8  显式调用模板函数
    cout << sum(3.2,5.3) << endl;        //8.5
    cout << sum(string("hello"),string("world")) << endl;


    return 0;
}

6> 模板函数的特化

当基础模板和特化模板同时出现时，如果是隐式调用，默认调用基础模板，如果是显式调用，则会调用特化模板

5.2 模板类

1> 引入背景：程序员有时定义类时，可能由于数据类型的不同，导致同样功能的类，需要定义多个，造成代码冗余问题

2> C++引入模板类，类中的一些类型可以是由调用时给定，由实参进行传递

3> 定义格式

template <typename 类型形参1，typename 类型形参2，。。。，typename 类型形参n>
class 类名
{
    //成员可以使用模板中的类型
};

4> 调用方式:只能显式调用，不能隐式调用

5> 在定义模板时，模板类外，但凡使用到类名，都需要重新再定义模板，并且使用类名时，需要给定类型

#include <iostream>


using namespace std;


template<typename T>
class Node
{
private:
    T data;              //数据域
    Node *next;           //指针域


public:
    Node():next(NULL) {}           //无参构造
    Node(T d):data(d), next(NULL){}    //有参构造


    void show();


};


//在模板类外，但凡使用到模板类，都必须显性调用给定类型，需要重新定义模板
template <typename T>
void Node<T>::show()
{
    cout<<"data = "<<data<<endl;
}








int main()
{
    Node<int> n1(520);        //模板类的使用必须显性调用
    n1.show();


    Node<double> n2(3.14);
    n2.show();
    


    return 0;
}

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

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

相关文章

Spring WebFlux详解

Spring WebFlux详解

Spring 框架中包含的原始 Web 框架 Spring Web MVC 是专门为 Servlet API 和 Servlet 容器而设计的。后来在 5.0 版本中加入了 reactive 栈的 Web 框架 Spring WebFlux。它是完全非阻塞的&#xff0c;支持 Reactive Streams 背压&#xff0c;并在 Netty、Undertow 和 Servlet 容…
阅读更多...
基于Protege的知识建模实战

基于Protege的知识建模实战

一.Protege简介、用途和特点 1.Protege简介 Protege是斯坦福大学医学院生物信息研究中心基于Java开发的本体编辑和本体开发工具&#xff0c;也是基于知识的编辑器&#xff0c;属于开放源代码软件。这个软件主要用于语义网中本体的构建&#xff0c;是语义网中本体构建的核心开发…
阅读更多...
山西电力市场日前价格预测【2023-09-14】

山西电力市场日前价格预测【2023-09-14】

日前价格预测 预测说明&#xff1a; 如上图所示&#xff0c;预测明日&#xff08;2023-09-14&#xff09;山西电力市场全天平均日前电价为314.65元/MWh。其中&#xff0c;最高日前电价为362.07元/MWh&#xff0c;预计出现在19: 00。最低日前电价为154.13元/MWh&#xff0c;预计…
阅读更多...
c、c++、java、python、js对比【面向对象、过程；解释、编译语言；封装、继承、多态】

c、c++、java、python、js对比【面向对象、过程；解释、编译语言；封装、继承、多态】

C 手动内存管理&#xff1a;C语言没有内置的安全检查机制&#xff0c;容易出现内存泄漏、缓冲区溢出等安全问题。 适用于系统级编程 C 手动内存管理&#xff1a;C需要程序员手动管理内存&#xff0c;包括分配和释放内存&#xff0c;这可能导致内存泄漏和指针错误。 适用于…
阅读更多...
一百七十五、Kettle——海豚调度kettle任务的脚本需不需要配置log日志文件？

一百七十五、Kettle——海豚调度kettle任务的脚本需不需要配置log日志文件？

一、目的 总结一下&#xff0c;在用海豚调度kettle任务脚本是需不需要配置log日志文件&#xff1f; 二、两种情形介绍 &#xff08;一&#xff09;海豚配置kettle任务调度脚本时加log日志文件 #!/bin/bash source /etc/profile /usr/local/hurys/dc_env/kettle/data-integ…
阅读更多...
《PostgreSQL物化视图：创建、维护与应用》

《PostgreSQL物化视图：创建、维护与应用》

&#x1f337;&#x1f341; 博主猫头虎&#xff08;&#x1f405;&#x1f43e;&#xff09;带您 Go to New World✨&#x1f341; &#x1f405;&#x1f43e;猫头虎建议程序员必备技术栈一览表&#x1f4d6;&#xff1a; &#x1f6e0;️ 全栈技术 Full Stack: &#x1f4da…
阅读更多...
Python——urllib库

Python——urllib库

urllib是一个用来处理网络请求的python内置库。 一.基本使用 二.一个类型和6个方法 2.1 一个类型 urllib的request库中urlopen方法返回的类型&#xff1a;<class http.client.HTTPResponse>。为了与之后request库做区别。 2.2 6个方法 read()方法&#xff1a;获得响应…
阅读更多...
spark6. 如何设置spark 日志

spark6. 如何设置spark 日志

spark yarn日志全解 一.前言二.开启日志聚合是什么样的2.1 开启日志聚合MapReduce history server2.2 如何开启Spark history server 三.不开启日志聚合是什么样的四.正确使用log4j.properties 一.前言 本文只讲解再yarn 模式下的日志配置。 二.开启日志聚合是什么样的 在ya…
阅读更多...
C#，数值计算——哈希表的实现代码

C#，数值计算——哈希表的实现代码

1 文本格式 using System; using System.Collections; using System.Collections.Generic; namespace Legalsoft.Truffer { public class Hash<K, V> : Hashtable<K> { private List<V> els { get; set; } new List<V>(); public Ha…
阅读更多...
iPhone苹果15手机圆点怎么设置让屏幕上显示出来圆形图标？

iPhone苹果15手机圆点怎么设置让屏幕上显示出来圆形图标？

iPhone苹果15手机圆点怎么设置让屏幕上显示出来圆形图标&#xff1f; 1、在iPhone苹果手机上找到「设置」并点击打开&#xff1b; 2、在苹果iPhone设置内找到「辅助功能」并点击打开&#xff1b; 3、在苹果iPhone手机辅助功能内的动作交互内找到「触控」并点击打开&#xff1b…
阅读更多...
车联网远程监控管理提升车辆调度效率，实现高效运营

车联网远程监控管理提升车辆调度效率，实现高效运营

随着智慧城市建设与物联网技术发展&#xff0c;车辆使用4G工业路由器网络实现车联网&#xff0c;并对车上视频监控、GPS定位以及温湿度传感器等信息进行数据采集和实时传输。这些数据的采集和监测将通过4G网络上传到管理平台&#xff0c;为车辆调度和运行效率的优化提供了有力的…
阅读更多...
全局滚动条样式修改，elementUI table底部滚动条遮挡

全局滚动条样式修改，elementUI table底部滚动条遮挡

/* 整个滚动条 */ ::-webkit-scrollbar {width: 15px !important;height: 15px !important; } /* 滚动条上的滚动滑块 */ ::-webkit-scrollbar-thumb {border-radius: 32px; } /* 滚动条轨道 */ ::-webkit-scrollbar-track {border-radius: 32px; }// 如果想作用组件 可以 .xxx…
阅读更多...
项目--苍穹外卖

项目--苍穹外卖

1.| constant | 存放相关常量类 | | context | 存放上下文类 | | enumeration | 项目的枚举类存储 | | exception | 存放自定义异常类 | | json | 处理json转换的类 | | properties | 存放SpringBoot相关的配置属性类 | | result | 返回结果类的封装 | | utils | 常用工具类 | …
阅读更多...
✔ ★算法基础笔记（Acwing）（二）—— 数据结构（17道题）【java版本】

✔ ★算法基础笔记（Acwing）（二）—— 数据结构（17道题）【java版本】

数据结构 1. 单链表模板1. 单链表(7分钟) 2. 双链表模板1. 双链表 3. 模拟栈1. 模拟栈(一个数组即可)2. 表达式求值(20分钟) 4. 队列 tt -1,hh 0;1. 模拟队列 5. 单调栈1. 单调栈(4分钟)3.14 6. 单调队列1. 滑动窗口例题(10分钟) 7. KMP1. KMP字符串(10分钟)二刷体会★三刷体…
阅读更多...
Python之glob

Python之glob

import os import glob import datetime # for dirpath, dirname, files in os.walk(rE:\htdos\Project): # print(dirpath, dirname, files)# glob.glob(**) 当前目录的所有文件和文件夹 # glob.glob(**/) 当前目录的所有文件夹 # glob.glob(20*) 找到当前目录以20开头的…
阅读更多...
HDMI协议Ver2.0a(学习笔记)

HDMI协议Ver2.0a(学习笔记)

1 简介 本规范由HDMI论坛制定 2.目的和范围 本文件构成了高清多媒体接口2.0版规范&#xff08;HDMI规范2.0版&#xff09;。本规范通过引用纳入了HDMI规范1.4b版&#xff0c;并定义了附加和改进的功能。对Source、Sink、中继器和电缆的合规性所需的机械、电气、行为和协议要…
阅读更多...
解决java.lang.reflect.ReflectionException: Reflection error

解决java.lang.reflect.ReflectionException: Reflection error

解决java.lang.reflect.ReflectionException: Reflection error 摘要引言正文1. 理解异常的根本原因2. 处理反射操作错误用法获取类的方式不正确&#xff1a;调用方法的方式不正确&#xff1a; 3. 处理访问权限问题4. 异常处理 总结参考资料 博主 默语带您 Go to New World. ✍…
阅读更多...
Unity 课时 1 : No.1 模拟面试题

Unity 课时 1 : No.1 模拟面试题

课时 1 : No.1 模拟面试题 C# 1.装箱和拆箱是什么&#xff1f; ​ 对于应用类型。将基类的子类转化成基类称为装箱。将基类转换成子类&#xff0c;成为拆箱。装箱通常使用隐式转换&#xff0c;拆箱可以使用 as 或者 强制转换。同样对于值类型也可以进行装箱和拆箱。 答案&a…
阅读更多...
C++11—线程库

C++11—线程库

C线程库 文章目录 C线程库线程的创建thread提供的成员函数get_idthis_thread命名空间线程的回收策略join detach 线程函数参数mutex的种类lock_guardunique_lock原子性操作库(atomic)cas操作windows和Linux创建进程的区别 线程的创建 调用无参的构造函数 thread() noexcept;#in…
阅读更多...
视频云存储/安防监控/AI分析/视频AI智能分析网关行为分析算法应用场景汇总

视频云存储/安防监控/AI分析/视频AI智能分析网关行为分析算法应用场景汇总

随着城市经济的日益发展&#xff0c;城市建设也如火如荼。很多施工人员为了自身方便&#xff0c;无视安全规章制度&#xff0c;不按照安全施工要求进行着装、施工。具有很大的安全隐患&#xff0c;一旦发生事故&#xff0c;就会造成人员损伤和工程进度的挤压。为了改善此问题&a…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023