Template metaprogramming is for those who enjoy using a pure, non-strict, functional programming language, with pattern matching within C . If there is anything truly worth in the language that's the completely serendipitous emergence of this important idiom to the point of it being a core practice for lots of really useful and advanced code. One thing that is currently missing is having the opportunity to seamlessly define strings as types in situ within a template parameter list as a language feature.
I have been using various personal implementations in my own code for this, though I think that it is such a fundamental construct it should also exist in stand-alone mode. This is a fast compile-time wise, single-header, no-dependencies, standard-compliant C library offering a seamless way to enjoy compile time strings defined in situ, as individual, distinct types.
typedef typestring_is("Hello!") test; /* irqus::typestring<'H','e','l','l','o','!'> */
An example of use for understanding the meaning of in-situ:
#include "typestring.hh"
#include <type_traits>
#include <iostream>
int main() {
// notice that there is no const value, you need to define, constexpr,
// static etc because it *just works*
std::cout << std::boolalpha
<< std::is_same< typestring_is("C ")
, irqus::typestring<'C',' ',' '> >::value
<< std::endl;
return {};
}
Applications of such a feature would be in the field of template metaprogramming generating code for parsers, type-safe printf, compile-time DSL embedding. Lots of other things I could discuss in proper time, but it is a strictly template metaprogramming oriented functionality.
The library is just a few lines but it includes extensive documentation as to its internal mechanics. Function template instantiations with multiple parameter packs are used together with a hexadecimal integer sequence through the preprocessor for accessing any string defined in situ. The hexadecimal arithmetic progression is generated extremely fast because concatenation is wired in such a way as to work like multiplication. The reason of such internals is because we want to be able to use string literals in situ, as type parameter types without defining them externally to the template parameter list.
If you don't realize what this is for, by now, then it is probably not meant for
you. At some point, perhaps the language does get some decent language features
doing such stuff in one go; the way this works is actually much faster than
expected given the few lines of implementation in typestring.hh
. You cannot
implement in-situ literal use in C 14 either through polymorphic lambdas, without
resorting to defining the values involved out of the template parameter list when
using the final construct. The reason is that they are not constexpr yet
(though they will eventually be for such a use). And if you do use any form of
such externally to the parameter list during instantiation values, you are really
not doing the same thing. Remember ... linkage and unevaluated operands will bite
you! But not typestring_is
literals.
You only need to include the file typestring.hh
in your code, after which, you
will be able to use typestring_is
easily for any kind of char
encoded string
you fancy, including ASCII art. The default maximum length of the strings
allowed is 64, but you can use any power of 2
within 0
(1) to 10
(1024)
by enabling -DUSE_TYPESTRING=<power of 2>
prior to compilation. The actual
procedure behind creating these compile-time strings as types for a template
parameter list allows for far greater numbers, but you will just segfault your
compiler, regardless of what instantiation depth you specify.
- Will work with standard C 11, C 14 and above as it is, no dependencies involved at all.
- Completely independent of compile-time constexpr metaprogramming string literals; you have individual strings as individual types to use as type parameters for use in type-driven code generation, not playing with values.
- Has been tested with
clang
andg
, use as recent versions as possible forC 11/C 14
compliance. - A few handy member functions have been added in
typestring
should you need to play with it outside its intended use. - Code could be made to do far more, but the fundamental construct is what matters, I have another project for such things.
- Always remember to have fun first and foremost.
- License is Mozilla Public Licence 2.0 because it suits all metaprogramming best.