设计模式（单例模式、工厂模式及适配器模式、装饰器模式）

news2024/11/22 16:13:17

目录

0 、设计模式简介

一、单例模式

二、工厂模式

三、适配器模式

四、装饰器模式 

0 、设计模式简介

设计模式可以分为以下三种: 

  1. 创建型模式：用来描述 “如何创建对象”，它的主要特点是 “将对象的创建和使用分离”。包括单例、原型、工厂方法、抽象工厂和建造者 5 种模式。
  2. 结构型模式：用来描述如何将类或对象按照某种布局组成更大的结构。包括代理、适配器、桥接、装饰、外观、享元和组合 7 种模式。
  3. 行为型模式：用来识别对象之间的常用交流模式以及如何分配职责。包括模板方法、策略、命令、职责链、状态、观察者、中介者、迭代器、访问者、备忘录和解释器 11 种模式。

下面将介绍单例模式、工厂模式、适配器模式、组合模式。 

一、单例模式

单例模式的实现需要三个必要的条件：

  1. 单例类的构造函数必须是私有的，这样才能将类的创建权控制在类的内部，从而使得类的外部不能创建类的实例。
  2. 单例类通过一个私有的静态变量来存储其唯一实例。
  3. 单例类通过提供一个公开的静态方法，使得外部使用者可以访问类的唯一实例。

注意：
因为单例类的构造函数是私有的，所以单例类不能被继承。

另外，实现单例类时，还需要考虑三个问题：

  • 创建单例对象时，是否线程安全。
  • 单例对象的创建，是否延时加载。
  • 获取单例对象时，是否需要加锁（锁会导致低性能）。

单例模式分为两种：饿汉方式和懒汉方式

饿汉方式：在类加载的时候就实例化对象，懒汉方式：只有在使用的时候才初始化对象。

饿汉式单例优缺点：

  • 优点：
    • 单例对象的创建是线程安全的；
    • 获取单例对象时不需要加锁。
    • 即不用考虑线程安全问题，不需要加锁，执行效率较高。
  • 缺点：
    • 单例对象的创建，不是延时加载。
    • 类加载的时候就初始化，不管后期用不用都占着空间，浪费了内存

懒汉式单例优缺点：

  • 优点：
    • 对象的创建是线程安全的。
    • 支持延时加载。
  • 缺点：获取对象的操作被加上了锁，影响了并发度。
    • 如果单例对象需要频繁使用，那这个缺点就是无法接受的。
    • 如果单例对象不需要频繁使用，那这个缺点也无伤大雅。

使用场景： 

  • 饿汉式单例模式在类加载时就创建实例，适用于单例对象的创建频繁的场景，以及对于性能要求较高的场景。
  • 懒汉式单例模式在第一次被使用时创建实例，适用于单例对象的创建不是很频繁的场景。

饿汉方式代码：

class singleton

{

    protected:

        singleton()

        {}
    
    private:

        static singleton* p;

    public:

    static singleton* initance();

};

singleton* singleton::p = new singleton;

singleton* singleton::initance()

{

    return p;

}

懒汉方式代码：

class singleton
{
protected:
    singleton()
    {
        pthread_mutex_init(&mutex);
    }
private:
    static singleton* p;
public:
    static pthread_mutex_t mutex;
    static singleton* initance();
};
 
pthread_mutex_t singleton::mutex;
singleton* singleton::p = NULL;
singleton* singleton::initance()
{
    if (p == NULL)
    {
        pthread_mutex_lock(&mutex);
        if (p == NULL)
            p = new singleton();
        pthread_mutex_unlock(&mutex);
    }
    return p;
}

二、工厂模式

工厂模式分为简单工厂模式、工厂方法模式、抽象工厂模式。

简单工厂模式：提供一个工厂类，在这个工厂类中生产A、B、C类产品。

工厂方法模式：提供n个工厂类，都继承自同一个总工厂类，然后分别生产各自的产品。

抽象工厂模式：提供n个工厂类，都继承自同一个总工厂类，然后分别生产各自的产品，产品可以包含多种。也就是对于每一个工厂，有多条生产线。

1.简单工厂模式：

