Inherting Primitive Data Types in C++

Hi,
The previous answers show that your approach is improper to your problem. Use a private member to control your value, for instance:

struct Variance
{
    Variance(long double var) : _var(std::abs(var))
    {}
    operator long double ()
    {
        return _var;
    }
    Variance& operator = (const long double& var)
    {
        _var = std::abs(var);
        return *this;
    }
private:
    long double _var;
};

With operator long double () there is no need to override all possible operators.
cheers,
AR

Unfortunately, you're not inheriting a primitive type but writing a wrapper around it.
I only faced with true inheritance of primitive types in Ada language, and that approach is brilliant! (There are different declarations type and subtype; with types, implicit conversion does not compile.)

Back to C++ and your wrapper, you really need to combine all arithmetic operations between wrappers and also between wrappers and primitive numeric type. (Is that you mentioned by messy? There is no other way). Which comes to the question: what's the added functionality? Is this is just constraints, I used different approach.

A while ago I developed architecture of Meta-data Engine (MDE), we developed implementation with the team (in C++), as well as commercial software product using the engine. One of the goal was to replace many boring data classes with meta-models of them, which created the routine data structures authomatically. One small part of the Engine was the support of data Domains on meta² level, and Domains specified primitive types including constrains (such as Multiplicity which is a constraint for Cardinality).

You see, when you wrap your double data type, you mix-up its valued (data, meta⁰-data) with meta¹-data, such as constraint. You could go away from this if you create universal data structures (for example, unlimited number of string, integer, boolean, enumeration and floating-point properties). The structure content and rules are controlled by meta¹-data (property names, descriptions, references to domains, and, back to the point, constraints). Every data structure meta⁰-data instance keep the reference to its meta¹-data type. Universal rule for operation on universal data structures make use of constraints.

—SA

If you want to have a separate class to represent a non-negative double that you can use anywhere you want, you'll have to create a class, override those operators, and watch out for casting. I'm not sure there is any simpler way to do it.

If this variance value is itself a member of only one or two other classes and not used independently like a class or struct, then I would consider just using a double (or other appropriate numeric type) and controlling access to it through functions that validate the value.