blocks|key|340335|text|对于高级模板和技术，我推荐:+Andrei+Alexandrescu的Modern+C%2B%2B+Design|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|340336|C%2B%2B是一种严格的语言，实际上没有运行时内省功能。你会遇到的很多麻烦都可以用模板来解决。此外，模板语言是turing-complete，这使得在编译时生成复杂的数据结构和预先计算值等成为可能。对于许多情况，这可能是更多的麻烦，尽管它是值得的。|340337|entityMap|0|LINK|mutability|MUTABLE|url|https://rads.stackoverflow.com/amzn/click/com/0201704315^0|Z|H|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

For advanced templates and techniques, I recommend: <a href="https://rads.stackoverflow.com/amzn/click/com/0201704315" rel="noreferrer" rel="nofollow noreferrer">Modern C++ Design</a>, by Andrei Alexandrescu

C++ is a rigid language, with practically no runtime introspection capabilities. A lot of the troubles you'll encounter can be dealt with templates. Also, the templating language is turing-complete, making it possible to generate complex data-structures and pre-calculate values at compile-time, among other things.
For many scenarios, it may be more trouble than it's worth it though.

blocks|key|342676|text|当你还有一段时间想要to+play的时候。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|342677|当你需要改进你的算法，并且不想从虚函数调用中获得额外的开销时，你可以用编译时绑定来代替运行时绑定。|342678|entityMap|0|LINK|mutability|MUTABLE|url|http://video.google.com/videoplay?docid=-4728145737208991310&hl=en^0|A|7|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

When you have quite some time left and want <a href="http://video.google.com/videoplay?docid=-4728145737208991310&amp;hl=en" rel="nofollow noreferrer">to play</a>.

When you need to boost your algorithm and don't want overhead from virtual function calls you can replace runtime binding with compile time bindings.

blocks|key|3321166|text|简单的例子：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3321167|template<typename+T>
void
swap(T&+var1,+T&+var2)
{
++T+var3+=+var1;
++var1+=+var2;
++var2+=+var3;
}

int+a+=+2;
int+b+=+3;
swap(a,+b);

float+c+=+400.0f;
float+d+=+500.0f;
swap(c,+d);|code-block|syntax|javascript|3321168|交换两个具有相同类型的变量的值。|3321169|使用模板，我们避免显式地为各种类型组合创建函数，如下所示：|3321170|void
swap(int&+var1,+int&+var2)
{
++int+var3+=+var1;
++var1+=+var2;
++var2+=+var3;
}

void
swap(float&+var1,+float&+var2)
{
++float+var3+=+var1;
++var1+=+var2;
++var2+=+var3;
}|3321171|在我的示例中，如果在代码中的某个地方使用int或float变量调用swap()，则上述函数将由编译器自动创建。|offset|length|style|BOLD|3321172|entityMap^0|0|0|0|0|0|K|3|O|5|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|Z|8|@$O|10|P|11|Q|R]|$O|12|P|13|Q|R]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|T|$]]

Simple example:

<pre><code>template&lt;typename T&gt;
void
swap(T&amp; var1, T&amp; var2)
{
 T var3 = var1;
 var1 = var2;
 var2 = var3;
}

int a = 2;
int b = 3;
swap(a, b);

float c = 400.0f;
float d = 500.0f;
swap(c, d);
</code></pre>

swap the values of 2 variables that have the same type.

With Templates we avoid to explicity create functions for various type combinations like these:

<pre><code>void
swap(int&amp; var1, int&amp; var2)
{
 int var3 = var1;
 var1 = var2;
 var2 = var3;
}

void
swap(float&amp; var1, float&amp; var2)
{
 float var3 = var1;
 var1 = var2;
 var2 = var3;
}
</code></pre>

The above functions will be created automatically by the compiler, in my example, if swap() is called somewhere in the code with int, or float, variables.

