Throw an exception when the parameters of a constructor are of the wrong type

Question

I want to build a class that throws an exception if the parameter list is of the wrong type,

For example this class: in the header

class rectangle
{
public:
    rectangle(int, int);
    int getarea();
private:
    int length;
    int width;

};

in cpp

rectangle::rectangle(int l, int w)
{
    if (l!=int|| w!=int)
        throw string("Exception found!");
    length=l;
    width=w;        
}

I want the constructor to throw an exception if it is called in the following ways in the main program:

rectangle rec1(3.5, 4);
rectangle rec1(a, 5);

because 3.5 and a are not of type int. How can I check if the argument of the constructor is of the desired type?

No need as your program will not compile if you pass non-int parameters to the constructor of `rectangle` — Richard Critten, Aug 03 '19 at 09:43
There's no way to check the original type with that code at runtime. You'll need a template and compile time checks. — πάντα ῥεῖ, Aug 03 '19 at 09:45
Inside the constructors the parameters will *always* be `int`. — Jesper Juhl, Aug 03 '19 at 09:46
The program does implicit type casting if a non-int parameter is passed to the constructor, I want it to throw an exception instead — Dave, Aug 03 '19 at 09:46
@Dave As mentioned, use a template, and let it not passing at compile time. A runtime exception doesn't make any sense. — πάντα ῥεῖ, Aug 03 '19 at 09:48
Instantiate rectangle like this: `rectangle rec1{3.5, 4};` and it will give you a compiler error on narrowing conversions. — Michael Mahn, Aug 03 '19 at 09:50

score 2 · Answer 1 · answered Aug 03 '19 at 10:59

I want to build a class that throws an exception if the parameter list is of the wrong type,

You probably don't want that because then it would be too late to do anything about it.

For strings (and most other types) the program won't even compile but for float, double, char, short, long and long long (and their unsigned versions) there are built-in conversions to int and if you want to make sure that your program won't even compile unless ints are used, you could make a template out of your constructor:

#include <type_traits>

class rectangle {
public:
    template<typename T, typename U = std::enable_if_t<std::is_same_v<int, T>, T>>
    rectangle(T l, T w) : length(l), width(w) {}

    int getarea() const { return length * width; }

private:
    int length;
    int width;
};

... but the linked duplicate solves it so much more elegantly. I'll leave my answer up as an alternative but for your specific problem I think the linked dup serves you better. — Ted Lyngmo, Aug 04 '19 at 21:31

score 0 · Answer 2 · answered Aug 03 '19 at 10:01

In c/c++ if you have a method with an

int

parameter then the value of this parameter will definitely be a natural number between

-2,147,483,648 and 2,147,483,647

on x86 and x64 architecture.

It will never be a float, a string, false or something else.

You might want to check if it is < 0 as it is a length in your example.

You could also change it to

unsigned int

Then the variable will be between

0 and 4,294,967,295

Throw an exception when the parameters of a constructor are of the wrong type

2 Answers2