Provocarea săptămânii – Output

#include <iostream>
#include <cstdio>
#include <cstring>

class customPrint {
private:
	unsigned precision;

public:
	static const char endline = '\n';
	customPrint(unsigned precision) {
		if(precision <= 15)
			this->precision = precision;
		else
			this->precision = 5;
	}
	customPrint() {
		this->precision = 5;
	}
	customPrint& operator<<(const char* str) {
		printf("%s", str);
		return *this;
	}
	customPrint& operator<<(const std::string& str) {
		return *this << str.c_str();
	}
	customPrint& operator<<(const char character) {
		printf("%c", character);
		return *this;
	}
	customPrint& operator<<(const unsigned unsignedNumber) {
		printf("%u", unsignedNumber);
		return *this;
	}
	customPrint& operator<<(const int integer) {
		printf("%d", integer);
		return *this;
	}
	customPrint& operator<<(const double number) {
		char printArg[20] = "%.";
		char precisionStr[20];
		sprintf(precisionStr, "%u", this->precision);
		strcat(printArg, precisionStr);
		strcat(printArg, "f");
		printf(printArg, number);
		return *this;
	}
	customPrint& operator<<(const customPrint& data) {
		this->precision = data.precision;
		return *this;
	}
};

customPrint setPrecision(const unsigned decimals) {
	return customPrint(decimals);
}

int main() {
	customPrint ceva;
	char cSir[] = "Ana are 3 mere";

	std::string sString = "pere";
	ceva << cSir << ", " << 4 << ' ' << sString << customPrint::endline;
	ceva << "Afara sunt " << -5 << " grade\n";
	ceva << setPrecision(3) << 4.56 << " " << setPrecision(6) << 1.0 / 3;

	return 0;
}

Quote

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cstdarg>
#include <iostream>
#include <string>
namespace custom {
char *strrev(char *str)
{
	  char *p1, *p2;
	  if (! str || ! *str)
			return str;
	 
	  for (p1 = str, p2 = str + strlen(str) - 1; p2 > p1; ++p1, --p2)
	  {
			*p1 ^= *p2;
			*p2 ^= *p1;
			*p1 ^= *p2;
	  }
	 
	  return str;
}
void add_hex_prefix(char *buf)
{
	int len = strlen(buf);
	for (int i = len - 1; i >= 0; i--) {
		buf[i + 2] = buf[i];
	}
	buf[len + 2] = '\0';
	buf[0] = '0';
	buf[1] = 'x';
}
void itoa(char *buf, unsigned long int n, int base)
{
	unsigned long int tmp;
	int i;
	tmp = n;
	i = 0;
	do {
		tmp = n % base;
		buf[i++] = (tmp < 10) ? (tmp + '0') : (tmp + 'a' - 10);
	} while (n /= base);
	buf[i] = '\0';
	strrev(buf);
	if (base == 16) {
		add_hex_prefix(buf);
	}
}
void putstring(const char *s, int n)
{
	for (int i = 0; i < n; i++) {
		putchar(s[i]);
	}
}
int printf(const char* format, ...) {
	va_list parameters;
	va_start(parameters, format);
	int written = 0;
	size_t amount;
	bool rejected_bad_specifier = false;
	while ( *format != '\0' ) {
		if ( *format != '%' ) {
		print_c:
			amount = 1;
			while ( format[amount] && format[amount] != '%' )
				amount++;
			putstring(format, amount);
			format += amount;
			written += amount;
			continue;
		}
		const char* format_begun_at = format;
		if ( *(++format) == '%' )
			goto print_c;
		if ( rejected_bad_specifier ) {
		incomprehensible_conversion:
			rejected_bad_specifier = true;
			format = format_begun_at;
			goto print_c;
		}
		if ( *format == 'c' ) {
			format++;
			char c = (char) va_arg(parameters, int);
			putstring(&c, sizeof(c));
		} else if ( *format == 's' ) {
			format++;
			const char* s = va_arg(parameters, const char*);
			putstring(s, strlen(s));
		} else if ( *format == 'd' ) {
			format++;
			int n = va_arg(parameters, int);
			if (n) {
				char s[256];
				itoa(s, n, 10);
				putstring(s, strlen(s));
			} else {
				putchar('0');
			}
		} else if ( *format == 'x') {
			format++;
			int n = va_arg(parameters, int);
			if (n) {
				char s[256];
				itoa(s, n, 16);
				putstring(s, strlen(s));
			} else {
				putstring("0x0", 3);
			}
		} else {
			goto incomprehensible_conversion;
		}
	}
	va_end(parameters);
	return written;
}
#define NOT_INITIALIZED_MANIPULATOR_FIELD -1
#define DEFAULT_PRECISION 6
#define DEFAULT_BASE 10
class outstream;
class manipulator {
	friend class outstream;
	private:
		int precision;
		int base;
	public:
		manipulator() {
			this->precision = NOT_INITIALIZED_MANIPULATOR_FIELD;
			this->base	  = NOT_INITIALIZED_MANIPULATOR_FIELD;
		}
		manipulator& setBase(int base) {
			this->base = base;
			return *this;
		}
		manipulator& setPrecision(int precision) {
			this->precision = precision;
			return *this;
		}
};
manipulator setPrecision(int precision) {
	manipulator m;
	return m.setPrecision(precision);
}
manipulator setBase(int base) {
	manipulator m;
	return m.setBase(base);
}
static const char endl = '\n';
class outstream {
	private:
		int precision;
		int base;
   
