# 建造者模式

建造者模式是一种创建型设计模式，它通过将复杂对象的构建过程与表示分离，使得同样的构建过程可以创建不同的表示。

你是否遇到过这样的问题：

- 🏗️ **复杂对象创建**：需要创建一个包含多个可选参数的对象，构造函数参数列表过长，难以使用
- 📝 **SQL 查询构建**：需要根据条件动态构建 SQL 查询语句，参数组合复杂
- 🌐 **HTTP 请求构建**：需要构建包含多个可选头部、参数、请求体的 HTTP 请求
- ⚙️ **配置对象构建**：需要创建包含大量可选配置项的对象，不同场景需要不同的配置组合

传统方法的问题：

```cpp
// ❌ 问题1：构造函数参数过多，难以使用
class HttpRequest {
public:
    HttpRequest(const std::string& url,
                const std::string& method,
                const std::map<std::string, std::string>& headers,
                const std::string& body,
                int timeout,
                bool followRedirects,
                // ... 更多参数
                );
};

// 使用困难
HttpRequest req("https://api.example.com", "POST",
                {{"Content-Type", "application/json"}},
                "{}", 30, true, /* ... */);

// ❌ 问题2：需要创建多个重载构造函数
HttpRequest(const std::string& url);
HttpRequest(const std::string& url, const std::string& method);
HttpRequest(const std::string& url, const std::string& method,
            const std::map<std::string, std::string>& headers);
// ... 参数组合爆炸

// ❌ 问题3：使用默认参数，但不够灵活
HttpRequest(const std::string& url,
            const std::string& method = "GET",
            int timeout = 30,
            // 无法跳过中间参数，只能按顺序设置
            );
```

**建造者模式**就是为了解决这些问题而生的！它通过将复杂对象的构建过程与表示分离，使用相同的构建过程创建不同的表示。

## 🧠 建造者模式核心概念

### 什么是建造者模式？

**建造者模式（Builder Pattern）**是一种创建型设计模式，它将复杂对象的构建过程与表示分离，使得同样的构建过程可以创建不同的表示。建造者模式的核心思想是：**逐步构建复杂对象，通过链式调用设置各个属性，最终构建出完整的对象**。

### 建造者模式的四个角色

1. **产品（Product）**：最终要构建的复杂对象
2. **抽象建造者（Builder）**：定义构建产品的抽象接口
3. **具体建造者（Concrete Builder）**：实现抽象建造者接口，构建具体产品
4. **指挥者（Director）**：使用建造者接口构建产品（可选）

### 建造者模式的 UML 图

```bash
┌──────────────┐
│   Product    │
│  (复杂对象)   │
└──────────────┘
       ▲
       │
┌──────┴───────┐
│   Builder    │
│  (抽象接口)   │
└──────┬───────┘
       │
┌──────▼───────┐
│ConcreteBuilder│
│  (具体实现)   │
└──────────────┘
```

这个 UML 图展示了建造者模式的基本结构。**产品**是最终要构建的复杂对象，它包含多个属性。**抽象建造者**定义了构建产品的接口，包括设置各个属性的方法和最终的 `build()` 方法。**具体建造者**实现了抽象接口，负责实际构建产品的过程。

在实际应用中，我们通常不需要抽象建造者接口，除非需要支持多种不同的建造者实现。对于大多数场景，直接实现一个具体的建造者类就足够了。

### 流式接口（Fluent Interface）

建造者模式通常结合**流式接口**使用，通过返回 `this` 指针实现链式调用，让代码更加优雅和易读：

```cpp
auto request = HttpRequestBuilder()
    .setUrl("https://api.example.com")
    .setMethod("POST")
    .addHeader("Content-Type", "application/json")
    .setBody("{}")
    .setTimeout(30)
    .build();
```

流式接口的核心思想是：每个设置方法都返回建造者自身的引用（`return *this`），这样就可以连续调用多个方法，形成一条"链"。这种设计让代码读起来就像自然语言一样，每个方法调用都清晰地表达了它在做什么。

流式接口的优势在于：

- • **可读性强**：代码自解释，读起来像自然语言
- • **灵活性高**：可以按任意顺序设置参数，也可以跳过不需要的参数
- • **易于扩展**：添加新的设置方法不会影响现有代码

需要注意的是，流式接口虽然优雅，但也要适度使用。如果对象很简单（只有 2-3 个参数），使用传统构造函数可能更直接。