blocks|key|339209|text|我认为，如果你不是库开发人员，那么最好忘记模板元编程。我相信，它在生产代码中是无用的，它给出了更多的问题，然后带来了好处：“一旦你开始使用它，那么你就会失去与这个解决方案捆绑在一起的灵活性。在你开始使用它之后，很难摆脱模板沸腾的代码。这是一个问题，因为模板不够灵活。”|type|unstyled|depth|inlineStyleRanges|entityRanges|data|339210|附注:当然，我不是指模板容器，交换，...但是Alexandrescu类代码|339211|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

I think, if you are not library developer, then it is better to forget about template metaprogramming. I beleive, that it is useless in production code, giving more problems, then benefits: "Once you started to use it, then you loose flexibility being tied to this solution. It is very hard to come away from template-boiled code after you started to use it. And this is a problem, as templates are not flexible enough".

P.S. Of course I don't mean template containers, swaps, ... but Alexandrescu-like code

blocks|key|337871|text|C%2B%2B模板元编程是一种强大的代码混淆技术，适用于一系列应用程序：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|337872|337873|当您想要编写团队中其他任何人都无法理解的代码时，您想要的代码在编写7天后就无法理解|unordered-list-item|337874|当代码性能对您来说比maintainability|337875|When更重要时，您希望能够在简历中将“模板元编程”列为一项技能。|337876|当您需要编写不太可能在许多实际编译器上运行的代码时|337877|如果您宁愿使用刀片而不是使用预处理器宏|337878|<+code+>F213|337879|另一种情况：|337880|337881|如果你想知道Boost库在幕后是如何工作的，或者你想为它们做贡献。|337882|337883|“泛型编程”(比如STL容器、auto_ptrs等)和“模板元编程”(使用模板系统让编译器有效地“运行算法”)之间的区别是很重要的。|337884|我完全赞成前者，但发现很难看到后者在现实世界中的好处。|337885|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|12|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|13|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|14|8|@]|9|@]|A|$]]|$1|H|3|I|5|E|7|15|8|@]|9|@]|A|$]]|$1|J|3|K|5|E|7|16|8|@]|9|@]|A|$]]|$1|L|3|M|5|E|7|17|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|18|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|19|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|S|3|T|5|E|7|1B|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]|$1|V|3|W|5|6|7|1D|8|@]|9|@]|A|$]]|$1|X|3|Y|5|6|7|1E|8|@]|9|@]|A|$]]|$1|Z|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]]|10|$]]

C++ Template metaprogramming is a powerful code obfuscating technique that's applicable to a range of applications:

<ul>
<li>When you want to write code that nobody else on your team can understand</li>
<li>When you want code that you won't be able to understand 7 days after you wrote it</li>
<li>When code performance is more important to you than maintainability</li>
<li>When you want to be able to list "Template Metaprogramming" as a skill on your resumé.</li>
<li>When you need to write code that's unlikely to work on many real-world compilers</li>
<li>If you'd rather eat razor blades than use preprocessor macros </li>
</ul>

One other case: 

<ul>
<li>If you want to you know how the Boost libraries work under the hood, or you want to contribute to them.</li>
</ul>

The distinction between "generic programming" (think STL containers, auto_ptrs etc), which is what C++ templates were designed to accomplish and "template metaprogramming" (use of the template system to get the compiler to effectively "run algorithms" for you) is important.

I'm all in favour of the first, but find it hard to see real-world benefits from the latter.

