《C++20设计模式》学习笔记代码---构造器模式

已于 2023-11-30 21:36:36 修改
阅读量422 收藏 10
点赞数 10
分类专栏： 设计模式 c++ 文章标签： c++20 设计模式 学习
于 2023-11-30 21:35:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BirdsLife/article/details/134332986
版权

C++20设计模式

第 2 章 构造器模式

本章所有相关代码：（包含了2.1～2.8的所有代码）

#include<iostream>
#include<string>
#include<vector>
struct HtmlElement
{
    std::string name;
    std::string text;
    std::vector<HtmlElement> elements;

    HtmlElement() {

    }

    HtmlElement(std::string name, std::string text)
        :name(name),text(text) {
        
    }

    // 该函数用来实现把elements元素拼接为字符串
    std::string str(int ident = 0) {
        // 考虑到元素的子元素包含子元素的情况，该方法可以采用递归处理起来会方便点
        // 递归法
        if (elements.empty()) {
            return "<" + name + "> " + text + " </" + name + ">";
        }

        std::string res;
        res += "<" + name + ">" + text;
        for(auto e: elements) {
            // res += "<" + e.name + "> " + e.text;
            res += e.str(); // 递归处理， 对子元素的的子元素处理
            // res += " </" + e.name + ">";
        }
        res += " </" + name + ">";

        return res;
    }
};


/* 该类是用于构建HTML元素的组件*/
struct HtmlBuilder
{
    HtmlElement root;

    HtmlBuilder(std::string root_name) {
        root.name = root_name;
    }

    // 向当前的元素中添加子元素
    /*
     * 简单构造器方法
    */
    // void add_child(std::string child_name, std::string child_text) {
    //     root.elements.emplace_back(child_name, child_text);
    // }

    /*
     * 流式构造器
    */
    HtmlBuilder& add_child(std::string child_name, std::string child_text) {
        root.elements.emplace_back(child_name, child_text);
        return *this;
    }

    HtmlBuilder* add_child2(std::string child_name, std::string child_text) {
        root.elements.emplace_back(child_name, child_text);
        return this;
    }


    std::string str() {
        return root.str();
    }
};

void oop_create_html()
{
    std::string words[] = {"hello", "world"};
    HtmlElement list{"ul", ""};

    for (auto w: words) {
        list.elements.emplace_back("li", w);
    }

    std::cout << list.str() << std::endl;
}


void simple_constructor()
{
    HtmlBuilder builder("ul");
    builder.add_child("li", "hello world.");
    builder.add_child("li", "what that?");

    std::cout << builder.str() << std::endl;
}

void flow_constructor()
{
    HtmlBuilder builder{"ul"};
    builder.add_child("li", "hello world")
           .add_child("li", "flow constructor");
    std::cout << builder.str() << std::endl;
}

void flow_constructor2()
{
    // HtmlBuilder builder{"ul"};
    HtmlBuilder *builder = new HtmlBuilder("ul");
    builder->add_child2("li", "hello world")
           ->add_child2("li", "flow constructor 2");
    std::cout << builder->str() << std::endl;
}


// 接下来看复杂一点的构造器， 我们不在使用上述代码， 特作分割， 方便代码阅读  //

#include<memory>

struct HtmlBuilder2;
struct HtmlElement2
{
    friend struct HtmlBuilder2;
    std::string name;
    std::string text;
    std::vector<HtmlElement2> elements;
    const size_t indent_size = 2;
private:
    HtmlElement2() {

    }
    HtmlElement2(std::string name, std::string text)
        :name(name),text(text) {
        
    }

public:
    static std::unique_ptr<HtmlBuilder2> create(const std::string &root_name) {
        return std::make_unique<HtmlBuilder2>(root_name);
    }
    // 该函数用来实现把elements元素拼接为字符串
    std::string str(int ident = 0) {
        // 考虑到元素的子元素包含子元素的情况，该方法可以采用递归处理起来会方便点
        // 递归法
        if (elements.empty()) {
            return "<" + name + "> " + text + " </" + name + ">";
        }

        std::string res;
        res += "<" + name + ">" + text;
        for(auto e: elements) {
            // res += "<" + e.name + "> " + e.text;
            res += e.str(); // 递归处理， 对子元素的的子元素处理
            // res += " </" + e.name + ">";
        }
        res += " </" + name + ">";

        return res;
    }
};