## 💻 建造者模式的基本实现

理解了建造者模式的核心概念后，让我们通过实际的代码示例来学习如何实现它。我们将从最完整的实现开始，然后逐步简化到实际开发中常用的版本。

### 基础版本：传统建造者模式

传统的建造者模式包含四个角色：产品、抽象建造者、具体建造者和指挥者。这种实现方式适合需要支持多种建造者变体的场景。让我们先看一个完整的实现：

```cpp
#include <iostream>
#include <string>
#include <map>
#include <memory>

// 产品类：HTTP请求
class HttpRequest {
private:
    std::string url;
    std::string method;
    std::map<std::string, std::string> headers;
    std::string body;
    int timeout;

public:
    HttpRequest(const std::string& u, const std::string& m,
                const std::map<std::string, std::string>& h,
                const std::string& b, int t)
        : url(u), method(m), headers(h), body(b), timeout(t) {}

    void print() const {
        std::cout << "URL: " << url << std::endl;
        std::cout << "Method: " << method << std::endl;
        std::cout << "Headers: ";
        for (constauto& h : headers) {
            std::cout << h.first << ": " << h.second << "; ";
        }
        std::cout << std::endl;
        std::cout << "Body: " << body << std::endl;
        std::cout << "Timeout: " << timeout << "s" << std::endl;
    }
};

// 抽象建造者
class HttpRequestBuilder {
public:
    virtual ~HttpRequestBuilder() = default;
    virtual HttpRequestBuilder& setUrl(const std::string& url) = 0;
    virtual HttpRequestBuilder& setMethod(const std::string& method) = 0;
    virtual HttpRequestBuilder& addHeader(const std::string& key,
                                          const std::string& value) = 0;
    virtual HttpRequestBuilder& setBody(const std::string& body) = 0;
    virtual HttpRequestBuilder& setTimeout(int timeout) = 0;
    virtual std::unique_ptr<HttpRequest> build() = 0;
};

// 具体建造者
class ConcreteHttpRequestBuilder : public HttpRequestBuilder {
private:
    std::string url;
    std::string method = "GET";  // 默认值
    std::map<std::string, std::string> headers;
    std::string body;
    int timeout = 30;  // 默认值

public:
    HttpRequestBuilder& setUrl(const std::string& u) override {
        url = u;
        return *this;
    }

    HttpRequestBuilder& setMethod(const std::string& m) override {
        method = m;
        return *this;
    }

    HttpRequestBuilder& addHeader(const std::string& key,
                                  const std::string& value) override {
        headers[key] = value;
        return *this;
    }

    HttpRequestBuilder& setBody(const std::string& b) override {
        body = b;
        return *this;
    }

    HttpRequestBuilder& setTimeout(int t) override {
        timeout = t;
        return *this;
    }

    std::unique_ptr<HttpRequest> build() override {
        return std::make_unique<HttpRequest>(url, method, headers, body, timeout);
    }
};

// 使用示例
int main() {
    ConcreteHttpRequestBuilder builder;

    auto request = builder
        .setUrl("https://api.example.com/users")
        .setMethod("POST")
        .addHeader("Content-Type", "application/json")
        .addHeader("Authorization", "Bearer token123")
        .setBody(R"({"name": "John", "age": 30})")
        .setTimeout(60)
        .build();

    request->print();
    return 0;
}
```

在这个基础版本中，我们看到了建造者模式的完整结构：

1. **产品类 `HttpRequest`**：包含所有需要设置的属性，通过构造函数接收参数
2. **抽象建造者 `HttpRequestBuilder`**：定义了构建产品的接口，所有方法都是纯虚函数
3. **具体建造者 `ConcreteHttpRequestBuilder`**：实现了抽象接口，维护产品的中间状态，在 `build()` 方法中创建最终产品

这种实现的优点是支持多态，可以有不同的建造者实现。但缺点是代码量较大，如果只需要一种建造方式，就显得有些过度设计了。

### 简化版本：直接实现（推荐）

在实际开发中，如果不需要多个建造者变体，可以直接实现，无需抽象接口。这种方式更简洁，也更符合现代 C++ 的设计理念：