	public:
		outstream() {
			this->precision = DEFAULT_PRECISION;
			this->base = DEFAULT_BASE;
		}
		outstream& operator<<(const char c) {
			printf("%c", c);
			return *this;
		}
		outstream& operator<<(const char* s) {
			printf("%s", s);
			return *this;
		}
		outstream& operator<<(const std::string& s) {
			printf("%s", s.c_str());
			return *this;
		}
		outstream& operator<<(const int n) {
			if (this->base == 16) {
				printf("%x", n);
			} else {
				printf("%d", n);
			}
			return *this;
		}
		outstream& operator<<(const manipulator& m) {
			if (m.precision != NOT_INITIALIZED_MANIPULATOR_FIELD)
				this->precision = m.precision;
			if (m.base != NOT_INITIALIZED_MANIPULATOR_FIELD)
				this->base = m.base;
			return *this;
		}
};
outstream cout;
} // end of namespace custom
int main() {
	char c = 'c';
	char s[] = "ok";
	int d = 123;
	int x = 0xABC;
	custom::printf("Hello %c %s %d %x\n", c, s, d, x);
	custom::cout << "Hello world" << custom::endl;
	custom::cout << custom::setBase(16) << x << custom::endl;
	custom::cout << custom::setBase(10) << d << custom::endl;
	return 0;
}
   

class setPrecision {
	unsigned numberOfDecimals;

public:
	setPrecision(unsigned numberOfDecimals) : numberOfDecimals{ numberOfDecimals }
	{
	}
	unsigned getNumberOfDecimals() const
	{
		return numberOfDecimals;
	}
};

class customPrint {
	unsigned precision = 5;

public:
	static const char endline = '\n';

	customPrint(unsigned precision) : precision{precision}
	{
	}

	customPrint()
	{
	}

	customPrint& setPrecision(unsigned precision)
	{
		this->precision = precision;
		return *this;
	}

	customPrint& operator<<(const char* str)
	{
		printf("%s", str);
		return *this;
	}

	customPrint& operator<<(const std::string& str)
	{
		return *this << str.c_str();
	}

	customPrint& operator<<(char character)
	{
		printf("%c", character);
		return *this;
	}

	customPrint& operator<<(unsigned unsignedNumber)
	{
		printf("%u", unsignedNumber);
		return *this;
	}

	customPrint& operator<<(int integer)
	{
		printf("%d", integer);
		return *this;
	}

	customPrint& operator<<(double number)
	{
		printf("%.*f", this->precision, number);
		return *this;
	}
};

customPrint& operator<<(customPrint& current, const setPrecision& data) {
	return current.setPrecision(data.getNumberOfDecimals());
}

#include <iostream>

void tprintf(const char* format) // base function
{
	std::cout << format;
}

template<typename T, typename... Targs>
void tprintf(const char* format, T value, Targs... Fargs) // recursive variadic function
{
	for ( ; *format != '\0'; format++ ) {
		if ( *format == '%' ) {
		   std::cout << value;
		   tprintf(format+1, Fargs...); // recursive call
		   return;
		}
		std::cout << *format;
	}
}

int main()
{
	tprintf("% world% %\n","Hello",'!',123);
	return 0;
}