blocks|key|340435|text|元编程是一个非常奇特的话题。了解它很有趣，它是一个强大的工具，有时您可能会发现它很有用。但它永远不会是你工具箱中最常用的工具。有时，您可能希望代码作用于一系列具有不同属性的无关类型，这就是元编程的用武之地。使用一些技巧，您可以编写一个重载的函数，只有当参数类型是整型的，或者如果它是一个指针，或者如果它是X，Y或Z类型(可能忽略Z的常量)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|340436|它本质上是使用类型进行编程。通常，你的程序可以做一些事情，比如取两个数字并产生第三个数字，或者告诉你一个数字是否满足某些要求。元编程可以接受两个类型并生成第三个类型，或者告诉您一个类型是否满足某些要求。是的，它可能在库开发中最有用。但话又说回来，大多数代码都可以被认为是库代码。您可以说main()函数之外的所有内容都是库代码。|340437|通常，如果您想通过元编程来解决问题，您可能希望使用相关的boost库来完成繁重的工作。当然，Boost.TypeTraits和Boost.Mpl确实可以为您简化工作。但这不是你需要知道的，也不是你经常需要的。|340438|泛型编程是相关的(在某些情况下，可能会在幕后使用元编程来变得真正的泛型，例如，标准库使用元编程将原始指针转换为有效的迭代器，这是“迭代器”概念成为泛型所必需的)，但并非完全相同。而且它得到了更广泛的应用。|340439|每次实例化std::vector时，都会使用泛型编程。每次使用一对迭代器来处理一系列值时，都会使用泛型编程。泛型编程就是这样一种想法，即你的代码应该尽可能的泛型，并且无论放入什么类型的代码都应该工作。vector不需要包含的类型来实现"ICanBeContained“接口(还记得Java是如何要求所有东西都从Object派生出来才能存储在容器类中的吗？这意味着原始类型被装箱，我们失去了类型安全性。这不是通用的，这是一个毫无意义的限制。)|offset|length|style|CODE|340440|使用迭代器遍历序列的代码是通用的，可以使用任何类型的迭代器，甚至可以使用普通指针。|340441|泛型编程非常有用，并且通常可以在很大程度上取代OOP。(请参见上面的示例。如果我可以避免这种限制，为什么我要编写一个需要包含的类型来实现接口的容器？)|340442|通常，当您在OOP中使用接口时，不允许在运行时更改类型(当然，这种情况也时有发生)，而是允许您在编译时交换另一个类型(可能在测试期间注入模拟对象，而不是使用完整的实现)，或者只是解耦两个类。泛型编程可以做到这一点，而不需要您做乏味的定义和维护接口的工作。在这些情况下，泛型编程意味着您必须编写和维护更少的代码，并且可以获得更好的性能和更好的类型安全性。所以，是的，你绝对应该熟悉泛型编程。C%2B%2B不是一种很好的OOP语言。如果您想严格使用OOP，您应该切换到Java或另一种更多OOP固定的语言。C%2B%2B允许您编写OO代码，但它通常不是最好的解决方案。这就是为什么几乎整个标准库都依赖于泛型编程而不是OOP的原因。标准库中几乎没有继承或多态性。他们不需要它，没有它，代码变得更容易使用和更强大。|340443|为了回答你的其他问题，是的，泛型编程几乎是一个独立的范例。模板元编程不是。它是操纵类型系统的一种相当特殊的技术，并且非常擅长解决少数问题。要被认为是一个范例，我认为它必须是更普遍的有用的，你可以使用的方法，基本上所有的东西，像函数式，面向对象或泛型编程。|340444|我认为xtofl确实做到了这一点:泛型编程就是让你的代码不知道类型。(+std::vector不关心，也不需要知道它存储的是什么类型。它就能正常工作。)|340445|另一方面，元编程是关于类型计算的。给定类型T0和T1，我们可以定义一个类型T2，就像我们可以定义一个整数N0和N1一样，我们可以定义一个N2，它是N0和N1的和。|340446|Boost.Mpl库有一个很明显的例子。在普通代码中，如果有整数N0、N1和N2，则可以创建包含这三个值的std::vector。然后，我可以使用其他算法来计算索引，然后提取存储在向量中该位置的值。|340447|给定T0、T1和T2类型，我们可以创建包含这三种类型的mpl::vector。现在，我可以使用其他算法在编译时计算索引，并提取存储在向量中该位置的类型。|340448|entityMap^0|0|0|0|0|5|B|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|15|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|16|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|17|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|18|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|19|8|@$J|1A|K|1B|L|M]]|9|@]|A|$]]|$1|N|3|O|5|6|7|1C|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|1D|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|1E|8|@]|9|@]|A|$]]|$1|T|3|U|5|6|7|1F|8|@]|9|@]|A|$]]|$1|V|3|W|5|6|7|1G|8|@]|9|@]|A|$]]|$1|X|3|Y|5|6|7|1H|8|@]|9|@]|A|$]]|$1|Z|3|10|5|6|7|1I|8|@]|9|@]|A|$]]|$1|11|3|12|5|6|7|1J|8|@]|9|@]|A|$]]|$1|13|3|-4|5|6|7|1K|8|@]|9|@]|A|$]]]|14|$]]