```cpp
#include <iostream>
#include <string>
#include <map>
#include <memory>

// 产品类
class HttpRequest {
    friendclassHttpRequestBuilder;  // 允许建造者访问私有成员

private:
    std::string url;
    std::string method;
    std::map<std::string, std::string> headers;
    std::string body;
    int timeout;

    HttpRequest() = default;  // 私有构造函数

public:
    void print() const {
        std::cout << "URL: " << url << std::endl;
        std::cout << "Method: " << method << std::endl;
        std::cout << "Headers: ";
        for (constauto& h : headers) {
            std::cout << h.first << ": " << h.second << "; ";
        }
        std::cout << std::endl;
        std::cout << "Body: " << body << std::endl;
        std::cout << "Timeout: " << timeout << "s" << std::endl;
    }
};

// 建造者类
class HttpRequestBuilder {
private:
    HttpRequest request;

public:
    HttpRequestBuilder& setUrl(const std::string& url) {
        request.url = url;
        return *this;
    }

    HttpRequestBuilder& setMethod(const std::string& method) {
        request.method = method;
        return *this;
    }

    HttpRequestBuilder& addHeader(const std::string& key,
                                  const std::string& value) {
        request.headers[key] = value;
        return *this;
    }

    HttpRequestBuilder& setBody(const std::string& body) {
        request.body = body;
        return *this;
    }

    HttpRequestBuilder& setTimeout(int timeout) {
        request.timeout = timeout;
        return *this;
    }

    HttpRequest build() {
        // 可以在这里进行验证
        if (request.url.empty()) {
            throw std::runtime_error("URL不能为空");
        }
        if (request.method.empty()) {
            request.method = "GET";  // 设置默认值
        }
        return request;
    }
};

// 使用示例
int main() {
    HttpRequest request = HttpRequestBuilder()
        .setUrl("https://api.example.com/users")
        .setMethod("POST")
        .addHeader("Content-Type", "application/json")
        .addHeader("Authorization", "Bearer token123")
        .setBody(R"({"name": "John"})")
        .setTimeout(60)
        .build();

    request.print();
    return 0;
}
```

这个简化版本的关键改进点：

1. 1. **产品类使用私有构造函数**：通过 `friend` 声明，只允许建造者类创建产品实例，确保产品只能通过建造者构建
2. 2. **建造者直接维护产品对象**：在建造者内部维护一个 `HttpRequest` 对象，逐步设置其属性
3. 3. **流式接口实现**：每个设置方法都返回 `*this`，支持链式调用
4. 4. **参数验证和默认值**：在 `build()` 方法中进行参数验证，并设置合理的默认值

这种实现方式的**优点**：

- • ✅ **代码简洁**：无需抽象接口，代码量减少一半
- • ✅ **流式接口**：代码可读性强，使用体验好
- • ✅ **默认值支持**：可以为可选参数设置合理的默认值
- • ✅ **参数验证**：在 `build()` 中进行集中验证，确保对象有效性
- • ✅ **封装性好**：产品类私有构造函数，确保只能通过建造者创建

这是实际项目中最常用的实现方式，既保持了建造者模式的优势，又避免了过度设计。

## 🔄 建造者模式 vs 工厂模式

建造者模式和工厂模式都是创建型设计模式，但它们解决的问题不同。理解它们的区别有助于我们在实际项目中做出正确的选择。

### 主要区别

| 特性         | 建造者模式                   | 工厂模式                     |
| ------------ | ---------------------------- | ---------------------------- |
| **关注点**   | 复杂对象的逐步构建           | 对象创建的解耦               |
| **构建过程** | 分步骤构建，可以设置多个属性 | 一次性创建对象               |
| **适用场景** | 对象有很多可选参数           | 需要根据条件创建不同类型对象 |
| **灵活性**   | 可以灵活组合参数             | 创建逻辑相对固定             |
| **代码风格** | 流式接口，链式调用           | 方法调用，返回对象           |

### 何时选择建造者模式

- • ✅ 对象有很多可选参数（5 个以上）
- • ✅ 需要逐步构建对象
- • ✅ 需要验证构建参数
- • ✅ 需要设置默认值

### 何时选择工厂模式

- • ✅ 需要根据条件创建不同类型对象
- • ✅ 需要隐藏对象创建细节
- • ✅ 对象创建逻辑复杂但参数不多

### 组合使用

建造者模式和工厂模式可以组合使用，发挥各自的优势。工厂模式负责根据类型创建不同的建造者，建造者模式负责逐步构建对象：

