Шаблоны в с++

template < typename T >
T Sum(T a, T b) {
    return a + b;
}
 
int main(int argc, char *argv[])
{
    setlocale(0, "");
 
    cout << Sum<int>(2, 2) << endl;
 
    system("pause");
    return 0;
}

int main(int argc, char *argv[])
{
    setlocale(0, "");
 
    cout << Sum(2, 2) << endl;
 
    system("pause");
    return 0;
}

cout << Sum<float>(2, 2) << endl;

Sum(2, 2.0)

#include <iostream>
 
//-std=c++14 -fopenmp -O2 -g3 -pedantic -Wall -Weffc++ -Wextra 
//-Woverloaded-virtual -Wctor-dtor-privacy -Wnon-virtual-dtor 
//-Wold-style-cast -Wconversion -Wsign-conversion -Winit-self 
//-Wunreachable-code
 
 
template<class T1, class T2>
auto Sum(T1&& a, T2&& b)
{
    using re = typename std::common_type<T1,T2>::type;
    return static_cast<re>(a) + static_cast<re>(b);
}
 
int main()
{
    
    std::cout << "result = " << Sum(2, 2.0) << std::endl;
    
}

#include <iostream>
 
struct LargeObject
{
    int n;
    LargeObject operator + (const LargeObject& f)
    {
        n += f.n;
        return *this;
    }
};
 
template <typename T>
auto sum(T a, T b) {
    typename std::remove_reference<T>::type result;
    result = (a + b);
    return result;
}
 
int main()
{
    LargeObject l1, l2;
    l1.n = 500;
    l2.n = 600;
    std::cout << (sum<LargeObject&>(l1, l2)).n << '\n';
    std::cout << sum(5, 5) << std::endl;
}

#include <iostream>
 
struct LargeObject
{
    int n;
    LargeObject operator + (const LargeObject& f)const
    {
        LargeObject obj(*this);
        obj.n += f.n;
        return obj;
    }
};
 
 
// аргументы не обязаны быть одного типа
// складывать можно любые
// лишь бы они умели друг с дружкой складываться
template <typename T1, typename T2>
// google: Идеальная передача и универсальные ссылки в C++
// [url]https://habrahabr.ru/post/242639/[/url]
auto sum(T1&& a, T2&& b) {
    return std::forward<T1>(a) + std::forward<T2>(b);
}
 
int main()
{
    LargeObject l1, l2;
    l1.n = 500;
    l2.n = 600;
    
    // передача по ссылкам
    std::cout << sum(l1, l2).n << '\n';
    
    // передача как rvalue
    std::cout << sum(5, 5) << std::endl;
}

//нужно передать копию?
some copy = origin; //<--- ну так сделайте её
foo(copy); // <--- и не парьте голову ни себе, ни людям

#include <iostream>
 
 
template < typename T >
T Div(T a, T b) {
    return a/b;
}
 
int main(){   
 std::cout << Div(5, 2) << '\n'; 
}

Div(5.0, 2)

Div(5.0, 2)

void foo(const int); //<---- вот это int
 
template <class T, typename std::enable_if< std::is_intergal<T>::value >::type* = nullptr>
void foo(const T); //<---- а вот это любой интеграл
 
 
template <class T, typename std::enable_if< !std::is_intergal<T>::value >::type* = nullptr>
void foo(const T&); //<---- а вот это все остальное. кроме интегралов

// аргументы не обязаны быть одного типа
// складывать можно любые
// лишь бы они умели друг с дружкой складываться
template <typename T1, typename T2>
// google: Идеальная передача и универсальные ссылки в C++
// [url]https://habrahabr.ru/post/242639/[/url]
auto sum(T1&& a, T2&& b) {
    return std::forward<T1>(a) + std::forward<T2>(b);
}