Question

Besides the global scope, of course.

---

I have a custom assertion class with a macro to cache a reference to __FILE__:

#define DEFINE_THIS_FILE \
  static const char THIS_FILE__[] = __FILE__

For source code, using the macro is no big deal since each source has its own scope. However, templated classes can’t use source code, so I’m forced to do all my ASSERT() calls in the declaration/definition given by TemplateClass.h

If I use my macro outside of the class definition e.g. Singleton

DEFINE_THIS_FILE;

namespace NE
{
  template<typename T>
  class Singleton
  {
    ...
  }
}

Then the macro winds up in the same scope of any code that #includes Singleton, and the compiler throws a redefinition error for THIS_FILE__. (Of course, this only happens if the other code also uses the DEFINE_THIS_FILE macro.)

If I put the macro inside the declaration, the compiler won’t complain but the linker won’t be able to find THIS_FILE__ for any given instance of templated class e.g. Singleton:

namespace NE
{
  template<typename T>
  class Singleton
  {
    constexpr DEFINE_THIS_FILE;     // constexpr modifier required in this case
    ...
  }
}

I assume the linker error I get,
Undefined symbols for architecture x86_64:
"NE::Singleton<NE::NonTemplateType>::THIS_FILE__"
is caused by the template instances not existing in the same scope as where THIS_FILE__ was first defined, Singleton.h

---

OT: Is there a way to get all instances of my templated type Singleton to share a scope (global is unacceptable) so that all instances can use this static const macro?

---

Edit1
Further testing confirms: Using the macro DEFINE_THIS_FILE inside each templated method containing an ASSERT() will compile and run correctly….
In this case, the instances aren’t sharing a scope, but have a static const char THIS_FILE__ defined for each method. This works, but I suspect that it uses as much or more ROM than a std::assert (with its its implied allocation of __FILE__).

I’ll settle for this until an answer to OT comes about 🙂

---

Edit2
Silly me. Instead of using the workaround listed in edit above, I might as well create another macro, UNCACHED_ASSERT(argsToCheck) that directly uses __FILE__ instead of a const static representation.
Multiple ASSERTions per method could still benefit from the caching, though.

Still need an answer to OT, though.

Answer 1

You can place your declaration in unnamed namespace

#define DEFINE_THIS_FILE namespace { static const char THIS_FILE__[] = __FILE__; }