Static_assert in function declaration

Question

I have a pretty simple function using static_assert. The trouble is that I want static_assertabout the behavior associated with declaring a function, in particular, indicating the type of return. There seems to be no room for interference static_assertso that I can run it before the compiler can not infer the return type.

So far, I have been returning the type of output and the static statement in the structure. This will launch this statement, which is fine, but it will still generate an error in outputting a type that is the noise I want to eliminate.

#include <type_traits>
#include <functional>
#include <memory>
#include <map>
#include <iostream>
#include <string>
#include <cstdio>
#include <tuple>
#include <sstream>
#include <vector>
#include <algorithm>

template<typename T, typename X> struct is_addable {
    template<typename Test, typename Test2> static char test(decltype(*static_cast<Test*>(nullptr) + *static_cast<Test2*>(nullptr))*);
    template<typename Test, typename Test2> static int test(...);
    static const bool value = std::is_same<char, decltype(test<T, X>(nullptr))>::value;
};
template<typename T, typename X> struct is_addable_fail {
    static const bool value = is_addable<T, X>::value;
    static_assert(value, "Must be addable!");
    typedef decltype(*static_cast<T*>(nullptr) + *static_cast<X*>(nullptr)) lvalue_type;
};

template<typename T1, typename T2> auto Add(T1&& t1, T2&& t2) -> typename is_addable_fail<T1, T2>::lvalue_type {
    return std::forward<T1>(t1) + std::forward<T2>(t2);
}

struct f {};

int main() {
    std::cout << Add(std::string("Hello"), std::string(" world!"));
    Add(f(), f());
}

Answer 1

- , SFINAE. , , , , .

:

• .
• , (SFINAE)
• , .

, assert ?

, SFINAE, , ( ).

Answer 2

, SFINAE :

template<typename T = int> void Add(...) {
    static_assert(sizeof(T) == 0, "Must be addable!");
}

template<typename T1, typename T2> auto Add(T1&& t1, T2&& t2) ->
  decltype(std::forward<T1>(t1) + std::forward<T2>(t2)) {
    return std::forward<T1>(t1) + std::forward<T2>(t2);
}

ideone. , Add .

EDIT: , , ? ( ideone)

template<typename T1, typename T2> void Add(T1 volatile&&, T2 volatile&&) {
    static_assert(sizeof(T1) == 0, "Must be addable!");
}