NiKeShoes、AdidasShoes、LiNingShoes为具体鞋子的类，分别是耐克、阿迪达斯和李宁鞋牌的鞋，它们都继承于Shoes抽象类。 

// 鞋子抽象类
class Shoes
{
public:
    virtual ~Shoes() {}
    virtual void Show() = 0;
};

// 耐克鞋子
class NiKeShoes : public Shoes
{
public:
    void Show()
    {
        std::cout << "我是耐克球鞋，我的广告语：Just do it" << std::endl;
    }
};

// 阿迪达斯鞋子
class AdidasShoes : public Shoes
{
public:
    void Show()
    {
        std::cout << "我是阿迪达斯球鞋，我的广告语:Impossible is nothing" << std::endl;
    }
};

// 李宁鞋子
class LiNingShoes : public Shoes
{
public:
    void Show()
    {
        std::cout << "我是李宁球鞋，我的广告语：Everything is possible" << std::endl;
    }
};

ShoesFactory为工厂类，类里实现根据鞋子类型创建对应鞋子产品对象的CreateShoes(SHOES_TYPE type)函数。 

enum SHOES_TYPE
{
    NIKE,
    LINING,
    ADIDAS
};

// 总鞋厂
class ShoesFactory
{
public:
    // 根据鞋子类型创建对应的鞋子对象
    Shoes *CreateShoes(SHOES_TYPE type)
    {
        switch (type)
        {
        case NIKE:
            return new NiKeShoes();
            break;
        case LINING:
            return new LiNingShoes();
            break;
        case ADIDAS:
            return new AdidasShoes();
            break;
        default:
            return NULL;
            break;
        }
    }
};

main函数，先是构造了工厂对象，后创建指定类型的具体鞋子产品对象，创建了具体鞋子产品的对象便可直接打印广告。因为采用的是`new`的方式创建了对象，用完了要通过`delete` 释放资源资源。

int main()
{
    // 构造工厂对象
    ShoesFactory shoesFactory;

    // 从鞋工厂对象创建阿迪达斯鞋对象
    Shoes *pNikeShoes = shoesFactory.CreateShoes(NIKE);
    if (pNikeShoes != NULL)
    {
        // 耐克球鞋广告喊起
        pNikeShoes->Show();

        // 释放资源
        delete pNikeShoes;
        pNikeShoes = NULL;
    }

    // 从鞋工厂对象创建阿迪达斯鞋对象
    Shoes *pLiNingShoes = shoesFactory.CreateShoes(LINING);
    if (pLiNingShoes != NULL)
    {
        // 李宁球鞋广告喊起
        pLiNingShoes->Show();

        // 释放资源
        delete pLiNingShoes;
        pLiNingShoes = NULL;
    }

    // 从鞋工厂对象创建阿迪达斯鞋对象
    Shoes *pAdidasShoes = shoesFactory.CreateShoes(ADIDAS);
    if (pAdidasShoes != NULL)
    {
        // 阿迪达斯球鞋广告喊起
        pAdidasShoes->Show();

        // 释放资源
        delete pAdidasShoes;
        pAdidasShoes = NULL;
    }

    return 0;
}

输出结果：

2.工厂方法模式： （有的地方直接是抽象工厂模式，即对工厂也进行了抽象）

ShoesFactory抽象工厂类，提供了创建具体鞋子产品的纯虚函数。

NiKeProducer、AdidasProducer、LiNingProducer具体工厂类，继承持续工厂类，实现对应具体鞋子产品对象的创建。

// 总鞋厂
class ShoesFactory
{
public:
    virtual Shoes *CreateShoes() = 0;
    virtual ~ShoesFactory() {}
};

// 耐克生产者/生产链
class NiKeProducer : public ShoesFactory
{
public:
    Shoes *CreateShoes()
    {
        return new NiKeShoes();
    }
};

// 阿迪达斯生产者/生产链
class AdidasProducer : public ShoesFactory
{
public:
    Shoes *CreateShoes()
    {
        return new AdidasShoes();
    }
};

// 李宁生产者/生产链
class LiNingProducer : public ShoesFactory
{
public:
    Shoes *CreateShoes()
    {
        return new LiNingShoes();
    }
};

