how to use function as literal string in C or C++ macro

Question

I posted a similar question yesterday, the site suggested to post a new question with better explanations.

There are two macros:

#define COMPANY L"Test Company"
#define PRODUCT COMPANY L" in Canada"

The result of PRODUCT will be "Test Company in Canada".

Now, we have the following requirements:

1. make the COMPANY to be "dynamic" string, to call a function to return a company name, e.g . #define COMPANY getCompanyName()
2. we are not allowed to change the other code to reference the COMPANY, such as #define PRODUCT COMPANY L" in Canada", since there are so many macros in the code

The issue with change: The result of PRODUCT will be "Test Company", lost the part " in Canada" literal.

Here is the code:

#include <stdio.h>
#include <tchar.h>
const wchar_t* getCompanyName() { return L"Test Company";};
#define COMPANY getCompanyName();
#define PRODUCT COMPANY L" in Canada"

int _tmain(int argc, _TCHAR* argv[])
{

const wchar_t * company = COMPANY; // get Test Company
const wchar_t * product = PRODUCT; // get Test Company in Canada

wprintf(company);
wprintf(product);


return 0;
} 

Answer 1

You PRODUCT macro expands in

getCompanyName(); L" in Canada"

so

const wchar_t * product = getCompanyName(); L" in Canada";
wprintf(product);

prints

Test Company

as expected.

In C++ we tend to:

• avoid macros (use inline functions instead)
• avoid naked pointers (prefer STL facilities)

So, In C++ we prefer:

inline const std::wstring getCompanyName() { return L"Test Company";}
inline const std::wstring PRODUCT() { return getCompanyName() + L" in Canada";}

Answer 2

It's a nasty hack, but it's actually possible. Define COMPANY to an expression, that starts with a literal, ends with a literal and can be implicitly converted to a const wchar_t *:

#define COMPANY L"" + getCompanyName() + L""

Of course the getCompanyName() must not return const wchar_t *, because operator+ is not defined for two pointers and it would work on addresses and not strings anyway.

You basically need as std::wstring, but you probably need it to be convertible to const wchar_t *, which std::wstring is not. So you'd have to define your own class:

struct AutoConvertibleString {
    std::string s;
    AutoConvertibleString(const std::string &s) : s(s) {}
    // C++ optimization for move:
    // AutoConvertibleString(std::string s) : s(std::move(s)) {}
    operator const wchar_t *() { return s.c_str(); }
};
AutoConvertibleString operator+(const wchar_t *l, const AutoConvertibleString &r) {
    return (l + r.s).c_str();
}
AutoConvertibleString operator+(const AutoConvertibleString &l, const wchar_t *r) {
    return (l.s + r).c_str();
}
// Ok, the operator+s could be optimized to use move for temporaries too...

AutoConvertibleString getCompanyName() { /* ... whatever ... */ }

It's an ugly hack. It would really be better to convert all of them to functions. But it should work.