struct HtmlBuilder2
{
    HtmlElement2 root;

    operator HtmlElement2() const {
        return root;
    }

    HtmlElement2 build() const{
        return root;
    }

    HtmlBuilder2(std::string root_name) {
        root.name = root_name;
    }

    HtmlBuilder2& add_child(std::string child_name, std::string child_text) {
        // 由于HtmlElement2的构造函数为protected, 所以需要在HtmlElement2把HtmlBuilder2设位HtmlElement2的友元类
        // 在这块遇到了个问题， 不能直接使用参数写到elements中，需把创建好的类型然后作为emplace_back的参数传入
        // 该问题的原因是由于HtmlElement2的构造函数是保护成员，把child_name和child_text作为参数传入emplace_back
        // vector内部会创建HtmlElement2导致报错
        // root.elements.emplace_back(child_name, child_text);
        root.elements.emplace_back(HtmlElement2(child_name, child_text));
        return *this;
    }

    std::string str() {
        return root.str();
    }
};

void user_to_api()
{
    auto builder = HtmlElement2::create("ul");
    builder->add_child("li", "hwllo world")
           .add_child("li", "user to api");
    std::cout << builder->str() << std::endl;
}

void user_to_api_add_op()
{
    HtmlElement2 e = HtmlElement2::create("ul")
            ->add_child("li", "hwllo world")
            .add_child("li", "user to api op");
    std::cout << e.str() << std::endl;
}

/******************************************************************/

struct Tag
{
    std::string name;
    std::string text;
    std::vector<Tag> children;
    std::vector<std::pair<std::string, std::string>> attributes;

    friend std::ostream& operator<<(std::ostream& os, const Tag& tag)
    {
        os << "name: "<< tag.name << ", text:" << tag.text << std::endl;
        return os;
    }

protected:
    Tag(const std::string& name, const std::string& text)
        :name{name},text{text}{
    }

    Tag(const std::string& name, const std::vector<Tag>& children)
        :name{name}, children{children}{
    }
};

struct  P:Tag
{
    // 在 C++ 中，explicit 是一个关键字，用于声明只能通过显式调用来调用的构造函数。
    // 这可以防止编译器进行隐式类型转换，从而提高代码的可读性和安全性。
    explicit P(const std::string& text)
        :Tag("P", text) {
    }

    P(std::initializer_list<Tag> children)
        :Tag("P", children) {
        std::cout << "test." << std::endl;
    }
};

struct IMG:Tag{
    explicit IMG(const std::string& url)
        :Tag("IMG", "") {
        attributes.emplace_back("src", url);
    }
};

void test_groovy_style()
{
    std::cout << 
        P{
            IMG{"http://baidu.com"}
        }
        << std::endl;

    P p{
            IMG{"http://baidu.com"}
        };
    std::cout << p << std::endl;
}

/******************************************************************/

//================================================================//
class Person;
class PersonBuilderBase;
class PersonBuilder;
class PersonAddressBuilder;
class PersonJobBuilder;

class Person{
    // address
    std::string street_address;
    std::string post_code;
    std::string city;

    // employment
    std::string company_name;
    std::string position;
    int annual_income = 0;

    Person(){}

    friend class PersonBuilder;
    friend class PersonAddressBuilder;
    friend class PersonJobBuilder;
public:
    static PersonBuilder create();
};

class PersonBuilderBase{
protected:
    Person& person;  
    explicit  PersonBuilderBase(Person &person)
        :person{person} {
    }

public:
    operator Person() 
    {
        return std::move(person);
    }

    // builder facets
    PersonAddressBuilder lives() const;
    PersonJobBuilder works() const;
};

class PersonBuilder:public PersonBuilderBase {
protected:
    Person p;
public:
    PersonBuilder()
        :PersonBuilderBase{p} {
    }
};

class PersonAddressBuilder:public PersonBuilderBase {
    typedef PersonAddressBuilder self;
public:
    explicit PersonAddressBuilder(Person& person)
        :PersonBuilderBase{person}{}
    self& at(std::string street_address)
    {
        person.street_address = street_address;
        return *this;
    }