main函数针对每种类型的鞋子，构造了每种类型的生产线，再由每个生产线生产出对应的鞋子。需注意的是具体工厂对象和具体产品对象，用完了需要通过delete释放资源。 

int main()
{
    // ================ 生产耐克流程 ==================== //
    // 鞋厂开设耐克生产线
    ShoesFactory *niKeProducer = new NiKeProducer();
    // 耐克生产线产出球鞋
    Shoes *nikeShoes = niKeProducer->CreateShoes();
    // 耐克球鞋广告喊起
    nikeShoes->Show();
    // 释放资源
    delete nikeShoes;
    delete niKeProducer;

    // ================ 生产阿迪达斯流程 ==================== //
    // 鞋厂开设阿迪达斯生产者
    ShoesFactory *adidasProducer = new AdidasProducer();
    // 阿迪达斯生产线产出球鞋
    Shoes *adidasShoes = adidasProducer->CreateShoes();
    // 阿迪达斯球鞋广喊起
    adidasShoes->Show();
    // 释放资源
    delete adidasShoes;
    delete adidasProducer;

    return 0;
}

 输出结果：

3.抽象工厂模式： 

鞋厂为了扩大了业务，不仅只生产鞋子，把运动品牌的衣服也一起生产了。

Clothe和Shoes，分别为衣服和鞋子的抽象产品类。

NiKeClothe和NiKeShoes，分别是耐克衣服和耐克衣服的具体产品类。

// 基类 衣服
class Clothe
{
public:
    virtual void Show() = 0;
    virtual ~Clothe() {}
};

// 耐克衣服
class NiKeClothe : public Clothe
{
public:
    void Show()
    {
        std::cout << "我是耐克衣服，时尚我最在行！" << std::endl;
    }
};

// 基类 鞋子
class Shoes
{
public:
    virtual void Show() = 0;
    virtual ~Shoes() {}
};

// 耐克鞋子
class NiKeShoes : public Shoes
{
public:
    void Show()
    {
        std::cout << "我是耐克球鞋，让你酷起来！" << std::endl;
    }
};

Factory为抽象工厂，提供了创建鞋子CreateShoes()和衣服产品CreateClothe()对象的接口。

NiKeProducer为具体工厂，实现了创建耐克鞋子和耐克衣服的方式。

// 总厂
class Factory
{
public:
    virtual Shoes *CreateShoes() = 0;
	virtual Clothe *CreateClothe() = 0;
    virtual ~Factory() {}
};

// 耐克生产者/生产链
class NiKeProducer : public Factory
{
public:
    Shoes *CreateShoes()
    {
        return new NiKeShoes();
    }
	
	Clothe *CreateClothe()
    {
        return new NiKeClothe();
    }
};

main函数，构造耐克工厂对象，通过耐克工厂对象再创建耐克产品族的衣服和鞋子对象。同样，对象不再使用时，需要手动释放资源。 

int main()
{
    // ================ 生产耐克流程 ==================== //
    // 鞋厂开设耐克生产线
    Factory *niKeProducer = new NiKeProducer();
    
	// 耐克生产线产出球鞋
    Shoes *nikeShoes = niKeProducer->CreateShoes();
	// 耐克生产线产出衣服
    Clothe *nikeClothe = niKeProducer->CreateClothe();
    
	// 耐克球鞋广告喊起
    nikeShoes->Show();
	// 耐克衣服广告喊起
    nikeClothe->Show();
	
    // 释放资源
    delete nikeShoes;
	delete nikeClothe;
    delete niKeProducer;


    return 0;
}

 输出结果：

三、适配器模式

适配器模式的作用是解决两个软件实体间的接口不兼容的问题。将一个接口转换成客户希望的另一个接口，使接口不兼容的那些类可以一起工作。

适配器模式有两种实现方法，类适配器和对象适配器。类适配器以多继承方式实现。对象适配器以组合的方式实现，即适配器类中包含了适配者类对象。（调用了适配者类中的方法，即新的方法）

一共包含三个类：目标类、适配者类、适配器类。目标类中的接口和适配者类中的接口不兼容，可通过引入适配器类，在适配器类中，保留了原目标类的接口名，调用了适配者类接口中的功能，对功能重新进行了封装，然后通过目标类指针指向适配器类对象或者目标类引用引用适配器类对象就可调用新的功能，完成对该接口的功能完善。
 

