Extern "C", variadic template

#include <iostream>
#include <string>
#include <limits>

using std::string;
using std::cerr;

#define LOG_FUNC(x) cerr << '\n' << #x " = " << x << '\t'
#define LOG_ARG(x) cerr << #x " = " << x << '\t'

template <typename T>
class Money {
static_assert((std::numeric_limits<T>::is_integer || std::is_floating_point<T>::value) && "Number required.");
public:
   Money(const string & dollars, const long double cents);   
   Money(const string & dollars); 

   static Money create(const string & dollars, const long double cents);
   static Money create(const string & dollars);
};

template <typename T>
Money<T>::Money(const string & dollars, const long double cent) {
   LOG_FUNC(__func__);
   LOG_ARG(dollars);
   LOG_ARG(cent);
}

template <typename T>
Money<T>::Money(const string & dollars) {
   LOG_FUNC(__func__);
   LOG_ARG(dollars);
}

template <typename T>
Money<T> Money<T>::create(const string & dollars) {   
   LOG_FUNC(__func__);
   LOG_ARG(dollars);
   return Money<T>(dollars);
}

template <typename T>
Money<T> Money<T>::create(const string & dollars, const long double cents) {
   LOG_FUNC(__func__);
   LOG_ARG(dollars);
   LOG_ARG(cents);
   return Money<T>(dollars, cents);
}

template <typename T>
struct Creation {
	template<typename... Args>
	Money<T> operator()(Args...args) const {
		return Money<T>::create(std::forward<Args>(args)...);
	}
};

template <class Type, template<typename> class Template>
struct Constructor {
	template<typename... Args>
	Template<Type> operator()(Args...args) const {
		return Template<Type>(std::forward<Args>(args)...);
	}
};

template <typename Function, typename... Args> 
void call(Function && f, Args &&... args ) { 
   f(std::forward<Args>(args)...);
}

int main() {
   call(Constructor<int, Money>(), "-20.8", 5.0L);
   call(Constructor<long long, Money>(), "78");
   call(Creation<unsigned long long>(), "2", 5);
   call(Creation<long double>(), "7");
   cerr << '\n';
}

// g++ -Wfatal-errors -Wall -Wextra -Wconversion -std=c++14 

#include <iostream>

enum class show { dollars , cents };

struct Tag
{
    Tag( std::ostream& out_ , show type_ ): out{out_} , type{type_} {}
    std::ostream& out;
    show type;    
}; 

auto operator<<( std::ostream& out , show type ){ return Tag{out,type}; }

std::ostream& operator<<( Tag tag , long double value )
{   
    if( tag.type == show::dollars ) tag.out << static_cast<long double>(value/100.0) << " dollars";
    else tag.out << value << " cents";
    return tag.out;
}

constexpr long double operator"" _dollars ( long double value ){ return value*100; }
constexpr long double operator"" _cents ( unsigned long long n ){ return n; }

int main() 
{   
   std::cout << show::dollars << -20.8_dollars+5_cents << std::endl;
   std::cout << show::cents << 2.1_dollars+78_cents << std::endl;
   std::cout << show::cents << 2.1_dollars-1.78_dollars-5000_cents << std::endl;
}

#ifdef __cplusplus
extern "C" {
#endif

// twoje funkcje


#ifdef __cplusplus
}
#endif

#include <stdlib.h>
...
int status = system("./foo 1 2 3");