    self& with_postcode(std::string post_code)
    {
        person.post_code = post_code;
        return *this;
    }

    self& in(std::string city) 
    {
        person.city = city;
        return *this;
    }
};

class PersonJobBuilder: public PersonBuilderBase {
    typedef PersonJobBuilder self;
public:
    explicit PersonJobBuilder(Person& person)
        :PersonBuilderBase{person}{}
    self& at(std::string company_name)
    {
        person.company_name = company_name;
        return *this;
    }

    self& as_a(std::string position)
    {
        person.position = position;
        return *this;
    }

    self& earning(int annual_income)
    {
        person.annual_income = annual_income;
        return *this;
    }
};

PersonBuilder Person::create()
{
    return PersonBuilder();
}

PersonAddressBuilder PersonBuilderBase::lives() const
{
    return PersonAddressBuilder(person);
}

PersonJobBuilder PersonBuilderBase::works() const
{
    return PersonJobBuilder(person);
}

void testCombinationConstructor()
{
    Person p = Person::create()
        .lives()
            .at("123 London road")
            .with_postcode("SW1 1GB")
            .in("london")
        .works()
            .at("pragmaSoft")
            .as_a("Consultant")
            .earning(10e6);
}
//================================================================//

// 2.7 参数化构造器
//----------------------------------------------------------------//
#include<functional>

class MailService{
    class Email
    {
    public:
        std::string from;
        std::string to;
        std::string subject;
        std::string body;
        // possibly other members here
    };

public:
    class EmailBuilder
    {
        Email &email;

    public:
        explicit EmailBuilder(Email &email) : email(email) {}
        EmailBuilder &from(std::string from)
        {
            email.from = from;
            return *this;
        }

        EmailBuilder &to(std::string to)
        {
            email.to = to;
            return *this;
        }

        EmailBuilder &subject(std::string subject)
        {
            email.subject = subject;
            return *this;
        }

        EmailBuilder &body(std::string body)
        {
            email.body = body;
            return *this;
        }
        // other fluent members here
    };

    void send_email(std::function<void(EmailBuilder)> builder)
    {
        Email email;
        EmailBuilder b{email};
        builder(b);
        send_email_impl(email);

    }
private:
    void send_email_impl(const Email& email)
    {
        // actually send the email
        std::cout << "from: " << email.from << std::endl
            << "to: " << email.to << std::endl
            << "subject: " << email.subject << std::endl
            << "body: " << email.body << std::endl;
    }
};

void testParameterizedConstructor()
{
    MailService ms;
    ms.send_email([&](auto eb) {
        eb.from("foo@bar.com")
          .to("bar@baz.com")
          .subject("hello")
          .body("Hello, how are you?");
    });
}
//----------------------------------------------------------------//


// 2.8 构造器模式的继承性
namespace InheritanceOfConstructor
{
    // constructor_2_8.cpp
    class Person
    {
    public:
        std::string name;
        std::string position;
        std::string date_of_birth;

        friend std::ostream &operator<<(std::ostream &os, const Person &obj)
        {
            return os << "name: " << obj.name
                      << "\nposition: " << obj.position
                      << "\ndata_of_birth: " << obj.date_of_birth << "\n";
        }
    };

    class PersonBuilder
    {
    protected:
        Person person;

    public:
        // PersonBuilder(){}
        // PersonBuilder(Person &person) : person{person} {}
        // [[nodiscard]] :C++17引入的语法
        // 当用于描述函数的返回值时，如果调用函数的地方没有获取返回值时，编译器会给予警告
        // 当用于描述类或枚举时，若果函数的返回值是该类或枚举的对象时（引用和指针不可以），如果该返回值没有被获取，编译器给予警告。
        [[nodiscard]] Person build() const
        {
            return person;
        }
    };

#if 0
    class PersonInfoBuilder : public PersonBuilder
    {
    public:
        // PersonInfoBuilder(){}
        // explicit PersonInfoBuilder(Person &person) : PersonBuilder(person) {}
        PersonInfoBuilder &called(const std::string &name)
        {
            person.name = name;
            return *this;
        }
    };