应用场景：通过适配器完成USB与TypeC的对接。原先接口功能是USB接口，新的接口是TypeC接口，需要完成适配，即可以把USB接口当成TypeC接口来使用。（相当于给中间连了转换器）

类适配器代码：

/* Connect Usb port */
class CUsbDisk
{
public:
    virtual ~CUsbDisk() {}

    virtual void ConnectDevice()
    {
       
        cout << "Connect usb port." << endl;
    }
};

/* Connect Type-C port */
class CTypeCInterface
{
public:
    virtual ~CTypeCInterface() {}

    void ConnectDevice()
    {
        cout << "Connect Type-C port." << endl;
    }
};

/* Not only connect Usb port, but also connect Type-C port */
class CAdapter : public CUsbDisk, public CTypeCInterface
{
public:
    void ConnectDevice()
    {
         //调用了适配者类中的方法，即完善了功能，用旧的名字调用了新的功能。
        CTypeCInterface::ConnectDevice();
    }
};

int main(int argc, char *argv[])
{
 //通过目标类指针指向适配器类对象，调用了新的方法（原先的接口及新的功能）
    CUsbDisk *theDisk = new CAdapter();

    theDisk->ConnectDevice();

    delete theDisk;
    return 0;
}

输出结果：

对象适配器模式：

/* Connect Usb port */
class CUsbDisk
{
public:
    virtual ~CUsbDisk() {}

    virtual void ConnectDevice()
    {
        cout << "Connect usb port." << endl;
    }
};

/* Connect Type-C port */
class CTypeCInterface
{
public:
    virtual ~CTypeCInterface() {}

    void ConnectDevice()
    {
        cout << "Connect Type-C port." << endl;
    }
};

/* Usb device connect phone */
class CAdapter : public CUsbDisk
{
public:
    CAdapter()
    {
        mpAdaptee = new CTypeCInterface();
    }

    ~CAdapter()
    {
        if (NULL != mpAdaptee) {
            delete mpAdaptee;
        }
    }

    void ConnectDevice()
    {
        if (NULL != mpAdaptee) {
            mpAdaptee->ConnectDevice();
        } else {
            cout << "Adapter abnormal. Connect fail!" << endl;
        }
    }

private:
    //包含了适配者类对象，通过该对象调用了新的方法，重新封装了旧接口。
    CTypeCInterface *mpAdaptee;
};


int main(int argc, char *argv[])
{
    CUsbDisk *theDisk = new CAdapter();

    theDisk->ConnectDevice();

    delete theDisk;
    return 0;
}

输出结果：

 或：

/**
 * The Target defines the domain-specific interface used by the client code.
 */
class Target {
 public:
  virtual ~Target() = default;
  virtual std::string Request() const {
    return "Target: The default target's behavior.";
  }
};

/**
 * The Adaptee contains some useful behavior, but its interface is incompatible
 * with the existing client code. The Adaptee needs some adaptation before the
 * client code can use it.
 */
class Adaptee {
 public:
  std::string SpecificRequest() const {
    return ".eetpadA eht fo roivaheb laicepS";
  }
};

/**
 * The Adapter makes the Adaptee's interface compatible with the Target's
 * interface using multiple inheritance.
 */
class Adapter : public Target, public Adaptee {
 public:
  Adapter() {}
  std::string Request() const override {
    std::string to_reverse = SpecificRequest();
    std::reverse(to_reverse.begin(), to_reverse.end());
    return "Adapter: (TRANSLATED) " + to_reverse;
  }
};

/**
 * The client code supports all classes that follow the Target interface.
 */
void ClientCode(const Target *target) {
  std::cout << target->Request();
}

int main() {
  std::cout << "Client: I can work just fine with the Target objects:\n";
  Target *target = new Target;
  ClientCode(target);
  std::cout << "\n\n";
  Adaptee *adaptee = new Adaptee;
  std::cout << "Client: The Adaptee class has a weird interface. See, I don't understand it:\n";
  std::cout << "Adaptee: " << adaptee->SpecificRequest();
  std::cout << "\n\n";
  std::cout << "Client: But I can work with it via the Adapter:\n";
  Adapter *adapter = new Adapter;
  ClientCode(adapter);
  std::cout << "\n";

  delete target;
  delete adaptee;
  delete adapter;

  return 0;
}

 结果如下：

