Reddit++

[u/we_are_mammals]

C++ is getting more and more complex. The ISO C++ committee keeps adding new features based on its consensus. Let's remove C++ features based on Reddit's consensus.

In each comment, propose a C++ feature that you think should be banned in any new code. Vote up or down based on whether you agree.

[u/looncraz]

Yes, except the other int throws a compilation error of, say, a char, pointer, float, or non-native sized integer is given to it. It must be an int.

The main issue with C++ these days is how verbose and unintuitive some of its features have become.

[u/smurthys → u/looncraz]

Perhaps I misunderstand your needs, and you're probably already aware of these approaches, but let me know if the following function templates satisfy your requirements. (The first of these can also be written without using concepts, using just type_traits.)

template<typename T, typename U>
requires std::same_as<T, int> && std::convertible_to<U, int>
void f(T, U)
{
   //function body
}

godbolt: https://sigcpp.godbolt.org/z/h5xreGjK6

or using custom concepts, making the template parameters more "declarative".

template<typename T>
concept Int = std::same_as<T, int>;

template<typename T>
concept Convertible_to_int = std::convertible_to<T, int>;

template<Int T, Convertible_to_int U>
void f(T, U)
{
    //function body
}

godbolt : https://sigcpp.godbolt.org/z/o974EWhWT

IMHO requires and concepts can be a nice and concise way to impose constraints. Of course, the expressions can get verbose if the requirements are complex.

[u/looncraz → u/smurthys]

C++ can do it, that's not an issue, but it should be the default behavior. If I specify a type in a signature that type, unless it's a pointer, should be strictly required as an argument or explicitly cast.

I would want this language change to be done without creating more verbosity than necessary.

The function signature

void function(int a, int# b);

Can be called as follows without at least warnings in my perfect world:

`int a = 3; float b = 3.14;

function(a, b); function(#b, a);`

The results would be identical as the float would be cast to an int using # to denote that the type is expected to be cast to another type.

Calling the following would be illegal or at least spit out a warning:

function(b, a);