```cpp
// 工厂模式：根据类型创建不同的建造者
class RequestBuilderFactory {
public:
    static std::unique_ptr<HttpRequestBuilder> createBuilder(
            const std::string& type) {
        if (type == "rest") {
            return std::make_unique<RestRequestBuilder>();
        } elseif (type == "graphql") {
            return std::make_unique<GraphQLRequestBuilder>();
        }
        throw std::invalid_argument("未知类型");
    }
};

// 使用
auto builder = RequestBuilderFactory::createBuilder("rest");
auto request = builder->setUrl("...").build();
```

这种组合使用的场景是：需要根据不同的协议类型（REST、GraphQL 等）创建不同的请求构建器，但每种构建器的使用方式相同。工厂模式负责选择正确的建造者类型，建造者模式负责构建具体的请求对象。

## ⚠️ 建造者模式的优缺点

了解建造者模式的优缺点，有助于我们在实际项目中做出正确的设计决策。

### ✅ 优点

1. **参数灵活**：可以灵活设置可选参数，不需要重载多个构造函数。当对象有 5 个以上可选参数时，这种优势尤其明显。
2. **代码可读性**：流式接口让代码更加清晰易读。每个方法调用都清晰地表达了它在设置什么，代码即文档。
3. **参数验证**：可以在 `build()` 方法中进行集中验证，确保对象的有效性。如果参数不合法，可以在构建阶段就发现问题。
4. **默认值**：可以设置合理的默认值，简化常用场景的使用。调用者只需要设置必要的参数，其他参数使用默认值。
5. **构建过程控制**：可以控制对象的构建过程，支持条件构建、分步构建等复杂场景。

### ❌ 缺点

1. **代码量增加**：需要额外的建造者类，增加了代码量。对于简单对象（只有 2-3 个参数），这种开销可能不值得。
2. **对象可变性**：建造过程中对象是可变的，可能不够安全。如果需要在多线程环境中使用，需要额外的同步机制。
3. **性能开销**：链式调用有轻微的性能开销（通常可忽略）。对于性能敏感的场景，可能需要考虑直接使用构造函数。
4. **过度设计**：简单对象不需要建造者模式。如果对象参数少且固定，使用传统构造函数更直接。

## 🎯 何时使用建造者模式

### ✅ 适合使用的场景

1. **复杂对象创建**：对象有很多可选参数（5 个以上）
2. **逐步构建**：需要根据条件逐步设置对象属性
3. **参数验证**：需要在构建时进行参数验证
4. **配置对象**：创建配置对象、设置对象等
5. **不可变对象**：需要构建不可变对象（通过私有构造函数）

### ❌ 不适合使用的场景

1. 1. **简单对象**：对象参数少，直接使用构造函数即可
2. 2. **固定参数**：对象参数固定，不需要灵活组合
3. 3. **性能敏感**：对性能要求极高的场景
4. 4. **过度设计**：不要为了使用模式而使用模式

## 💡 最佳实践建议

### 1. 使用流式接口

```cpp
// ✅ 推荐：流式接口，代码清晰
auto request = HttpRequestBuilder()
    .setUrl("...")
    .setMethod("POST")
    .build();

// ❌ 不推荐：传统方式
HttpRequestBuilder builder;
builder.setUrl("...");
builder.setMethod("POST");
auto request = builder.build();
```

### 2. 在 build() 中进行验证

```cpp
HttpRequest build() {
    if (request.url.empty()) {
        throw std::runtime_error("URL不能为空");
    }
    // 设置默认值
    if (request.method.empty()) {
        request.method = "GET";
    }
    return request;
}
```

### 3. 提供便捷方法

```cpp
// 提供便捷方法，简化常用场景
HttpRequestBuilder& get(const std::string& url) {
    request.url = url;
    request.method = "GET";
    return *this;
}

HttpRequestBuilder& post(const std::string& url, const std::string& body) {
    request.url = url;
    request.method = "POST";
    request.body = body;
    return *this;
}
```

### 4. 使用私有构造函数保护产品类

```cpp
class HttpRequest {
    friend class HttpRequestBuilder;  // 只允许建造者创建

private:
    HttpRequest() = default;  // 私有构造函数

public:
    // 业务方法...
};
```

------

## 🔍 常见问题解答

### Q1: 建造者模式和构造函数有什么区别？