Client: I can work just fine with the Target objects:
Target: The default target's behavior.

Client: The Adaptee class has a weird interface. See, I don't understand it:
Adaptee: .eetpadA eht fo roivaheb laicepS

Client: But I can work with it via the Adapter:
Adapter: (TRANSLATED) Special behavior of the Adaptee.s

四、装饰器模式 

装饰器模式是比较常用的一种设计模式，Python中就内置了对于装饰器的支持。

具体来说，装饰器模式是用来给对象增加某些特性或者对被装饰对象进行某些修改。

如上图所示，需要被装饰的对象在最上方，它自身可以有自己的实例，一般通过抽象类来实现(Java中也可以通过接口实现)。

右侧中间是一个装饰器类或者接口，其实内容与原对象基本一致，不过我们自定义的装饰器一般会继承这个装饰器基类。

最下层就是具体的装饰器了，可以看到，具体装饰器类中需要包含被装饰对象成员（也就是说，装饰器需要和被装饰对象有同样的子类），然后增加一些额外的操作。

下面的代码是一个买煎饼的例子，如我们生活中所见，可以选基础煎饼（鸡蛋煎饼，肉煎饼等），然后再额外加别的东西。

 代码如下：

#include<iostream>
#include<string>
using namespace std;

class Pancake//基类
{
public:
    string description = "Basic Pancake";
    virtual string getDescription(){ return description; }
    virtual double cost() = 0;
};

class CondimentDecorator :public Pancake//装饰器基类
{
public:
    string getDescrition();
};

class MeatPancake :public Pancake//肉煎饼
{
public:
    MeatPancake(){ description = "MeatPancake"; }
    double cost(){ return 6; }
};
class EggPancake :public Pancake//鸡蛋煎饼
{
public:
    EggPancake(){ description = "EggPancake"; }
    double cost(){ return 5; }
};

class Egg :public CondimentDecorator//额外加鸡蛋
{
public:
    Pancake* base;
    string getDescription(){ return base->getDescription() + ", Egg"; }
    Egg(Pancake* d){ base = d; }
    double cost(){ return base->cost() + 1.5; }
};
class Potato :public CondimentDecorator//额外加土豆
{
public:
    Pancake* base;
    string getDescription(){ return base->getDescription() + ", Potato"; }
    Potato(Pancake* d){ base = d; }
    double cost(){ return base->cost() + 1; }
};
class Bacon :public CondimentDecorator//额外加培根
{
public:
    Pancake* base;
    string getDescription(){ return base->getDescription() + ", Bacon"; }
    Bacon(Pancake* d){ base = d; }
    double cost(){ return base->cost() + 2; }
};


int main()
{
    Pancake* pan = new EggPancake();
    pan = &Potato(pan);
    pan = &Bacon(pan);
    cout << pan->getDescription() << "  $ : " << pan->cost() << endl;
    system("pause");
    return 0;
}

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

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

相关文章

LabVIEW开发安捷伦液相色谱Agilent 1100 HPLC

LabVIEW开发安捷伦液相色谱Agilent 1100 HPLC

LabVIEW开发安捷伦液相色谱Agilent 1100 HPLC 液相色谱是在科研中常用的仪器&#xff0c;尤其是安捷伦等大品牌。这里对1100的使用进行介绍。 LabVIEW安捷伦1100系列驱动程序&#xff0c;用于控制1100系列的所有仪器。在LabVIEW中使用串行&#xff0c;GPIB或以太网接口。参考…
阅读更多...
【java爬虫】公司半年报数据展示

【java爬虫】公司半年报数据展示

前言 前面有一篇文章介绍了使用selenium获取上市公司半年报的方法&#xff0c;这篇文章就给这些数据写一个简单的前端展示页面 上一篇文章的链接在这里 【java爬虫】使用selenium获取某交易所公司半年报数据-CSDN博客 首先来看一下整个页面的展示效果 前端页面采用vueeleme…
阅读更多...
第89步 时间序列建模实战：时间序列融合模型