    class PersonJobBuilder : public PersonInfoBuilder
    {
    public:
        // explicit PersonJobBuilder(Person &person) : PersonInfoBuilder(person) {}
        PersonJobBuilder &works_as(const std::string &position)
        {
            person.position = position;
            return *this;
        }
    };

    void testInheritanConstructor()
    {
        PersonInfoBuilder pb;
        auto person = pb.called("Dmitri")
                          //.work_as("programmer") // will not compile
                          .build();
        std::cout << person;
    }
#else

    template <typename TSelf>
    class PersonInfoBuilder : public PersonBuilder
    {
    public:
        // PersonInfoBuilder(){}
        // explicit PersonInfoBuilder(Person &person) : PersonBuilder(person) {}
        TSelf &called(const std::string &name)
        {
            person.name = name;
            return static_cast<TSelf &>(*this);
            // alternatively, *static_cast<TSelf*>(this)
        }
    };

    template <typename TSelf>
    class PersonJobBuilder : public PersonInfoBuilder<PersonJobBuilder<TSelf>>
    // class PersonJobBuilder : public PersonInfoBuilder<TSelf>
    {
    public:
        // explicit PersonJobBuilder(Person &person) : PersonInfoBuilder(person) {}
        TSelf &work_as(const std::string &position)
        {
            this->person.position = position;
            return static_cast<TSelf &>(*this);
        }
    };

    template <typename TSelf>
    // class PersonBirthDataBuilder : public PersonJobBuilder<TSelf>
    class PersonBirthDataBuilder : public PersonJobBuilder<PersonBirthDataBuilder<TSelf>>
    {
    public:
        TSelf &born_on(const std::string &data_of_birth)
        {
            this->person.date_of_birth = data_of_birth;
            return static_cast<TSelf &>(*this);
        }
    };

    class MyBuilder : public PersonBirthDataBuilder<MyBuilder>
    {
    };

    void testInheritanConstructor()
    {
        MyBuilder mb;
        auto me = mb.called("Dmitri")
                      .work_as("programmer") // will not compile
                      .born_on("01/01/1980")
                      .build();
        std::cout << me;
    }

    void testInheritanConstructor1()
    {
        MyBuilder mb;
        auto me = mb.called("Dmitri");
        printf("\n\ntest1: %s\n", typeid(me).name());
        me = mb.work_as("programmer"); // will not compile
        printf("test2: %s\n", typeid(me).name());
        me = mb.born_on("01/01/1980");
        printf("test3: %s\n", typeid(me).name());
        auto mm = mb.build();
        printf("test: %s\n\n", typeid(mm).name());
        std::cout << mm;
    }
#endif
} // namespace InheritanceOfConstructor

int main()
{
    oop_create_html();
    simple_constructor();
    flow_constructor();
    flow_constructor2();
    std::cout << std::endl << "================================" << std::endl;
    user_to_api();
    user_to_api_add_op();
    test_groovy_style();
    testCombinationConstructor();
    testParameterizedConstructor();
    InheritanceOfConstructor::testInheritanConstructor1();
    InheritanceOfConstructor::testInheritanConstructor();

    return 0;
}

关于2.8节中问题的代码

#include<iostream>
#include<string>

class Person
{
public:
    std::string name;
    std::string position;
    std::string date_of_birth;

    friend std::ostream &operator<<(std::ostream &os, const Person &obj)
    {
        return os << "name: " << obj.name
                  << "\nposition: " << obj.position
                  << "\ndata_of_birth: " << obj.date_of_birth << "\n";
    }
};

class PersonBuilder
{
protected:
    Person person;
public:
    // PersonBuilder(){}
    // PersonBuilder(Person &person) : person{person} {}
    // [[nodiscard]] :C++17引入的语法
    // 当用于描述函数的返回值时，如果调用函数的地方没有获取返回值时，编译器会给予警告
    // 当用于描述类或枚举时，若果函数的返回值是该类或枚举的对象时（引用和指针不可以），如果该返回值没有被获取，编译器给予警告。
    [[nodiscard]] Person build() const
    {
        return person;
    }
};