Metaprogramming is a pretty exotic topic. It's interesting to learn about, it's a powerful tool, and occasionally you might find it useful. But it'll never be the most often used tool in your toolbox. Sometimes, you might want your code to act on a range of unrelated types with different properties, and that's where metaprogramming comes in. With a bit of trickery, you can write an overload of a function that is only available if the argument type is integral, or if it is a pointer, or if it is either type X, Y, or Z (perhaps ignoring constness on Z).

It is essentially programming with types. Normally, your program can do things like take two numbers and produce a third number, or tell you whether a number satisfies some requirement. Metaprogramming can take two types and produce a third type, or tell you whether a type satisfies some requirement. And yes, it is probably mostly useful in library development. But then again, most code could be considered library code. You could say that everything outside your main() function is library code.

Usually, if you want to solve a problem through metaprogramming, you'll probably want to use the relevant boost libraries to do the heavy lifting. Boost.TypeTraits and of course Boost.Mpl can really simplify things for you. But it's not something you need to know, and it's not something you're likely to need very often.

Generic programming is related (and may in some cases use metaprogramming under the hood to become really generic, for example the standard library uses a touch of metaprogramming to turn raw pointers into valid iterators which is required for the "iterator" concept to be generic), but not entirely the same. And it is much more widely used.

Every time you instantiate a <code>std::vector</code>, you use generic programming. Every time you use a pair of iterators to process a sequence of values, you use generic programming. Generic programming is just the idea that your code should be as generic as possible, and should work regardless of what types are put into it. A std::vector doesn't require the contained type to implement a "ICanBeContained" interface (remember how Java requires everything to be derived from Object in order for it to be stored in a container class? Which means primitive types get boxed, and that we lose type safety. That's not generic, and it's a pointless restriction.)

The code to iterate over a sequence using iterators is generic, and works with any type of iterators, or even with plain pointers.

Generic programming is very widely useful, and can often to a large extent replace OOP. (see the above example. Why would I write a container that required the contained types to implement an interface, if I can avoid that limitation?)

Often, when you use interfaces in OOP, it is not to allow the type to change during runtime (although of course that happens from time to time too), but to allow you to swap in another type at compile-time (perhaps injecting a mock object during tests, rather than using the full-fledged implementation), or just to decouple two classes. Generic programming can do that, without having you do the tedious work of defining and maintaining the interface. In those cases, generic programming means you have to write and maintain less code, and you get better performance and better type-safety. So yes, you should definitely feel at home with generic programming. C++ isn't a very good OOP language. If you want to stick strictly with OOP, you should switch to Java or another more more OOP-fixated language. C++ allows you to write OO code, but it's often not the best solution. There's a reason why almost the entire standard library relies on generic programming, rather than OOP. There is very little inheritance or polymorphism in the standard library. They didn't need it, and the code became simpler to use and more powerful without it.

And to answer your other questions, yes, Generic programming is pretty much a separate paradigm. Template metaprogramming is not. It is a fairly specific technique for manipulating the type system, and is very good at solving a small number of problems. To be considered a paradigm, I think it'd have to be much more generally useful, and approach you can use for basically everything, like functional, OO or generic programming.

