吐槽一下c++

另外一个可能有点卵用的写法:
http://www.open-std.org/jtc1/sc2 ... s/2016/p0195r2.html

Airtnp 发表于 2019-5-21 17:34
这个其实就是std::variant... https://en.cppreference.com/w/cpp/utility/variant/variant

是说TypeList像std::variant么.. 我觉得完全不是一回事啊，首先那一堆做类型推导的meta functions和variant一点关系没有，你拿variant过来是没法使用std::is_constructible进行过滤以及条件性给出编译时错误的。

std::variant本质上就是一个功能有限的tagged union，顶多是ForEach那边“看起来有点像”搭配std::variant使用的std::visit —— 但也有很大的区别，因为std::visit是要拿对应类型的instance来dispatch的，而我们这里是根据运行时一个string的值（也就是"name"参数）进行dispatch，这个相关机制必须手写：要么用TypeList这个比较强大的工具，要么手写一个template recursive function。

当然这只是我的理解，如果你有什么巧妙的想法不妨试着实现一下，如果只是引用一两个概念别人可能没有办法理解你的方案，而且去实现一下自己才能知道是否行得通。

magicsets 发表于 2019-5-21 16:36
第一个问题要带类型检查的话其实非常麻烦，因为需要在编译期做很多事情，我写了一份参考代码，测试环境用的 ...

多谢大佬解答问题！
代码有些复杂，我要研究一下

magicsets 发表于 2019-5-22 00:10
是说TypeList像std::variant么.. 我觉得完全不是一回事啊，首先那一堆做类型推导的meta functions和varia ...

https://wandbox.org/permlink/soNyHbuhPkiz9nJg

我傻了。。。因为visit也是用笛卡尔积实现的

写了三种

Airtnp 发表于 2019-5-22 13:55
https://wandbox.org/permlink/soNyHbuhPkiz9nJg

我傻了。。。因为visit也是用笛卡尔积实现的

写得不错~ 其实可以看出来能work的还是只有第一种编译时枚举的方法

第二种方法（使用typeinfo）没有办法做隐式类型转换，而且想要把general的隐式类型转换在runtime做应该也是不可能的

第三种方法要求所有的create()具有不同的signature，这个方法甚至都没有使用name变量.. instantiate错了也是不能检查出来的

最近也在巩固C++，感觉东西真的挺多的。看着看着就有点晕了

根据下面的网址改编：

1. /// [url]https://stackoverflow.com/a/29154449[/url]
   
2. /// [url]https://wandbox.org/permlink/wghDJw5xbDHVZ52x[/url]
   
3. 
   
4. #include <iostream>
   
5. #include <memory>
   
6. #include <stdexcept>
   
7. #include <string>
   
8. #include <unordered_map>
   
9. #include <utility>
   
10. 
    
11. #include <gtest/gtest.h>
    
12. 
    
13. using namespace std::string_literals;
    
14. 
    
15. struct Base {
    
16.     virtual ~Base() = 0;
    
17. };
    
18. 
    
19. Base::~Base() {}
    
20. 
    
21. template <typename... Args>
    
22. class Factory {
    
23. public:
    
24.     static Factory& get()
    
25.     {
    
26.         static Factory instance;
    
27.         return instance;
    
28.     }
    
29. 
    
30.     template <typename T>
    
31.     void reg(const std::string& name)
    
32.     {
    
33.         auto it = stock.find(name);
    
34.         if (it != stock.end()) {
    
35.             throw std::invalid_argument(name + " has been registered: " + __PRETTY_FUNCTION__);
    
36.         }
    
37.         stock[name].reset(new Creator<T>);
    
38.     }
    
39. 
    
40.     std::unique_ptr<Base> create(const std::string& name, Args&&... args)
    
41.     {
    
42.         auto it = stock.find(name);
    
43.         if (it == stock.end()) {
    
44.             throw std::invalid_argument("Cannot find "s + __PRETTY_FUNCTION__);
    
45.             // std::cout << "Cannot find " << __PRETTY_FUNCTION__ << '\n';
    
46.             // return nullptr;
    
47.         }
    
48.         std::cout << __PRETTY_FUNCTION__ << '\n';
    
49.         return it->second->create(std::forward<Args>(args)...);
    
50.     }
    
51. 
    
52. private:
    
53.     struct ICreator {
    
54.         virtual std::unique_ptr<Base> create(Args&&...) = 0;
    
55.         virtual ~ICreator() = default;
    
56.     };
    
57. 
    
58.     template <typename T>
    
59.     struct Creator : public ICreator {
    
60.         virtual std::unique_ptr<Base> create(Args&&... args) override
    
61.         {
    
62.             return std::make_unique<T>(std::forward<Args>(args)...);
    
63.         }
    
64.     };
    
65. 
    
66.     std::unordered_map<std::string, std::unique_ptr<ICreator>> stock;
    
67. };
    