**A**: 构造函数是直接创建对象的方式，而建造者模式封装了构建过程。两者的主要区别在于：

**构造函数方式**：

- • 参数必须一次性提供，无法跳过中间参数
- • 参数过多时，调用代码难以阅读
- • 无法在构建时进行复杂的验证
- • 无法设置合理的默认值（除非使用默认参数，但不够灵活）

**建造者模式**：

- • 可以灵活设置可选参数，按需组合
- • 流式接口让代码可读性更好
- • 可以在 `build()` 中进行集中验证
- • 可以为可选参数设置合理的默认值

总的来说，建造者模式是对构造函数的一种封装和增强，特别适合复杂对象的创建。

### Q2: 什么时候使用建造者模式，什么时候使用工厂模式？

**A**:

- • **建造者模式**：对象有很多可选参数，需要逐步构建
- • **工厂模式**：需要根据条件创建不同类型对象

### Q3: 建造者模式会影响性能吗？

**A**: 建造者模式有轻微的间接调用开销，但在大多数场景下可以忽略。如果性能是瓶颈，可以考虑：

- • 使用内联函数
- • 直接使用构造函数（如果不需要灵活性）

### Q4: 如何确保建造者构建的对象是不可变的？

**A**: 使用私有构造函数和友元类：

```
class Product {
    friend class ProductBuilder;
private:
    Product() = default;  // 私有构造函数
public:
    // 只有getter，没有setter
    const std::string& getName() const { return name; }
};
```

------

## 📝 总结

### 建造者模式的核心价值

建造者模式是一种创建型设计模式，它解决了一个核心问题：**如何优雅地创建包含多个可选参数的复杂对象**。通过将复杂对象的构建过程与表示分离，建造者模式让对象创建变得更加灵活和可读。

通过本文的学习，我们深入探讨了建造者模式的基本实现、流式接口设计，以及在实际项目中的应用场景。**建造者模式结合流式接口，以其优雅的代码风格和灵活的参数设置，成为构建复杂对象的首选方案**。

### 核心要点回顾

1. **核心思想**：将复杂对象的构建过程与表示分离，逐步构建对象
2. **流式接口**：通过返回 `this` 指针实现链式调用，提高代码可读性
3. **适用场景**：对象有很多可选参数、需要逐步构建、需要参数验证
4. **与工厂模式的区别**：
   -  建造者模式：关注复杂对象的逐步构建
   -  工厂模式：关注对象创建的解耦

### 现代 C++最佳实践

```
// 推荐：流式接口 + 参数验证 + 默认值
class HttpRequestBuilder {
private:
    HttpRequest request;
public:
    HttpRequestBuilder& setUrl(const std::string& url) {
        request.url = url;
        return *this;
    }

    HttpRequest build() {
        if (request.url.empty()) {
            throw std::runtime_error("URL不能为空");
        }
        return request;
    }
};
```

### 设计哲学

**建造者模式是工具，不是目的**。它解决的是"复杂对象构建"这个具体问题，而不是为了展示设计能力。在实际开发中：

-  ✅ **该用时就用**：对象有很多可选参数、需要逐步构建的场景
-  ❌ **不该用时不用**：简单对象不需要建造者模式
-  💡 **结合使用**：可以与工厂模式组合使用，发挥各自优势

