C++11 Function That Only Accepts String Literals?

Question

I want to write a C++11 function that will only accept string literals as a parameter:

 void f(const char* s) { static_assert(s is a string literal); ... }

That is:

 f("foo"); // OK

 char c = ...;
 f(&c); // ERROR: Doesn't compile

 string s = ...;
 f(s.c_str()); // ERROR: Doesn't compile

 etc

Is there anyway to implement this? The signature of the function is open to changes, as is adding the use of macros or any other language feature.

If this is not possible what is the closest approximation? (Can user-defined literals help in anyway?)

If not is there a platform specific way in GCC 4.7 / Linux ?

Answer 1

I think the closest you are going to get is this

template<int N>
void f(const char (&str)[N]){
  ...
}

It will compile with literals and arrays but not pointers.

Answer 2

An alternative might be to make a GCC extension to check at compile time that your particular function is only called with a literal string.

You could use MELT to extend GCC. MELT is a high-level domain specific language to extend the GCC compiler, and is very well suited for the kind of check you want.

Basically, you would add a new pass inside GCC and code that pass in MELT which would find every gimple which is a call to your function and check that the argument is indeed a literal string. The ex06 example on melt-examples should inspire you. Then subscribe to [email protected] and ask your MELT specific questions there.

^{Of course, this is not a foolproof approach: the function could be called indirectly thru pointers, and it could e.g. have a partial literal string, e.g. f("hello world I am here"+(i%4)) is conceptually a call with some literal string (e.g. in .rodata segment), but not in the generated code nor in the gimple.}