第89步 时间序列建模实战：时间序列融合模型

基于WIN10的64位系统演示 一、写在前面 这一期&#xff0c;我们介绍融合模型模型。 &#xff08;1&#xff09;数据源&#xff1a; 《PLoS One》2015年一篇题目为《Comparison of Two Hybrid Models for Forecasting the Incidence of Hemorrhagic Fever with Renal Syndro…
阅读更多...
创建进程中的内核操作

创建进程中的内核操作

fork 是一个系统调用&#xff0c;流程的最后会在 sys_call_table 中找到相应的系统调用 sys_fork。 _do_fork 里面做的第一件大事就是 copy_process&#xff0c;咱们前面讲过这个思想。如果所有数据结构都从头创建一份太麻烦了&#xff0c;还不如使用惯用“伎俩”&#xff0c;…
阅读更多...
shell脚本中数组

shell脚本中数组

分界点&#xff1a;以下内容需要更改&#xff0c;正常放假更改 数组&#xff1a; 数组的作用&#xff1a;可以一次性的定义多个变量&#xff0c;数组的长度是不限的 数组的元素类型&#xff1a;int string float. 就是形成变量池&#xff0c;可以随时的遍历和使用 数组的写…
阅读更多...
c#方法中的参数

c#方法中的参数

无参 //无参数直接调用即可MethodWithoutParameters();/// <summary>/// 没有参数的方法/// </summary>private void MethodWithoutParameters(){Debug.Log("没有参数的方法");}有参 //有一个参数MethodWithOneParameters("我是参数");/// <…
阅读更多...
【算法|动态规划 | 01背包问题No.2】AcWing 423. 采药

【算法|动态规划 | 01背包问题No.2】AcWing 423. 采药

个人主页&#xff1a;兜里有颗棉花糖 欢迎 点赞&#x1f44d; 收藏✨ 留言✉ 加关注&#x1f493;本文由 兜里有颗棉花糖 原创 收录于专栏【手撕算法系列专栏】【AcWing算法提高学习专栏】 &#x1f354;本专栏旨在提高自己算法能力的同时&#xff0c;记录一下自己的学习过程&a…
阅读更多...
JDBC与MySql数据库

JDBC与MySql数据库

一、系统开发前的环境准备 1.下载Mysql 下载地址&#xff1a;https://dev.mysql.com/downloads/mysql/ 文件解压缩到本地 在此路径下新增my.ini文件以及新建data文件夹 编辑my.ini文件 配置环境变量 注意是编辑系统变量的Path 以管理员身份运行cmd 输入命令&#xff1a…
阅读更多...
【Go】格式化字符串指令大全 Redis常用命令

【Go】格式化字符串指令大全 Redis常用命令

【Go】格式化字符串指令大全 && Redis常用命令 原创&#xff1a;As.Kai 博客地址&#xff1a;https://blog.csdn.net/qq_42362997 如果以下内容对您有帮助&#xff0c;点赞点赞点赞~ 目录 格式化格式化字符串指令大全%s 用于插入字符串%d 用于插入整数%f 用于插入浮点数…
阅读更多...
Spring AOP源码解读

Spring AOP源码解读

今天我们来分析Spring中AOP的源码&#xff0c;主要是关于SpringAOP是如何发挥作用的。 前期准备 首先我们需要有一个Spring AOP项目&#xff0c;添加好了SpringAOP的依赖。 <dependency><groupId>org.springframework</groupId><artifactId>spring-co…
阅读更多...
项目基础配置

项目基础配置

1、Spring整合MyBatis&#xff1a; 在子工程中加入所需要的依赖 准备jdbc.properties 创建spring的配置文件、整合spring和mybatis 在spring的配置文件中加载jdbc.properties 配置数据源 测试数据库连接 配置SqlSessionFactoryBean 装配数据源 指定XXXMapper.xml文件的位…
阅读更多...
DVWA-SQL Injection SQL注入

DVWA-SQL Injection SQL注入

