CODEWITHSUNDEEP
c++c++11boosttype-safety
user2891462
user2891462

Reputation: 3333

Enforce type safety in C++ without using extra classes

I am somewhat familiar with type safety, and have used it successfully before in methods which receive several parameters of the same type (bool) to avoid confusion. For example:

// Old version of the method
void sendPackage(bool sendImmediately, bool dividePacket);

// Type safe version
enum SendImmediatelyPreference
{
    SEND_IMMEDIATELY,
    DO_NOT_SEND_IMMEDIATELY
};

enum PacketDivisionPreference
{
    DIVIDE_PACKET,
    DO_NOT_DIVIDE_PACKET
};

void sendPackage(
    SendImmediateltPreference immediatePref,
    PacketDivisionPreference divisionPref);

So the cryptic sendPackage(true, false) becomes sendPackage(SEND_IMMEDIATELY, DO_NOT_DIVIDE_PACKET).

The problem is that this is only an option for bool. I have a method that accepts several std::vector<std::string> and I'd like to minimise the posibility of the user inputting the arguments in the wrong order.

I can think of creating different classes which contains an std::vector<std::string> and either override tons of the std::vector methods or expose the internal vector.

Is there an easier way, some sort of typedef which enforces type safety? Using boost would be okay.

Upvotes: 3

Views: 687

Answers (5)

StackedCrooked
StackedCrooked

Reputation: 35485

I like to bundle the parameters in a config class or struct. For example:

struct SendOptions
{
    bool send_immediately = false;
    bool divide_packet = false;
    // ...
};

void sendPackage(SendOptions options);

This has the additional advantage the extra options can be added later without needing to change the interface of sendPackage(SendOptions).

This does not increase type safety but it does help to prevent errors (especially if there are a lot of parameters), which is probably the goal you're trying to achieve.

Upvotes: 0

user2891462
user2891462

Reputation: 3333

BOOST_STRONG_TYPEDEF is precisely a typedef which enforces type safety.

However, this answer provides some caveats related to using this strong typedef for just a function, and argues that the types should be used all over the code to prevent unnecessary castings.

Upvotes: 0

Mitchell Kline
Mitchell Kline

Reputation: 383

How about an alternative approach using named parameters? There are several ways of going about this in C++ described here. The tag approach using a tuple looks reasonable. There is also boost parameter.

This doesn't offer strong type safety, but you could argue that the user is just as likely to call the wrong constructor to make their type safe object as they are to use the wrong tag when calling your function. This situation is less likely to occur if the types are used throughout your application vs defined only for one particular function.

See also the discussion of boost strong typedef vs parameter for a similar purpose here.

Upvotes: 2

eti_nne
eti_nne

Reputation: 126

What about creating a class that inherits (public) from std::vector to have a strong typecheck. The advantage is that you only need to rewrite constructors..

You can also regroup your parameters in a std::unordered_map>, to implement argument as a dict (like in python, or javascript)

Upvotes: 0

Hardwired
Hardwired

Reputation: 834

Not sure I understood you correctly, but maybe this can help:

enum SendImmediatelyPreference : bool  // allows only 2 options:
{
  DO_NOT_SEND_IMMEDIATELY,  // false
  SEND_IMMEDIATELY          // true
}

Upvotes: 0

Related Questions