I think xtofl really nailed it: Generic programming is about making your code type-unaware. (A std::vector doesn't care, or need to know what type is stored in it. It just works.)

Metaprogramming on the other hand, is about type computations. Given type T0 and T1, we can define a type T2, just like how we can, given integers N0 and N1, we can define a N2 that is the sum of N0 and N1.

The Boost.Mpl library has an obvious example of this.
In your normal code, if you have the integers N0, N1 and N2, you can create a std::vector containing these three values. I can then use some other algorithm to compute an index, and then extract the value stored at that location in the vector.

Given types T0, T1 and T2, we can create a mpl::vector containing these three types.
I can now use some other algorithm to compute an index at compile-time, and extract the type stored at that location in the vector.

blocks|key|339267|text|你真的需要区分泛型编程(有点不知道类型)和元编程，元编程是在类型系统中进行计算的一种完全合法的方式。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|339268|当你在很多代码中发现一个可泛化的模式时，泛型编程是非常有用的。如果模式中的差异不仅在于变量值，还在于不同的类型，那么泛型编程对于重构代码很有用。|339269|元编程适用于完全不同的领域。这个领域确实很新，需要你自己去探索一下。这也很有趣！|339270|一个非常有用且常见的元编程模式是特征/策略概念。|339271|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

You really have to differentiate between generic programming (which is kinda type-unaware) and metaprogramming, which is a perfectly legal way to do calculations within the type system.

Generic programming is very useful when you find a generalizable pattern in a lot of code. If the difference in the pattern lies not only in variable values, but also in different types, generic programming is useful to refactor the code.

Metaprogramming is applicable in a totally different domain. That domain is, indeed, quite new, and needs some exploring of your own. It is fun, too! 

One very useful, and common, metaprogramming pattern is the Traits/Policy concept.

blocks|key|3321314|text|在以下情况下：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3321315|模板元编程是一种编写由编译器解释的程序的方法。它是更高一层的抽象。你可以用它做各种奇怪和时髦的事情。boost库包含许多示例：|3321316|3321317|不喜欢c%2B%2B是静态类型的？使用boost::any。|unordered-list-item|3321318|喜欢λ微积分，但你必须c%2B%2B吗？使用boost:lambda。|3321319|有EBNF，需要解析器吗？使用boost::spirit。|3321320|3321321|原因：|3321322|这很酷。你可以给你的约会对象留下深刻印象(也许)。|3321323|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|U|8|@]|9|@]|A|$]]|$1|E|3|F|5|G|7|V|8|@]|9|@]|A|$]]|$1|H|3|I|5|G|7|W|8|@]|9|@]|A|$]]|$1|J|3|K|5|G|7|X|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|R|$]]

When:

Template meta programming is a way of writing programs which are interpreted by the compiler. It is one level of abstraction higher. You can do all kinds of weird and funky stuff with it. The boost libraries contain many examples: 

<ul>
<li>Don't like it that c++ is statically typed? Use boost::any. </li>
<li>Love lambda calculus, but must you c++? Use boost:lambda. </li>
<li>Have an EBNF and need a parser? Use boost::spirit. </li>
</ul>

Why:

It's cool. You can impress your dates (maybe).

