Boost logo

Boost :

From: Bronek Kozicki (brok_at_[hidden])
Date: 2006-07-04 15:41:09

Peter Dimov wrote:
>>> The compiler cannot check that the right tag is used since
>>> information is added to the exception at runtime, so you're still
>>> vulnerable to typos. That means you would still have to either put
>>> the tags
>> you only declare them; and if you used different name than declared,
>> compiler will catch that error.
> No, it will not, unless I'm misunderstanding something. You either have
> coupling and static checking, or you have no coupling and no static
> checking; strings or tags make no difference. A tag is just a compile-time
> string.

Tag is a type name recognized by compiler; you can declare it as many times
and in as many locations as you wish. Important point about tag is that you
have to declare it before you use it; compiler will enforce it. On the other
hand, string is a literal; there is nothing compiler could check for you.
Obviously, it means that while tags come with some coupling (although minimal
- there is no need for "unified system" or "central location"), strings
require no coupling at all. While this might sound like an advantage, I
believe that it's not - strings (used as literals) are extremely prone to
programming mistakes (like all literals). Obviously, there is simple cure:
replace literal with single definition eg. macro or global const variable. But
this solution comes at the cost, as you suddenly need two names: one for macro
(or variable) and other for actual string. You also need guarantee that the
later one is unique, and compiler will not help you with this. Tags do not
have this problem - there is just one name, and language provides pretty good
means (namespaces, nested types etc.) to help you make that name unique. The
other problem with string is that you need its definition. Simplest solution
for these problems is to keep all all string definitions in a single location
- but that brings strong coupling. To sum it up : strings are prone to
mistakes and there is no good cure for it; on the other hand, tags bring some
(rather weak) coupling and that's it. Of you want, you can introduce
requirement that tag type has to be fully defined at the point of use -
compiler will provide more warranties (more difficult to define mispelled tag)
and coupling will be still weaker that strings used as macros or variables (no
need for central location to warranty uniqneness if you have sane design).

I'm have experience with similar system, my colleagues are still figthing with
problems introduced by literals used as identifiers, and we have not found
good way to solve them so far. Compiler provides too few checks, and
infrastructure to maintain uniqueness is too complex (and centralized).


Boost list run by bdawes at, gregod at, cpdaniel at, john at