概念 SQL注入&#xff0c;是指将特殊构造的恶意SQL语句插入Web表单的输入或页面请求的查询字符串中&#xff0c;从而欺骗后端Web服务器以执行该恶意SQL语句。 成功的 SQL 注入漏洞可以从数据库中读取敏感数据、修改数据库数据&#xff08;插入/更新/删除&#xff09;、对数据…
阅读更多...
【已解决】VSCode运行C#控制台乱码显示

【已解决】VSCode运行C#控制台乱码显示

问题描述 如上图所示&#xff0c;最近在学习C#突然发现我在运行Hello World的时候出现这样的乱码情况。 分析原因 主要是因为VS Code 是UTF-8的编码格式&#xff0c;而我们的PC是Unicode编码&#xff0c;所以我们需要对其进行一个统一即可解决问题。那么知道这个的问题那就开…
阅读更多...
“创新深化 数实融合”，AntDB数据库邀您参与“2023世界数字经济大会暨第十三届智慧城市与智能经济博览会”

“创新深化 数实融合”，AntDB数据库邀您参与“2023世界数字经济大会暨第十三届智慧城市与智能经济博览会”

10月13日&#xff0c;“2023世界数字经济大会暨第十三届智慧城市与智能经济博览会”将在浙江宁波国际会议展览中心隆重启幕&#xff0c;AntDB数据库受邀参会&#xff0c;并诚挚邀请各位领导嘉宾莅临会场参观指导。 图1&#xff1a;会议邀请函 “2023世界数字经济大会暨第十三届…
阅读更多...
BUUCTF Reverse 新年快乐

BUUCTF Reverse 新年快乐

下载文件先查壳&#xff0c;可以看到有UPX壳 用upx脱壳 拖到ida pro32&#xff0c;shiftF12查看字符串&#xff0c;看到关键字flag&#xff0c;双击进去 双击然后f5查看伪代码 main函数伪代码 关键函数&#xff1a; strncmp(const char *str1, const char *str2, size_t n)…
阅读更多...
多媒体应用设计师 第14章 多媒体应用的策划与设计

多媒体应用设计师 第14章 多媒体应用的策划与设计

口诀 图片 12.4的没有 思维导图 2020
阅读更多...
asp.net老年大学教务管理信息系统VS开发sqlserver数据库web结构c#编程

asp.net老年大学教务管理信息系统VS开发sqlserver数据库web结构c#编程

一、源码特点 asp.net 老年大学教务管理信息系统是一套完善的web设计管理系统&#xff0c;系统具有完整的源代码和数据库&#xff0c;系统主要采用B/S模式开发。开发环境为vs2010&#xff0c;数据库为sqlserver2008&#xff0c;使 用c#语言开发 asp.net老年大学教务管理…
阅读更多...
【java学习—十】HashSet集合（4）

【java学习—十】HashSet集合（4）

文章目录 1. Java集合概述2. HashSet3. 泛型 1. Java集合概述 Java 集合类存放于 java.util 包中&#xff0c;是一个用来存放对象的容器。 ① 集合只能存放对象。比如你存一个 int 型数据 1 放入集合中&#xff0c;其实它是自动转换成 Integer类后存入的&#xff0c; Java 中每…
阅读更多...
Animate（原Flash）和木疙瘩中遮罩动画秒懂

Animate（原Flash）和木疙瘩中遮罩动画秒懂

遮罩&#xff1a;就是遮住别人的罩&#xff0c;比如桌布遮住桌子&#xff0c;床单遮住床面&#xff01; 桌布就是遮罩层&#xff0c;桌子就是被遮罩层&#xff01; 让一个立方体在圆中显示&#xff0c;把圆作为遮罩层&#xff0c;放在上面图层&#xff01;立方体紧挨放在下面…
阅读更多...
C语言 每日一题 PTA 10.29 day7

C语言 每日一题 PTA 10.29 day7

1.特殊a串数列求和 给定两个均不超过9的正整数a和n&#xff0c;要求编写程序求a aa aaa⋯ aa⋯a&#xff08;n个a&#xff09;之和。 输入格式&#xff1a; 输入在一行中给出不超过9的正整数a和n。 输出格式&#xff1a; 在一行中按照“s 对应的和”的格式输出。 思路 n…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023