#if 0
class PersonInfoBuilder : public PersonBuilder
{
public:
    // PersonInfoBuilder(){}
    // explicit PersonInfoBuilder(Person &person) : PersonBuilder(person) {}
    PersonInfoBuilder &called(const std::string &name)
    {
        person.name = name;
        return *this;
    }
};

class PersonJobBuilder : public PersonInfoBuilder
{
public:
    // explicit PersonJobBuilder(Person &person) : PersonInfoBuilder(person) {}
    PersonJobBuilder &works_as(const std::string &position)
    {
        person.position = position;
        return *this;
    }
};

void testInheritanConstructor()
{
    PersonInfoBuilder pb;
    auto person = pb.called("Dmitri")
                      //.work_as("programmer") // will not compile
                      .build();
    std::cout << person;
}
#else

template<typename TSelf>
class PersonInfoBuilder : public PersonBuilder
{
public:
    // PersonInfoBuilder(){}
    // explicit PersonInfoBuilder(Person &person) : PersonBuilder(person) {}
    TSelf& called(const std::string &name)
    {
        person.name = name;
        return static_cast<TSelf&>(*this);
        // alternatively, *static_cast<TSelf*>(this)
    }
};

template<typename TSelf>
//class PersonJobBuilder : public PersonInfoBuilder<PersonInfoBuilder<TSelf>>
class PersonJobBuilder : public PersonInfoBuilder<TSelf>
{
public:
    // explicit PersonJobBuilder(Person &person) : PersonInfoBuilder(person) {}
    TSelf& work_as(const std::string &position)
    {
        this->person.position = position;
        return static_cast<TSelf&>(*this);
    }
};

template<typename TSelf>
class PersonBirthDataBuilder
    :public PersonJobBuilder<TSelf>
{
public:
    TSelf& born_on(const std::string& data_of_birth)
    {
        this->person.date_of_birth = data_of_birth;
        return static_cast<TSelf&>(*this);
    }
};

class MyBuilder: public PersonBirthDataBuilder<MyBuilder>{

};

void testInheritanConstructor()
{
    MyBuilder mb;
    auto me = mb.called("Dmitri")
                .work_as("programmer") // will not compile
                .born_on("01/01/1980")
                .build();
    std::cout << me;
    // printf("test: %s",typeid(me).name());
}
#endif