记住：**好的设计是简单、清晰、易维护的**。建造者模式虽然优雅，但也要根据实际需求选择，避免过度设计。
<!-- markdown for nginx, see https://phus.lu -->
<script>
!function(){
	var dom = {
		element: null,
		get: function (o) {
			var obj = Object.create(this)
			obj.element = (typeof o == "object") ? o : document.createElement(o)
			return obj
		},
		add: function (o) {
			var obj = dom.get(o)
			this.element.appendChild(obj.element)
			return obj
		},
		text: function (t) {
			this.element.appendChild(document.createTextNode(t))
			return this
		},
		attr: function (k, v) {
			this.element.setAttribute(k, v)
			return this
		}
	}

	if (!document.head) return
	head = dom.get(document.head)
	head.add('meta').attr('charset', 'utf-8')
	head.add('meta').attr('name', 'viewport').attr('content', 'width=device-width,initial-scale=1')

	if (!document.body) {
		document.write(["<div class=\"container\">",
		"<h3>nginx.conf</h3>",
		"<textarea rows=6 cols=50>",
		"# download markdown.html to /wwwroot",
		"location ~ \\.md$ {",
		"    default_type text/html;",
		"    add_after_body /markdown.html;",
		"}",
		"</textarea>",
		"</div>"].join("\n"))
		return
	}

	var bodytext = document.body.innerHTML
	document.body.innerHTML = ''

	div = dom.get('div').attr('class', 'container')

	div.add('script').attr('src', 'https://cdnjs.cloudflare.com/ajax/libs/marked/0.5.2/marked.min.js').attr('integrity', 'sha256-zFUosuESzULu5P+SZdjRRtBZR8+1u5RZDlbt3Q5KL8U=').attr('crossorigin', 'anonymous')
	div.add('link').attr('rel', 'stylesheet').attr('href', 'https://cdnjs.cloudflare.com/ajax/libs/github-markdown-css/5.1.0/github-markdown-light.min.css').attr('integrity', 'sha256-WQx0Y6LLZeGv3V3NVVge+YIL5MIOt45RPuFdkyNodls=').attr('crossorigin', 'anonymous')

	title = decodeURIComponent(document.location.pathname.replace(/.*\//, '').replace(/\.html$/, ''))
	document.title = '《' + title.replace(/\.md$/, '') + '》'
	tbody = div.add('table').add('tbody')
	tbody.add('tr').add('th').text(title).attr('class', 'octicon-book')
	tbody.add('tr').add('td').add('div').attr('id', 'readme').attr('class', 'markdown-body')

	wait = function (name, callback) {
		var interval = 10; // ms
		window.setTimeout(function() {
			if (window[name]) {
				callback(window[name])
			} else {
				window.setTimeout(arguments.callee, interval)
			}
		}, interval)
	}
	wait('marked', function() {
		document.getElementById("readme").innerHTML = marked.parse(bodytext)
	})

	document.body.appendChild(div.element)
}()
</script>

<style>
body {
	margin: 0;
	font-family: "ubuntu", "Tahoma", "Microsoft YaHei", Arial, Serif;
}
.markdown-body {
	float: left;
	font-family: "ubuntu", "Tahoma", "Microsoft YaHei", Arial, Serif;
}
.container {
	padding-right: 15px;
	padding-left: 15px;
	margin-right: auto;
	margin-left: auto;
}
@media (min-width: 768px) {
	.container {
		max-width: 80%;
	}
}
@media (min-width: 992px) {
	.container {
		max-width: 70%;
	}
}
@media (min-width: 1200px) {
	.container {
		max-width: 60%;
	}
}
table {
	width: 100%;
	max-width: 100%;
	margin-bottom: 20px;
	border: 1px solid #ddd;
	padding: 0;
	border-collapse: collapse;
}
table th {
	font-size: 14px;
}
table tr {
	border: 1px solid #ddd;
	padding: 5px;
}
table th, table td {
	border: 1px solid #ddd;
	font-size: 14px;
	line-height: 20px;
	padding: 3px;
	text-align: left;
}
.octicon-book {
	background-position: center left;
	background-repeat: no-repeat;
	padding-left: 20px;
	background-image: url("data:image/svg+xml;charset=utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='16' height='16' viewBox='0 0 16 16'%3E%3Cpath d='M3,5 L7,5 L7,6 L3,6 L3,5 L3,5 Z M3,8 L7,8 L7,7 L3,7 L3,8 L3,8 Z M3,10 L7,10 L7,9 L3,9 L3,10 L3,10 Z M14,5 L10,5 L10,6 L14,6 L14,5 L14,5 Z M14,7 L10,7 L10,8 L14,8 L14,7 L14,7 Z M14,9 L10,9 L10,10 L14,10 L14,9 L14,9 Z M16,3 L16,12 C16,12.55 15.55,13 15,13 L9.5,13 L8.5,14 L7.5,13 L2,13 C1.45,13 1,12.55 1,12 L1,3 C1,2.45 1.45,2 2,2 L7.5,2 L8.5,3 L9.5,2 L15,2 C15.55,2 16,2.45 16,3 L16,3 Z M8,3.5 L7.5,3 L2,3 L2,12 L8,12 L8,3.5 L8,3.5 Z M15,3 L9.5,3 L9,3.5 L9,12 L15,12 L15,3 L15,3 Z' /%3E%3C/svg%3E");
}
</style>