Welcome to Software Development on Codidact!
Will you help us build our independent community of developers helping developers? We're small and trying to grow. We welcome questions about all aspects of software development, from design to code to QA and more. Got questions? Got answers? Got code you'd like someone to review? Please join us.
Macro to verify that an expression has no side effects at compile time
I'd like to implement a macro strnul():
#define strnul(s) (s + strlen(s))
But that expands and evaluates s twice. I'd like to avoid that.
I could do (using GNU extensions)
#define strnul(s) \
({ \
auto s_ = s; \
s_ + strlen(s_);\
})
However, this adds some other problem: a local variable named s_.
This local variable must have a name different from whatever users of this function may pass as argument, as otherwise we'd have auto s_ = s_;, which can't work.
But I have reasons to pass an argument called s_, so I'd like to find a way to entirely avoid the variable. If possible, an alternative would be to do
#define strnul(s) \
({ \
static_assert(!has_side_effects(s)); \
s + strlen(s); \
})
Is it possible to somehow do this in C? Even if the solution would require using compiler extensions, I'd be interested in finding a solution.
1 answer
A function is the obvious solution since it only comes with one evaluation per argument before the function is called.
If the only rationale for using macros over functions is to avoid casts, then just make the macro a wrapper macro for the function calls, similar to how a C standard lib will have to implement QVoid and QChar fictional types in C23.
Assuming we do not allow implicit void pointer conversions (for the same reason as we don't allow casts - type safety), then:
#include <string.h>
char* strnul (char* s)
{
return (s + strlen(s));
}
const char* strnulc (const char* s)
{
return (s + strlen(s));
}
#define strnul(s) \
_Generic((s), \
char*: strnul, \
const char*: strnulc)(s)
If void pointers should be allowed then simply add void*: strnul to _Generic (and one for const void* too). The implicit conversion to char* also means we can do standard-compliant pointer arithmetic even if we started out with void*.
Full code with some test examples:
#include <string.h>
#include <stdio.h>
char* strnul (char* s)
{
return (s + strlen(s));
}
const char* strnulc (const char* s)
{
return (s + strlen(s));
}
#define strnul(s) \
_Generic((s), \
char*: strnul, \
const char*: strnulc)(s)
int main()
{
char str[] = "hello";
const char* strc = str;
printf("Pos: %td\n", strnul(str) - str);
printf("Pos: %td\n", strnul(strc) - strc);
printf("Pos: %td\n", strnul(str+2) - str);
}
1 comment thread