++ constructs such as functions, types, variables, and blocks are associated with implicit properties that you sometimes need to override. Certain constructs require you to specify their unusual properties, for example:
- A function that never returns
- A type with a particular alignment restriction
- A virtual function that must not be overridden
Attributes, a new C++09 feature, are compile-time tokens that enable you to designate properties like these. By using attributes, you can specify additional information about your programming constructs conveniently and portably. This 10-Minute Solution shows how to apply this technique.

You need to tell the compiler and your fellow programmers how to use a certain component, but you don't want to use nonstandard features or risk inadvertent usage violations.

Use C++09 attributes.
final, Finally
Before the advent of C++09, ensuring that clients could not override a certain virtual function any further was a struggle. Consider the following example:
struct B
{
virtual void f (); //do not override this!
};
struct D : B {
void f(); //overriding B::f, uncaught by the compiler
};
The author of class B made her intentions clear: Any class derived from B must not override f(). Still, an innocent user who derived D from Bmistakenly violated this requirement. A standard C++ compiler cannot detect this violation because all public virtual functions can be overridden by default.
C++09 attributes tackle this problem. An attribute is a token enclosed between double square brackets, for example [[myattribute]]. C++09 defines several attribute tokens, which you need to understand aren't reserved keywords. To indicate that a virtual function must not be overridden any further, you need to appertain the attribute [[final]]to the last permitted override of that function:
struct B //C++09 only
{
virtual void f [[final]] ();//can't override f() any further!
};
struct D : B {
void f(); // compilation error: attempt to override B::f
};
The [[final]] attribute applies to class definitions and to virtual member functions declared in a class definition. If the [[final]] attribute is specified for a class definition, it's equivalent to being specified for each virtual member function of that class, including inherited member functions. The following declaration of class A...
struct A [[final]] //C++09 only
{
virtual void f();
virtual void g();
virtual void h();
};
...is equivalent to:
struct A //C++09 only
{
virtual void f [[final]] ();
virtual void g [[final]] ();
virtual void h [[final]] ();
};