Update C++.md (#16)

* Update C++.md * complement --------- Co-authored-by: runxuan.zhang <[email protected]>
guaguaupup · Sep 9, 2024 · 02ff6ac · 02ff6ac
1 parent 201c99a
commit 02ff6ac
Show file tree

Hide file tree

Showing 4 changed files with 257 additions and 4 deletions.
diff --git a/.vscode/settings.json b/.vscode/settings.json
@@ -0,0 +1,3 @@
+{
+    "C_Cpp.errorSquiggles": "disabled"
+}
diff --git a/C++.md b/C++.md
@@ -620,7 +620,7 @@ const PINT p2 = &i2;	//p可以更改，p指向的内容不能更改，相当于
 
 
 
-## #define<>和#define“ ”的区别
+## #include<>和#include“ ”的区别
 
 **#include<>**
 
@@ -1846,7 +1846,7 @@ public:
 
 
 
-## 怎么在栈上栈上分配内存？
+## 怎么在栈上分配内存？
 
 alloca函数
 

diff --git a/手撕代码.md b/手撕代码.md
@@ -1346,8 +1346,39 @@ string convert_to_hex(int number) {
     return result;
 }
 ```
-
-
+# 大小端转换
+```c
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+//组合位运算的操作 实现大小端转换取高八位 取第八位 然后 按位或 实现大小端转换
+#define SWAP16(x) ((uint16_t)((((uint16_t)(x) & 0xFF00) >> 8) | \
+                               (((uint16_t)(x) & 0x00FF) << 8)))
+
+#define SWAP32(x) ((uint32_t)((((uint32_t)(x) & 0xFF000000) >> 24) | \
+                               (((uint32_t)(x) & 0x00FF0000) >> 8)  | \
+                               (((uint32_t)(x) & 0x0000FF00) << 8)  | \
+                               (((uint32_t)(x) & 0x000000FF) << 24)))
+
+#define SWAP64(x) ((uint64_t)((((uint64_t)(x) & 0xFF00000000000000) >> 56) | \
+                               (((uint64_t)(x) & 0x00FF000000000000) >> 40) | \
+                               (((uint64_t)(x) & 0x0000FF0000000000) >> 24) | \
+                               (((uint64_t)(x) & 0x000000FF00000000) >> 8)  | \
+                               (((uint64_t)(x) & 0x00000000FF000000) << 8)  | \
+                               (((uint64_t)(x) & 0x0000000000FF0000) << 24) | \
+                               (((uint64_t)(x) & 0x000000000000FF00) << 40) | \
+                               (((uint64_t)(x) & 0x00000000000000FF) << 56)))
+
+int main(int argc, char *argv[]) {
+    if (argc < 2) {
+        printf("Usage: %s <number>\n", argv[0]);
+        return 1;
+    }
+    uint32_t num32 = strtoul(argv[1], NULL, 16);
+    printf("Original 32-bit: 0x%08X, Swapped: 0x%08X\n", num32, SWAP32(num32));
+    return 0;
+}
+```
 
 # 二分查找
 

diff --git a/设计模式.md b/设计模式.md
@@ -341,9 +341,228 @@ public class Client {
 - 如果在被观察者之间有循环依赖的话，被观察者会触发它们之间进行循环调用，导致系统崩溃。在使用观察者模式是要特别注意这一点。
 
 # 工厂模式
+https://blog.csdn.net/qq_55882840/article/details/139043332
 
+## 1.工厂模式简介      
+工厂模式的三种类型：
+- 简单工厂模式
+- 工厂方法模式
+- 抽象工厂模式
+工厂模式的作用是生产对象，可以简化代码、提高可维护性，并旦可以通过工厂类生产多种对象。简单工厂模式适用于创建简单的对象，工厂模式适用于创建复杂的对象，而抽象工厂模式适用于创建更复杂的对象。
 
+## 2. 简单工厂模式
+简单工厂模式是一种创建型设计模式，旨在通过一个工厂方法来创建对象，而无需直接暴露对象的实例化逻辑。简单工厂模式通常包括一个工厂类和多个产品类。工厂类负责根据客户端的请求，返回对应的产品类实例。就是用户申请一个产品，由工厂负责创建对象。而不是用户自己创建对象。在简单工厂模式中，客户端只需要通过调用工厂类的方法，并传入相应的参数，而无需直接实例化产品类。工厂类根据客户端传入的参数决定创建哪个产品类的实例，并将实例返回给客户端。
 
+###  优点：
+封装了实例化的细节，使得客户端与具体产品类解耦，增强了灵活性和可维护性。客户端只需要知道需要什么类型的产品，而无需关心具体的实现细节。同时，如果需要新增产品类时，只需修改工厂类即可，不需要修改客户端代码。      
+### 缺点：
+简单工厂模式也有一些限制。例如，当需要创建多种类型的产品实例时，工厂类的代码可能会变得复杂，并且随着产品类型的增加，工厂类的责任也会越来越大。因此，在一些复杂的场景下，可能需要使用其他更灵活的创建型设计模式，如工厂方法模式或抽象工厂模式。总的来说，简单工厂模式提供了一种简单而灵活的方式来创建对象，对于一些简单的对象创建场景是很有用的。
+
+简单工厂模式
+```c++
+class Product {
+public:
+    virtual void operation() = 0;
+};
+class ConcreteProductA : public Product {
+public:
+    void operation() override {
+        // 具体产品A的操作实现
+    }
+};
+class ConcreteProductB : public Product {
+public:
+    void operation() override {
+        // 具体产品B的操作实现
+    }
+};
+```
+简单工厂类
+```c++
+class SimpleFactory {
+public:
+    static Product* createProduct(const std::string& type) {
+        if (type == "A") {
+            return new ConcreteProductA();
+        } else if (type == "B") {
+            return new ConcreteProductB();
+        } else {
+            return nullptr; // 可以添加默认处理逻辑或抛出异常
+        }
+    }
+};
+```
+客户端调用方式
+```c++
+int main() {
+    Product* productA = SimpleFactory::createProduct("A");
+    productA->operation(); // 调用具体产品A的操作
+    Product* productB = SimpleFactory::createProduct("B");
+    productB->operation(); // 调用具体产品B的操作
+    delete productA;
+    delete productB;
+    return 0;
+}
+```
+
+## 3. 工厂方法模式
+工厂方法模式（Factory Method Pattern）是一种创建型设计模式，它定义了一个用于创建对象的接口，但将具体的对象创建过程交给子类来实现。工厂方法模式通过让子类决定实例化哪个具体类来实现对象的创建，从而实现了将对象的创建和使用解耦的目的。
+工厂方法模式一般包括以下角色：
+抽象产品（Product）：定义了产品的共同接口，具体的产品类必须实现这个接口。
+具体产品（ConcreteProduct）：实现了抽象产品接口，是工厂方法模式中具体创建的对象。
+抽象工厂（Factory）：定义了一个工厂的接口，包含一个创建产品的抽象方法，具体的工厂类必须实现这个接口。
+具体工厂（ConcreteFactory）：实现了抽象工厂接口，负责实例化具体的产品对象。
+        工厂方法模式的关键在于通过抽象工厂和具体工厂的组合，将对象的创建过程推迟到子类中实现。客户端通过使用抽象工厂来创建产品对象，而无需关心具体的产品类和实例化细节。
+```c++
+// 抽象产品
+class Product {
+public:
+    virtual void operation() = 0;
+};
+// 具体产品 A
+class ConcreteProductA : public Product {
+public:
+    void operation() override {
+        // 具体产品 A 的操作实现
+    }
+};
+// 具体产品 B
+class ConcreteProductB : public Product {
+public:
+    void operation() override {
+        // 具体产品 B 的操作实现
+    }
+};
+// 抽象工厂
+class Factory {
+public:
+    virtual Product* createProduct() = 0;
+};
+// 具体工厂 A
+class ConcreteFactoryA : public Factory {
+public:
+    Product* createProduct() override {
+        return new ConcreteProductA();
+    }
+};
+// 具体工厂 B
+class ConcreteFactoryB : public Factory {
+public:
+    Product* createProduct() override {
+        return new ConcreteProductB();
+    }
+};
+```
+```c++
+int main() {
+    Factory* factoryA = new ConcreteFactoryA();
+    Product* productA = factoryA->createProduct();
+    productA->operation(); // 调用具体产品 A 的操作
+    Factory* factoryB = new ConcreteFactoryB();
+    Product* productB = factoryB->createProduct();
+    productB->operation(); // 调用具体产品 B 的操作
+    delete factoryA;
+    delete productA;
+    delete factoryB;
+    delete productB;
+    return 0;
+}
+```
+### 4. 抽象工厂模式
+抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它提供了一个接口，用于创建一系列相关或相互依赖的对象，而无需指定具体的类。抽象工厂模式通过将对象的创建和使用解耦，使得客户端代码与具体类的实现分离，从而实现了对象的变化和替换的灵活性。抽象工厂模式一般包括以下角色：
+
+抽象工厂（Abstract Factory）：定义了创建一系列产品对象的接口，通常包含多个创建产品的抽象方法。
+具体工厂（Concrete Factory）：实现了抽象工厂接口，负责创建具体的产品对象。
+抽象产品（Abstract Product）：定义了产品的共同接口，具体的产品类必须实现这个接口。
+具体产品（Concrete Product）：实现了抽象产品接口，是抽象工厂模式中具体创建的对象。
+```c++
+// 抽象产品 A
+class AbstractProductA {
+public:
+    virtual void operationA() = 0;
+};
+// 具体产品 A1
+class ConcreteProductA1 : public AbstractProductA {
+public:
+    void operationA() override {
+        // 具体产品 A1 的操作实现
+    }
+};
+// 具体产品 A2
+class ConcreteProductA2 : public AbstractProductA {
+public:
+    void operationA() override {
+        // 具体产品 A2 的操作实现
+    }
+};
+// 抽象产品 B
+class AbstractProductB {
+public:
+    virtual void operationB() = 0;
+};
+// 具体产品 B1
+class ConcreteProductB1 : public AbstractProductB {
+public:
+    void operationB() override {
+        // 具体产品 B1 的操作实现
+    }
+};
+// 具体产品 B2
+class ConcreteProductB2 : public AbstractProductB {
+public:
+    void operationB() override {
+        // 具体产品 B2 的操作实现
+    }
+};
+// 抽象工厂
+class AbstractFactory {
+public:
+    virtual AbstractProductA* createProductA() = 0;
+    virtual AbstractProductB* createProductB() = 0;
+};
+// 具体工厂 1
+class ConcreteFactory1 : public AbstractFactory {
+public:
+    AbstractProductA* createProductA() override {
+        return new ConcreteProductA1();
+    }
+    AbstractProductB* createProductB() override {
+        return new ConcreteProductB1();
+    }
+};
+// 具体工厂 2
+class ConcreteFactory2 : public AbstractFactory {
+public:
+    AbstractProductA* createProductA() override {
+        return new ConcreteProductA2();
+    }
+    AbstractProductB* createProductB() override {
+        return new ConcreteProductB2();
+    }
+};
+```
+客户端
+```c++
+int main() {
+    AbstractFactory* factory1 = new ConcreteFactory1();
+    AbstractProductA* productA1 = factory1->createProductA();
+    AbstractProductB* productB1 = factory1->createProductB();
+    productA1->operationA(); // 调用具体产品 A1 的操作
+    productB1->operationB(); // 调用具体产品 B1 的操作
+    delete factory1;
+    delete productA1;
+    delete productB1;
+    AbstractFactory* factory2 = new ConcreteFactory2();
+    AbstractProductA* productA2 = factory2->createProductA();
+    AbstractProductB* productB2 = factory2->createProductB();
+    productA2->operationA(); // 调用具体产品 A2 的操作
+    productB2->operationB(); // 调用具体产品 B2 的操作
+    delete factory2;
+    delete productA2;
+    delete productB2;
+    return 0;
+}
+```
 
 
 # MVC模式