blocks|key|337983|text|一个尚未给出的答案是:尽管泛型编程和元编程确实是彼此完全不同的技术，但它们都是为了解决(本质上)相同的问题:如何摆脱样板。这些也体现在软件工程原则的两个缩写词中：DRY+(don't+repeat+yourself)+and+DIE+(duplication+is+evil)。这是Occam's+Razor的现代重新表述，即“实体不能超出必要性的倍增”(entia+non+sunt+multiplicanda+)。谁知道14世纪的逻辑学家能提出对21世纪软件设计有用的东西呢？|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|337984|无论如何，这两种技术的重点都是找到将“几乎相同”的代码统一到单个参数化代码中的方法。在元编程的情况下，您将使用代码生成，因此该技术涉及到将通用代码(也称为模板，或者更一般的代码生成函数)专门化到特定的情况。在泛型编程的情况下，您尝试使用类型系统来识别不同的代码片段是“相同的”，然后使用基于类型的分派进行专门化。|337985|事实证明，这两种技术甚至可以一起使用来做一些相当奇特的事情。有关这方面的示例，请参阅Multi-stage+programming+with+functors+and+monads:+eliminating+abstraction+overhead+from+generic+code。但如果你觉得STL很可怕，最好不要看它...|337986|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Don%2527t_repeat_yourself|1|http://en.wikipedia.org/wiki/Occam%2527s_Razor|2|http://www.cas.mcmaster.ca/~carette/metamonads/^0|29|1L|0|3X|D|1|0|0|16|2S|2|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@$A|U|B|V|1|W]|$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|11|8|@]|9|@$A|12|B|13|1|14]]|C|$]]|$1|H|3|-4|5|6|7|15|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]|P|$5|K|L|M|C|$N|Q]]|R|$5|K|L|M|C|$N|S]]]]

One answer which has not yet been given: although generic programming and meta-programming are indeed quite different techniques from each other, they were both designed to solve (essentially) the same problem: how to get rid of boilerplate. These are also embodied into not just one but two acronyms of software engineering principles: <a href="http://en.wikipedia.org/wiki/Don%27t_repeat_yourself" rel="nofollow noreferrer">DRY (don't repeat yourself) and DIE (duplication is evil)</a>. This is a modern-day rephrasing of <a href="http://en.wikipedia.org/wiki/Occam%27s_Razor" rel="nofollow noreferrer">Occam's Razor</a>, ie that "entities must not be multiplied beyond necessity" (entia non sunt multiplicanda praeter necessitatem). [Who knew that 14th century logicians could come up with something useful for 21rst century software design?].

Anyways, the point of both techniques is to find ways to unify codes which are 'almost the same' into a single piece of parametrized code. In the meta-programming case, you are using code generation so the technique involves specializing a general piece of code (aka a template, or more generally a code-generating-function) to a specific case. In the generic programming case, you try to use the type system to recognize that various pieces of code are 'the same' and then use type-based dispatch for the specialization.

It turns out that these two techniques can even be used together to do rather fancy things. See <a href="http://www.cas.mcmaster.ca/~carette/metamonads/" rel="nofollow noreferrer">Multi-stage programming with functors and monads: eliminating abstraction overhead from generic code</a> for an example of this. But if you think that the STL is scary, better not look at it...

IMHO to me OOPS, design patterns make sense and i have been able to apply them practically.

But when it comes to "generic programming /meta programming" of the Modern C++ kind, i am left confused.

-- Is it a new programming/design paradigm ?

-- Is it just limited to "library development"? If not, What design/coding situations call for using meta programming/generic programming.

-- Does using templates mean i am doing generic programming?

I have googled a lot on this topic but do not grasp the BIG PICTURE fully.
Also see this <a href="http://discuss.fogcreek.com/joelonsoftware/default.asp?cmd=show&amp;ixPost=85900" rel="nofollow noreferrer">post</a>.

<hr>

After reading dicussions here under, up till now, I am sure ( might still not be correct):

a) Generic programming and meta programming are two different concepts.

When/Why ( if ever ) should i think about doing Generic Programming/Meta Programming

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

对我来说，设计模式是有意义的，我已经能够实际地应用它们了。但是，当谈到现代C++类型的"generic programming /meta programming"时，我感到困惑。--它是一种新的编程/设计范式吗？--是否仅限于“库开发”？如果不是，什么设计/编码情况需要使用元编程/泛型编程。--使用模板是否意味着我在...

问什么时候/为什么(如果有的话)我应该考虑做泛型编程/元编程
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问什么时候/为什么(如果有的话)我应该考虑做泛型编程/元编程EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问什么时候/为什么(如果有的话)我应该考虑做泛型编程/元编程
EN