Printable View
So when I first read about template metaprogramming I said. "Humm, this is interesting!" But the more I read about it, the more it seems a that most of its functionallity could be replaced with a iterative for loop and a command to the compiler"unroll loops". Beyond that, its uses seem pretty trivial.
Am I missing something here? Is this like Bayes theorem where you REALLY have to get it before you see the uses for it?
erm, absolutely not. loops are runtime code. templates are compile time structures.Quote:
most of its functionallity could be replaced with a iterative for loop and a command to the computer "unroll loops"
the point of templates are that they allow you generalize patterns and algorithms for different types without having to recode them individually or rely on less-safe and flexibile techniques like downcasting.
Boost includes a library to facilitate metaprogramming, and along with it they provide a very good introductory tutorial (at least I thought so when I read it). I don't actually pretend to understand how it all works, but I think you should give it a read.
http://www.boost.org/doc/libs/1_37_0...functions.html
O_oQuote:
So when I first read about template metaprogramming I said. "Humm, this is interesting!" But the more I read about it, the more it seems a that most of its functionallity could be replaced with a iterative for loop and a command to the computer "unroll loops". Beyond that, its uses seem pretty trivial.
What garbage have you been reading?
Yes. Meta-programing, of any sort, isn't about saving a few cycles during execution. Meta-programming is about making a tool do the job of a programmer. It is about generation. The result of the application of meta-programming, the expansion, may save a few cycles during execution, but the same performance could have been had by manually writing the source in the first place.Quote:
Am I missing something here?
Soma
Im really sorry, slip of the keyboard. I ment to say compiler rather then computer. I know that GCC supports a loop unrolling optimization which seems to eliminate much of the use for metaprogramming.Quote:
Originally Posted by m37h0d
I thought about complex recursion being another case where it could come in handy, but by that point the fact still remains that you have to have a specific target for it to work, Most of the complex uses for recursion, that I know of, would be pretty useless if they where purely static (IE tree traversing).
I guess what I am saying, is that I haven't seen any good examples of metaprograming online. The only examples that seem to be present are factorials and Fibonacci numbers.
nope. computer/compiler - it doesn't matter. loops are for the processing of data at runtime.
templates and metastructures are compile time structures. loops perform operations on data that has been allocated once the program is running. templates can determine both what data gets allocated, and how to deal with it.
loops and templates are in no way equivalent; there's a conceptual disconnect.
i am hardly a metaprogramming guru, but i did recently implement a rather nice (imho) metastructure.
consider this:
http://cboard.cprogramming.com/showthread.php?t=111075
you could use a typelist metaobject structure like the kind i'm toying with there to represent a database table without having to recode structs for each table in the schema. you could just use a typelist to create a structure that encapsulates the columns of the table.
this isn't the only way to go about doing it, but it is arguably a good one.
fibbonacci numbers and factorials are fundamentally NOT suited for templates - not in the slightest. they only use 1 datatype: integers.
there is no purpose whatsoever to using a template for an algorithm that inherently uses only 1 datatype.
the more classic example is a generalized functor.
do you want to have to code different functors for each function signature? that is so cumbersome as to make the use of functors impractical. however, with typelists and a functor metaobject, they become elegant, robust, and convenient.
Fibonacci is not suited for template metaprogramming, because you usually need the the first portion of the series series, not a single element to the series, so you might as well use a loop. But there are uses for metaprogramming that does not involve different datatypes, or type parameters.Quote:
Originally Posted by m37h0d
For example, You can use templates to implement as a lookup table for complex expressions that can be computed compile time, that the compiler is not otherwise smart enough to optimize, and without requiring the programmer to manually do the calculation himself.
An ideal example would be a hash function. Metaprogramming can be used to create a hash of a sequence of characters like a password, that can be used to verify the password, but not retrieve it. Unfortunately, the syntax for this is atrocious, since the sequence of character cannot be written as a literal string.
Re: fibonacci - aah, yes, i suppose so. i recall seeing that example now.
I realized that part had a major typo, but I hope the negatives later in the sentence made it clear that I actually meant not suited. The OP is correct that that example is not the best application, though it does demonstrate the principle.
We use template meta programming for a very useful purpose at work. We often have constants defined for the minimum and maximum values a given field can take. Previously we also had a seperate constant for the maximum string length of the maximum constant. This was used in limiting an edit box to a fixed number of characters. However over time, sometimes the maximum was changed, but the number of characters was not. E.g. a certain field might have once allowed values up to 50000, but was later restricted to just 4000, and the constant for the string length was left at 5.
We now have a template meta-programming function surrounded by a macro such you can replace MAX_FIELD_LENGTH with CONSTANT_DIGITS(MAX_FIELD_VALUE) and now, never again can the constants become out of sync.
Other useful things are some template meta-programming to tell you at compile time if a number is prime or not. combined with a compile-time assert, you get the ability to change the chosen prime between versions, with the safety in knowing that it will never compile with a non-prime.
I've also needed to calculate the log base b of a number n at compile time, where n and b are provided template parameters affecting the maximum size and memory/speed tradeoff values.
Trust me, it has it's uses in the real world.
Anything that is iterative or recursive and has a know start compile-time value can be optimized with template meta programming... It will cut the whole thing out from runtime with a hard-coded constant by the compiler. Easily a good example, albeit a small one. Log, exp, etc are good algorithms that work well with it, provided you do have a known value at compile time.
I was also reading expressions templates. They look a lot like tmp actually, and has a huge advantage.
The resulting code can actually be faster than hand-coded C that uses callbacks.
http://ubiety.uwaterloo.ca/~tveldhui.../exprtmpl.html
It sure does demonstrate the power of template and template programming techniques.
Also, calculating things at compile time is just one aspect of template metaprogramming.
For example, consider something like the BOOST_FOREACH macro (thankfully it will be replaced with a built-in construct). There is actually a lot of type-deducing going on underneath to support all the iterable types: C style strings, arrays and classes having a begin() and end() method.
Code:#include <iostream>
#include <vector>
#include <boost/foreach.hpp>
int main()
{
char* str = "Hello!";
int arr[] = { 1, 2, 3, 4, 5 };
std::vector<int> vec(3, 42);
BOOST_FOREACH( char c, str ) {
std::cout << c << ' '; //H e l l o !
}
std::cout << '\n';
BOOST_FOREACH( int n, arr ) {
std::cout << n << ' '; //1 2 3 4 5
}
std::cout << '\n';
BOOST_FOREACH( int n, vec ) {
std::cout << n << ' '; //42 42 42
}
std::cout << '\n';
/*
doesn't compile:
int* p = arr;
BOOST_FOREACH( int n, p ) {
std::cout << n << ' ';
}
*/
}
per this thread, i just optimized my spectrum classes to be template<unsigned int width>spectrum instead of allocating a new array of doubles off the heap.
now i dont' have do to size-checking on all my arithmetic and assignment operators. compile-time errors ftw!
So, if I'm getting this correct. The best use for template metaprogramming is when you have some value in your program, you know will be static, and you know can be completed in some time (not an infinite loop). Basically, template metaprogramming will get that value for you, doing all the processing at compile time and then just do something to the effect of a quick mov call.
Correct? So the main use is in a situation where, perhaps you need to know constant value but all you have is the formula and the data to get the value. And since the data changes frequent enough, a template of the formula will do the calculation for you.
Off the top of my head, I don't know where I would use this, but I guess it is probably pretty useful, especially in complex calculations.
False.Quote:
The best use for template metaprogramming is when you have some value in your program, you know will be static, and you know can be completed in some time (not an infinite loop).
False.Quote:
So the main use is in a situation where, perhaps you need to know constant value but all you have is the formula and the data to get the value.
Paraphrasing my own earlier comments: meta-programming is about generation.
That isn't the best use; that is the only use.
You can use meta-programming to:
generate a value by applying some algorithms to other values.
generate multiple values by applying some algorithms to other values.
generate an operation by sequencing other operations.
generate an operation by nesting other operations.
generate multiple operations by expanding a meta-program with several target operations.
generate an algorithm by sequencing operations or other algorithms.
generate an algorithm by nesting operations or other algorithms.
generate multiple algorithms by expanding a meta-program with several target algorithms.
generate the meta-programs that generate all of these things.
...
generate the meta-programs that generate the meta-programs that generate the meta-programs that...
You get the point?
You aren't wrong to say that it can generate a value. You can generate the value. You can also generate the formula that generates the value. You can generate the type that stores the value. You can generate the types that the formula operates on during expansion. You can choose between formulas. You can decide if any formula should be expanded.
Soma
this is relevant to my interests. can you provide an example?Quote:
generate an operation by sequencing other operations.
generate an operation by nesting other operations.
generate multiple operations by expanding a meta-program with several target operations.
O_oQuote:
can you provide an example?
You know, I don't do a lot of "work for hire". My confidence, eclectic approach, and refusal to use any standard other than my own good judgment gives me an apparent arrogance that isn't really attractive. When I am contracted I'm often asked to solve template implementation issues that only exist because no one bothered to specify how the expansion should behave in the first place. I usually find myself asking "How would you like it to behave?".
The moral of the story: you need to be more specific.
-_-
Not that I could do the area justice with a few simple examples. If you really want to learn, you'll have to do the work.
If for whatever reason you don't already own "C++ Template Metaprogramming: Concepts, Tools, and Techniques from Boost and Beyond" you should buy it immediately. If you already own it, read chapter three for a good approach to representing arbitrary operations, nested operations, sequential operations, the values that these operators operate on, and the types that represent those values with abstract types as generated by meta-programs. (It also provides an introduction to expression templates.) Until you do own it, you my read the relevant portion "http://www.boost.org/doc/libs/1_37_0/libs/mpl/doc/tutorial/tutorial-metafunctions.html".
After you feel familiar with the ideas you can grab 'Blitz++' to see how the ideas have been used as a building block for expressive mathematics that generate incredible efficient source. (You don't look at the source. You look at the interface and the output, but you figure out how they did it for yourself.)
When you've understood that take a look at 'Boost::Spirit' for an extraordinary application of the same idea as applied to entity processing and generation.
When you've understood that take a look at 'Boost::Spirit::Phoenix'. I've seen people describe it as the ultimate application of the same very simple ideas. It isn't. It is extremely good. I think penultimate would be fair.
Soma
And when you've done that, look at Boost.Proto, which is the next evolutionary step of expression template programming.
ok after some thought on it, i think i get it.
one example might be if you had a matrix template class of arbitrary dimensions, an operation on a higher order matrix would/could recurse through the operators of the lower orders down to simple row/column operations.
Or at the very least a step in the right direction.Quote:
And when you've done that, look at Boost.Proto, which is the next evolutionary step of expression template programming.
Soma
>>When you've understood that take a look at 'Boost::Spirit::Phoenix'. I've seen people describe
>>it as the ultimate application of the same very simple ideas. It isn't. It is extremely good. I think
>>penultimate would be fair.
Unless Boost.Proto or something else succeeded Phoenix, maybe just superior.
Coming from a recent edition. The entomology makes it seem like it would fit but that is history only I think. In terms of style (and depending on what you were writing about) it might describe one of the last great things a person did, but clearly not the final one.Quote:
Originally Posted by The Concise Oxford English Dictionary
I'm being a dick, true, but it's just an excuse to define one of my favorite words.
So if soma thinks there's one more step that can be taken with (the ideas behind) phoenix, then wouldn't he be right? (Not that I would presume to put words in his mouth.)Quote:
Originally Posted by whiteflags
*shrug* In my opinion, there is a better word for that. Given the literal definition the "ultimate step" should have been achieved already for the description to be definite.
penultimate means second to last...what is the hubbub about now? :-?
Well if Soma knows what the ultimate application of template metaprogramming is, we will all learn something new.
O_oQuote:
The entomology makes it seem like it would fit but that is history only I think.
You confuse 'entomology' for 'etymology', begin a sentence with "In my opinion", and yet harp on my style?
Cute.
As I've taken pains to explain, meta-programming has only one purpose: generation.Quote:
Well if Soma knows what the ultimate application of template metaprogramming is, we will all learn something new.
The statement regarded the ideas so gloriously presented by 'Boost::Spirit::Phoenix'.
Also, nowhere did I restrict the statement to meta-programming as it pertains to C++ templates. The concepts are extremely valuable in many languages.
As for the choice of "penultimate", I simply find it the most appropriate word to describe the implementation. 'Boost::Spirit::Phoenix' has a few problems. If it didn't have those problems, I would have simply said ultimate.
Soma