int main()
{
    PersonBuilder pb;
    std::cout << "hello world!" << std::endl;
    testInheritanConstructor();
    return 0;
}
BirdsLife
关注
  • 10
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《C++20设计模式》学习笔记-第2章构造器模式学习代码
02-04
通过这些文件，我们可以看到一个全面的学习路径：从理解构造器模式的基本原理，到掌握C++11中的继承构造器和参数化构造函数的使用，再到实际编写和编译代码进行测试。这样的学习过程有助于开发者在C++20环境中熟练...
C++设计模式笔记资料.zip
07-22
C++设计模式是一种在软件开发过程中，为了应对特定问题或场景而形成的可重用解决方案的模板。这些模式是经过时间考验、广泛接受并被证明有效的编程实践，它们可以帮助开发者更高效地组织代码，提高代码的可读性、可...
《C++20设计模式》学习笔记--构造器模式
BirdsLife的博客
11-30 1192
构造器模式的目的是简化复杂对象或一系列对象的构建过程，从而单独定义构成该复杂对象的各个组件的构建方法。构造器模式可以通过流式接口调用链来实现复杂的构建过程。为了实现流式接口，构造器函数需要返回this或 *this。为了强制用户使用构造器的API，我们可以将目标对象的构造函数限制为不可访问，同时，定义一个create()接口返回构造器。通过定义适当的运算符，可以使构造器转化为对象本身。借助C++新特性中的统一初始化语法，可以实现Groovy风格的构造器。
《C++20设计模式》学习笔记---单例模式
BirdsLife的博客
12-08 1211
单例模式并不完全令人厌恶，但是，如果不小心使用，它们会破坏应用程序的可测试性可可重构性。如果必须使用单例模式，请尝试避免直接使用它（如编写SomeComponent.get().foo()），将其指定为依赖项（例如，作为构造函数的参数），并保证所有依赖项都是从应用程序的某个唯一的位置（例如，控制反转容器）获取或初始化的。
《C++20设计模式》学习笔记---原型模式
BirdsLife的博客
12-06 1135
原型模式体现了对对象进行深度拷贝的概念，因此，不必每次都进行完全初始化，而是可以获取一个预定义的对象，拷贝它，稍微修改它，然后独立于原始的对象使用它。编写正确拷贝原始对象的代码，也就是执行深度拷贝的代码。这项工作可以在拷贝构造函数 / 拷贝赋值运算符或者单独的成员函数中完成。编写支持序列化 / 反序列化的代码，使用序列化 / 反序列化机制，在完成序列化后立即进行反序列化，由此完成复制。该方法会引入额外的开销，是否使用这种方法取决于具体使用场景下的拷贝频率。
《C++20设计模式》学习笔记——第2章构造器模式
qq_41668147的博客
02-02 854
本文是《C++20设计模式——可复用的面向对象设计方法》一书第二章的学习笔记。构造器模式主要关注复杂对象的创建过程。复杂对象指的是难以通过调用单行构造函数来创建的对象。这些类型的对象本身可能由其他对象组成，并且可能涉及不太明显的逻辑，因此需要专门设计单独的组件来创建。
《C++20设计模式》学习笔记---工厂方法和抽象工厂模式
BirdsLife的博客
12-04 1100
工厂方法：类的成员函数，用于创建对象，它通常可以替换构造函数。工厂：一个类，它知道如何创建对象。不过，如果为imen传入给一个函数可以创建对象的参数（如函数或类似的对象），那么这个参数也被称为工厂。正如其名所表示的意义，抽象类可以被具体的类继承。由此产生了一个工厂族群。实际开发中抽象工厂很少见。工厂可以拒绝构建对象，也就是说，工厂可以返回默认初始化的智能指针，可以返回optional或者空指针nullptr，而不用必须返回一个对象。
《C++20设计模式》---桥接模式学习笔记
BirdsLife的博客
12-16 1213
Pimpl模式是桥接（Bridge）模式的一种具体实现，现在我们看看关于桥接模式更加通用的做法。假设有两种（数学意义上的）对象：几何对象以及将几何对象绘制在屏幕上的渲染器对象。如同我们在适配器模式中展示的那样，假设我们可以以向量和光栅形式进行渲染（尽管我们不会在这里编写任何实际的绘图代码），并且将几何对象的形状限制为圆形。protected:public:可以看到，Shape类含有一个Render类型的引用。这正是桥接模型的“桥”之所在。
《C++20设计模式》---适配器模式学习笔记
BirdsLife的博客
12-16 906
适配器“是一个非常简单的概念：它允许我们将已有的接口调整（适配）为我们需要的另一个接口。适配器模式存在的真正问题是，在适配过程中，有时会生成临时数据以满足其他接口的要求。当发生这种情况时，我们可以采用缓存策略，确保只在必要时生成新的数据。当缓存的数据发生变化时，需要清理缓存中过时的数据。我们尚未提及的一个主题时懒汉式适配器，我们之前实现的适配器总是在适配器创建时就完成适配转换。如果只希望在使用适配器时才完成适配转换的工作，又该如何呢？这个问题很简单。（懒汉式适配器）
《C++20设计模式》学习笔记——第1章引论
qq_41668147的博客
02-02 811
本文是《C++20设计模式——可复用的面向对象设计方法》一书第一章的学习笔记，主要介绍一些在C++世界里很重要的概念，并且这些概念会在后续的模块章节中反复出现，值得进行熟悉。
《C++20设计模式》学习笔记——第13章职责链模式
qq_41668147的博客
02-27 925
职责链模式是一种非常简单的设计模式，允许组件依次处理命令（或查询）。职责链最简单的实现只需要维护一个指针链。理论上，如果想快速删除链上的对象，也可以用普通的vector或者list来代替指针链。代理链的实现则更加复杂，它利用了中介者模式和观察者模式，允许通过事件（信号）处理查询，让每个订阅者在将查询值返回给用户之前对最初传递的值（它是贯穿整个链的单个引用）进行修改。
Cpp.rar - C++学习笔记
03-23
标题"Cpp.rar - C++学习笔记"暗示了这份压缩包可能包含一系列关于C++的学习资料，比如笔记、代码示例或者教程。这些笔记可能会涵盖C++的基础语法、类与对象、模板、异常处理、STL（标准模板库）、内存管理等方面。...
cpp代码-练习c++
07-14
在本压缩包中，我们关注的是“cpp代码-练习c++”，这表明它包含了一些C++编程语言的实践练习。C++是一种强大的、通用的、面向...而对于有经验的开发者，挑战在于熟练运用各种设计模式和最佳实践，以及优化代码性能。
C++软件开发工程师面试学习笔记.zip
01-20
这份"C++软件开发工程师面试学习笔记"涵盖了C++程序员进阶大厂所必须了解的关键知识点，包括但不限于C++面试常见问题、设计模式、数据结构、操作系统原理以及网络编程等内容。 1. **C++面试常见问题**： - 内存...
C++20中的constinit说明符
最新发布
网络资源是无限的
07-14 960
C++20中的constinit说明符
C++20那些事之宇宙飞船运算符
Francis的博客
07-12 866
大纲三种排序equal与equivalent为什么使用三向比较运算符？本节将引入C++20的另一个知识点：宇宙飞船运算符/三向比较运算符。三种排序三向比较运算符<=>又称为宇宙飞船运算符，返回值有三种排序，下面从gcc源码角度来深入聊一下。注：懒人版，本节示例已更新星球。用法：<=>#include<compare> #include<iostream...
《C++20设计模式》访问者模式
Ten_years_star的博客
07-11 1144
《C++20设计模式》访问者模式
配置sublime的中的C++编译器(.sublime-build)，实现C++20在sublime中的使用，小白教程
司职在下的博客
07-11 798
编译器通常不会使用最新的 C++ 标准，而是使用一个稳定的默认标准（通常是一个较旧的标准，如 C++14 或 C++17），以确保与旧代码的兼容性。首先我们需要准备一下 C++ 环境，当然如果你觉得你当前的C++环境配置好了，并且C++的版本也能完成您日常的使用需求，您可以使用下面两条命令对C++的版本进行查询。所以，如果我们想使用最新的编译方式，我们必须要参考上文，我们的编译器最大支持的C++版本，从而更新我们的JSON文件，达到使用最新版本的C++进行编译。当前我使用我当前最新的Mingw来作为演示。
C++20中的consteval说明符
网络资源是无限的
07-14 407
C++20中的consteval说明符
c++设计模式--基于qt4开源跨平台开发框架 pdf
10-13
设计模式是在软件开发中常用的一种编程思想，它提供了一种解决问题的方法论，可以帮助开发者更加灵活和高效地开发软件。基于qt4开源跨平台开发框架的PDF设计模式主要包括以下几个方面。 首先，观察者模式是一种常用的设计模式，它可以用于实现PDF文件的订阅和通知功能。通过该模式，用户可以选择关注自己感兴趣的PDF文件，并在文件更新时接收到通知。 其次，工厂模式是常用的创建型设计模式，它可以帮助开发者根据需要创建不同类型的PDF文件。例如，可以使用工厂模式创建基本的PDF文件、加密的PDF文件或者带有水印的PDF文件。 再次，装饰器模式是一种结构型设计模式，可以用于在不修改现有代码的情况下为PDF文件添加额外的功能。开发者可以通过装饰器模式为PDF文件添加页眉、页脚、书签等功能，同时保持原有的PDF文件结构和功能不受影响。 此外，策略模式也是常用的设计模式之一，在PDF开发中可以用于实现不同的压缩策略和加密策略。通过策略模式，开发者可以根据需求选择不同的策略来实现对PDF文件的处理和管理。 最后，单例模式是一种创建型设计模式，可以确保在整个应用程序中只有一个PDF文件实例。通过单例模式，可以在不同的模块中共享同一个PDF文件对象，避免资源浪费和数据冲突。 总而言之，设计模式在基于qt4开源跨平台开发框架的PDF开发中具有重要的作用。以上提到的几种设计模式可以帮助开发者更好地组织和管理PDF文件，提高开发效率和代码的可维护性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值