68. 
    
69. template <typename... Args>
    
70. std::unique_ptr<Base> create(const std::string& name, Args&&... args)
    
71. {
    
72.     return Factory<Args...>::get().create(name, std::forward<Args>(args)...);
    
73. }
    
74. 
    
75. template <typename T, typename... Args>
    
76. class Register {
    
77. public:
    
78.     explicit Register(const std::string& name)
    
79.     {
    
80.         Factory<Args...>::get().template reg<T>(name);
    
81.     }
    
82. };
    
83. 
    
84. struct A : public Base {
    
85.     inline static const Register<A, int> r1{"a"};
    
86.     inline static const Register<A, int, const std::string&> r2{"a"};
    
87.     inline static const Register<A, int, std::string&> r3{"a"};
    
88.     inline static const Register<A, int, std::string> r4{"a"};
    
89.     inline static const Register<A, int, const char*&> r5{"a"};
    
90. 
    
91.     explicit A(int a)
    
92.     {
    
93.         std::cout << "Creating A(" << a << ")\n";
    
94.     }
    
95. 
    
96.     A(int a, const std::string& s)
    
97.     {
    
98.         std::cout << "Creating A(" << a << ", " << s << ")\n";
    
99.     }
    
100. };
     
101. 
     
102. struct B : public Base {
     
103.     inline static const Register<B> r{"b"};
     
104.     // inline static Register<B> r2{"b"}; // abort at compile time
     
105.     B()
     
106.     {
     
107.         std::cout << "Creating B()\n";
     
108.     }
     
109. };
     
110. 
     
111. TEST(Factory, Simple)
     
112. {
     
113.     ASSERT_TRUE(create("a", 1));
     
114.     ASSERT_TRUE(create("b"));
     
115. }
     
116. 
     
117. TEST(Factory, String)
     
118. {
     
119.     ASSERT_TRUE(create("a", 2, "hi"s));  // Args = {int, std::string}
     
120. }
     
121. 
     
122. TEST(Factory, StringLvalue)
     
123. {
     
124.     std::string s = "hi";
     
125.     ASSERT_TRUE(create("a", 3, s));  // Args = {int, std::string&}
     
126. }
     
127. 
     
128. TEST(Factory, ConstStringLvalue)
     
129. {
     
130.     const std::string s = "hi";
     
131.     ASSERT_TRUE(create("a", 4, s));  // Args = {int, const std::string&}
     
132. }
     
133. 
     
134. TEST(Factory, ConstCharPtr)
     
135. {
     
136.     const char* s = "hi";
     
137.     ASSERT_TRUE(create("a", 5, s));  // Args = {int, const char*&}
     
138. }
     
139. 
     
140. TEST(Factory, CharArray)
     
141. {
     
142.     // Cannot find std::unique_ptr<Base> Factory<Args>::create(const string&, Args&& ...)
     
143.     // [with Args = {int, const char (&)[3]}]
     
144.     ASSERT_THROW(create("a", 6, "hi"), std::invalid_argument);  // runtime error
     
145. 
     
146.     ASSERT_TRUE((create<int, std::string>("a", 7, "hi")));
     
147. }
     
148. 
     
149. TEST(Factory, InvalidParams)
     
150. {
     
151.     ASSERT_THROW(create("b", 1), std::invalid_argument);  // runtime error
     
152. }
     
153. 
     
154. int main(int argc, char** argv)
     
155. {
     
156.     ::testing::InitGoogleTest(&argc, argv);
     
157.     return RUN_ALL_TESTS();
     
158. }
     

复制代码

你这个需求是违背工厂模式的初衷的。如果不同的子类需要不同的初始化参数，那就用另一个函数来初始化，不要在构造函数里

所以我写Java了....

cai_lw 发表于 2019-6-16 08:13
你这个需求是违背工厂模式的初衷的。如果不同的子类需要不同的初始化参数，那就用另一个函数来初始化，不要 ...

工厂模式的初衷是什么，为什么这么做就违反了工厂模式的初衷了