This is the type converter he meant.
1. 'using namespace std;' in a header is a bad idea
2. mixed C and C++ (string.h instead of cstring, TypeConverter(
3. i miss const-correctness
4. inconsistent code style
Code: Select all
#pragma once
#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <wchar.h>
#include <sstream>
#include <string>
using namespace std;
class TypeConverter
{
public:
TypeConverter(void);
~TypeConverter(void);
void set_intToCharSize(int size);
int get_intToCharSize();
//INTEGER
char* intToChar(int* item);
const char* intToConstChar(int* item);
wchar_t* intToWChar(int* item);
const wchar_t* intToConstWChar(int* item);
string intToString(int* item);
const string intToConstString(int* item);
double intToDouble(int* item);
const double intToConstDouble(int* item);
float intToFloat(int* item);
const float intToConstFloat(int* item);
__int64 intToInt64(int* item);
const __int64 intToConstInt64(int* item);
//~INTEGER
//INTEGER64
char* int64ToChar(__int64* item);
const char* int64ToConstChar(__int64* item);
wchar_t* int64ToWChar(__int64* item);
const wchar_t* int64ToConstWChar(__int64* item);
double int64ToDouble(__int64* item);
const double int64ToConstDouble(__int64* item);
int int64ToInt(__int64* item);
const int int64ToConstInt(__int64* item);
string int64ToString(__int64* item);
const string int64ToConstString(__int64* item);
float int64ToFloat(__int64* item);
const float int64ToConstFloat(__int64* item);
//~INTEGER64
//DOUBLE
char* doubleToChar(double* item);
char* doubleToChar(double* item, int vorkomma, int nachkomma,bool nachkomma_kuerzen);
const char* doubleToConstChar(double* item);
const char* doubleToConstChar(double* item,int vorkomma,int nachkomma,bool nachkomm_kuerzen);
wchar_t* doubleToWChar(double* item);
const wchar_t* doubleToConstWChar(double* item);
string doubleToString(double* item,int nachkomma);
const string doubleToConstString(double* item,int nachkomma);
int doubleToInt(double* item);
const int doubleToConstInt(double* item);
__int64 doubleToInt64(double* item);
const __int64 doubleToConstInt64(double* item);
float doubleToFloat(double* item);
const float doubleToConstFloat(double* item);
//~DOUBLE
//FLOAT
char* floatToChar(float* item);
const char* flaotToConstChar(float* item);
wchar_t* floatToWChar(float* item);
const wchar_t* floatToConstWChar(float* item);
string floatToString(float* item, int nachkomma);
const string floatToConstString(float* item, int nachkomma);
int floatToInt(float* item);
const int floatToConstInt(float* item);
__int64 floatToInt64(float* item);
const __int64 floatToConstInt64(float* item);
double floatToDouble(float* item);
const double floatToConstDouble(float* item);
//~FLOAT
//CHAR
int charToInt(char* item);
const int charToConstInt(char* item);
__int64 charToInt64(char* item);
const __int64 charToConstInt64(char* item);
float charToFloat(char* item);
const float charToConstFloat(char* item);
double charToDouble(char* item);
const double charToConstDouble(char* item);
string charToString(char* item);
const string charToConstString(char* item);
wchar_t* charToWChar(char* item);
const wchar_t* charToConstWChar(char* item);
//~CHAR
//WCHAR_T
int wchar_tToInt(wchar_t* item);
const int wchar_tToConstInt(wchar_t* item);
__int64 wchar_tToInt64(wchar_t* item);
const __int64 wchar_tToConstInt64(wchar_t* item);
float wchar_tToFloat(wchar_t* item);
const float wchar_tToConstFloat(wchar_t* item);
double wchar_tToDouble(wchar_t* item);
const double wchar_tToConstDouble(wchar_t* item);
string wchar_tToString(wchar_t* item);
const string wchar_tToConstString(wchar_t* item);
char* wchar_tToChar(wchar_t* item);
const char* wchar_tToConstChar(wchar_t* item);
//~WCHAR_T
//STRING
int stringToInt(string* item);
const int stringToConstInt(string* item);
__int64 stringToInt64(string* item);
const __int64 stringToConstInt64(string* item);
float stringToFloat(string* item);
const float stringToConstFloat(string* item);
double stringToDouble(string* item);
const double stringToConstDouble(string* item);
char* stringToChar(string* item);
const char* stringToConstChar(string* item);
wchar_t* stringToWchar_T(string* item);
const wchar_t* stringToConstWchar_T(string* item);
//~STRING
void ShowTest();
private:
int intToCharSize;
char* char_buffer;
wchar_t* wchar_t_buffer;
char* wchar_c_buffer;
static const int Wchar_c_buffer_Size = 5000;
static const int CharOfIntBufferSize = 5000;
int int1;
int a;
__int64 int64;
__int64 int642;
double doub;
double doub2;
float flo;
char* satz;
char* ch;
wchar_t* wchar;
wchar_t* wsatz;
string str;
string str2;
};
Code: Select all
#include "StdAfx.h"
#include "TypeConverter.h"
#include <stdlib.h>
#include <string.h>
#include <wchar.h>
#include <sstream>
#include <iostream>
#include <new.h>
#include <float.h>
using namespace std;
TypeConverter::TypeConverter(void)
{
char_buffer = new char[CharOfIntBufferSize];
wchar_t_buffer = new wchar_t[CharOfIntBufferSize];
wchar_c_buffer = new char[Wchar_c_buffer_Size];
int1 = 1234567890;
int64= 1556667778881234124;
int642 = 7777777777777;
a = 54321;
doub = 987654321;
doub2 = 12345.578901;
flo = 4352.192837475f;
satz = new char[50];
satz = "Hallo, das ist nur ein Test!";
ch = new char[15];
ch = "244336.123";
wchar = new wchar_t[20];
wchar = L"70605.04030201";
wsatz = new wchar_t[50];
wsatz = L"Hallo, das ist nur ein wchar_t Test!";
str = "123456.765123456789";
str2 = "Hallo, das ist nur ein string Test!";
}
TypeConverter::~TypeConverter(void)
{
delete this->char_buffer;
delete this->wchar_t_buffer;
delete this->wchar_c_buffer;
this->int1 = 0;
this->a = 0;
this->int64 = 0;
this->int642 = 0;
this->doub = 0;
this->doub2 = 0;
this->flo = 0;
delete this->satz;
delete this->ch;
delete this->wchar;
delete this->wsatz;
this->str = "";
this->str2 = "";
}
//INTTO
char* TypeConverter::intToChar(int *item)
{
_itoa_s(*item, char_buffer, CharOfIntBufferSize, 10);
return char_buffer;
}
const char* TypeConverter::intToConstChar(int* item)
{
_itoa_s(*item,char_buffer,CharOfIntBufferSize,10);
return char_buffer;
}
wchar_t* TypeConverter::intToWChar(int *item)
{
_itow_s(*item,wchar_t_buffer,11,10);
return wchar_t_buffer;
}
const wchar_t* TypeConverter::intToConstWChar(int* item)
{
return intToWChar(item);
}
string TypeConverter::intToString(int* item)
{
stringstream _ss;
if(_ss<< *item)
{
return _ss.str();
}
else
{
return 0;
}
}
const string TypeConverter::intToConstString(int* item)
{
return (intToString(item));
}
double TypeConverter::intToDouble(int* item)
{
return (double)*item;
}
const double TypeConverter::intToConstDouble(int* item)
{
return (double)*item;
}
float TypeConverter::intToFloat(int* item)
{
return (float)*item;
}
const float TypeConverter::intToConstFloat(int* item)
{
return (float)*item;
}
__int64 TypeConverter::intToInt64(int* item)
{
return (__int64)*item;
}
const __int64 TypeConverter::intToConstInt64(int* item)
{
return (__int64)*item;
}
//~INTTO
//INT64TO
char* TypeConverter::int64ToChar(__int64 *item)
{
_i64toa_s(*item,char_buffer,CharOfIntBufferSize,10);
return char_buffer;
}
const char* TypeConverter::int64ToConstChar(__int64 *item)
{
_i64toa_s(*item,char_buffer,CharOfIntBufferSize,10);
return char_buffer;
}
wchar_t* TypeConverter::int64ToWChar(__int64* item)
{
_i64tow_s(*item,wchar_t_buffer,CharOfIntBufferSize,10);
return wchar_t_buffer;
}
const wchar_t* TypeConverter::int64ToConstWChar(__int64* item)
{
return int64ToWChar(item);
}
double TypeConverter::int64ToDouble(__int64 *item)
{
return (double)*item;
}
const double TypeConverter::int64ToConstDouble(__int64 *item)
{
return (double)*item;
}
int TypeConverter::int64ToInt(__int64 *item)
{
stringstream ss;
char* buffer = new char[10];
if(ss << *item)
{
for(int i = 0;i<9;i++)
{
buffer[i] = ss.str()[i];
}
buffer[9] = '\0';
}
unsigned int result = atoi(buffer);
return result;
}
const int TypeConverter::int64ToConstInt(__int64 *item)
{
return int64ToInt(item);
}
string TypeConverter::int64ToString(__int64* item)
{
stringstream ss;
if(ss << *item)
{
return ss.str();
}
else
{
return "Error";
}
}
const string TypeConverter::int64ToConstString(__int64 *item)
{
return this->int64ToString(item);
}
float TypeConverter::int64ToFloat(__int64 *item)
{
return (float)*item;
}
const float TypeConverter::int64ToConstFloat(__int64 *item)
{
return (float)*item;
}
//~INT64TO
//DOUBLE
char* TypeConverter::doubleToChar(double *item)
{
sprintf_s(char_buffer,CharOfIntBufferSize,"%20.4f",*item);
return char_buffer;
}
char* TypeConverter::doubleToChar(double *item, int vorkomma, int nachkomma, bool nachkomma_kuerzen)
{
if(nachkomma_kuerzen)
{
while((vorkomma + nachkomma) > 21)
{
nachkomma--;
}
}
else
{
while((vorkomma + nachkomma) > 21)
{
vorkomma--;
}
}
stringstream vor;
stringstream nach;
string plattern;
if((vor << vorkomma) && (nach << nachkomma))
{
plattern = '%' + vor.str()+'.'+nach.str()+'f';
}
sprintf_s(char_buffer,CharOfIntBufferSize,plattern.c_str(),*item);
return char_buffer;
}
const char* TypeConverter::doubleToConstChar(double *item)
{
return doubleToChar(item);
}
const char* TypeConverter::doubleToConstChar(double *item, int vorkomma, int nachkomma, bool nachkomm_kuerzen)
{
return doubleToChar(item,vorkomma,nachkomma,nachkomm_kuerzen);
}
wchar_t* TypeConverter::doubleToWChar(double* item)
{
_gcvt_s(this->wchar_c_buffer,this->Wchar_c_buffer_Size,*item,30);
size_t size;
mbstowcs_s(&size,wchar_t_buffer,30,this->wchar_c_buffer,32);
return wchar_t_buffer;
}
const wchar_t* TypeConverter::doubleToConstWChar(double *item)
{
return this->doubleToWChar(item);
}
string TypeConverter::doubleToString(double* item,int nachkomma)
{
stringstream ss;
ss.setf(ios_base::fixed,ios_base::floatfield);
ss.precision(nachkomma);
if(ss << *item)
{
return ss.str();
}
else
{
return "Error";
}
}
const string TypeConverter::doubleToConstString(double *item, int nachkomma)
{
return this->doubleToString(item,nachkomma);
}
int TypeConverter::doubleToInt(double* item)
{
return (int)*item;
}
const int TypeConverter::doubleToConstInt(double *item)
{
return (int)*item;
}
__int64 TypeConverter::doubleToInt64(double *item)
{
return (__int64)*item;
}
const __int64 TypeConverter::doubleToConstInt64(double *item)
{
return (__int64)*item;
}
float TypeConverter::doubleToFloat(double *item)
{
return (float)*item;
}
const float TypeConverter::doubleToConstFloat(double *item)
{
return (float)*item;
}
//~DOUBLE
//FLOAT
char* TypeConverter::floatToChar(float *item)
{
_gcvt_s(char_buffer,32,*item,30);
return this->char_buffer;
}
const char* TypeConverter::flaotToConstChar(float *item)
{
return this->floatToChar(item);
}
wchar_t* TypeConverter::floatToWChar(float* item)
{
_gcvt_s(this->wchar_c_buffer,this->Wchar_c_buffer_Size,*item,30);
size_t size;
mbstowcs_s(&size,wchar_t_buffer,30,this->wchar_c_buffer,32);
return wchar_t_buffer;
}
const wchar_t* TypeConverter::floatToConstWChar(float *item)
{
return floatToWChar(item);
}
string TypeConverter::floatToString(float *item, int nachkomma)
{
stringstream ss;
ss.setf(ios_base::fixed,ios_base::floatfield);
ss.precision(nachkomma);
if(ss << *item)
{
return ss.str();
}
else
{
return "Error";
}
}
const string TypeConverter::floatToConstString(float* item,int nachkomma)
{
return floatToString(item,nachkomma);
}
int TypeConverter::floatToInt(float* item)
{
return (int)*item;
}
const int TypeConverter::floatToConstInt(float* item)
{
return (int)*item;
}
__int64 TypeConverter::floatToInt64(float* item)
{
return (__int64)*item;
}
const __int64 TypeConverter::floatToConstInt64(float* item)
{
return (__int64)*item;
}
double TypeConverter::floatToDouble(float* item)
{
return (double)*item;
}
const double TypeConverter::floatToConstDouble(float* item)
{
return (double)*item;
}
//~FLOAT
//CHAR
int TypeConverter::charToInt(char* item)
{
return atoi(item);
}
const int TypeConverter::charToConstInt(char *item)
{
return atoi(item);
}
__int64 TypeConverter::charToInt64(char* item)
{
return _atoi64(item);
}
const __int64 TypeConverter::charToConstInt64(char* item)
{
return _atoi64(item);
}
float TypeConverter::charToFloat(char *item)
{
return (float)atof(item);
}
const float TypeConverter::charToConstFloat(char *item)
{
return (float)atof(item);
}
double TypeConverter::charToDouble(char* item)
{
return atof(item);
}
const double TypeConverter::charToConstDouble(char* item)
{
return atof(item);
}
string TypeConverter::charToString(char *item)
{
stringstream ss;
if(ss << item)
{
return ss.str();
}
else
{
return "Error";
}
}
const string TypeConverter::charToConstString(char *item)
{
return charToString(item);
}
wchar_t* TypeConverter::charToWChar(char *item)
{
size_t size;
size_t origsize = strlen(item)+1;
mbstowcs_s(&size,this->wchar_t_buffer,origsize,item,_TRUNCATE);
return this->wchar_t_buffer;
}
const wchar_t* TypeConverter::charToConstWChar(char *item)
{
return charToWChar(item);
}
//~CHAR
//WCHAR_T
int TypeConverter::wchar_tToInt(wchar_t* item)
{
return _wtoi(item);
}
const int TypeConverter::wchar_tToConstInt(wchar_t* item)
{
return _wtoi(item);
}
__int64 TypeConverter::wchar_tToInt64(wchar_t *item)
{
return _wtoi64(item);
}
const __int64 TypeConverter::wchar_tToConstInt64(wchar_t* item)
{
return _wtoi64(item);
}
float TypeConverter::wchar_tToFloat(wchar_t* item)
{
return (float)_wtof(item);
}
const float TypeConverter::wchar_tToConstFloat(wchar_t* item)
{
return (float)_wtof(item);
}
double TypeConverter::wchar_tToDouble(wchar_t* item)
{
return _wtof(item);
}
string TypeConverter::wchar_tToString(wchar_t* item)
{
string result;
result = (char)(item)[0];
int i = 1;
int max = wcslen(item);
while((item) && (i<max))
{
result +=(char)(item)[i];
i++;
}
result+='\0';
return result;
}
//after this char_buffer has the length of(item)
char* TypeConverter::wchar_tToChar(wchar_t *item)
{
int max = wcslen(item);
int i = 0;
while(i<max)
{
this->char_buffer[i] = (char)(item)[i];
i++;
}
this->char_buffer[i] = '\0';
return this->char_buffer;
}
const char* TypeConverter::wchar_tToConstChar(wchar_t* item)
{
return wchar_tToChar(item);
}
const string TypeConverter::wchar_tToConstString(wchar_t* item)
{
return wchar_tToString(item);
}
const double TypeConverter::wchar_tToConstDouble(wchar_t* item)
{
return _wtof(item);
}
//~WCHAR_T
//STRING
int TypeConverter::stringToInt(string* item)
{
return atoi(&(*item)[0]);
}
const int TypeConverter::stringToConstInt(string *item)
{
return atoi(&(*item)[0]);
}
__int64 TypeConverter::stringToInt64(string* item)
{
return _atoi64(&(*item)[0]);
}
const __int64 TypeConverter::stringToConstInt64(string *item)
{
return _atoi64(&(*item)[0]);
}
float TypeConverter::stringToFloat(string* item)
{
return (float)atof(&(*item)[0]);
}
const float TypeConverter::stringToConstFloat(string* item)
{
return (float)atof(&(*item)[0]);
}
double TypeConverter::stringToDouble(string* item)
{
return atof(&(*item)[0]);
}
const double TypeConverter::stringToConstDouble(string* item)
{
return atof(&(*item)[0]);
}
char* TypeConverter::stringToChar(string* item)
{
return &(*item)[0];
}
const char* TypeConverter::stringToConstChar(string* item)
{
return &(*item)[0];
}
wchar_t* TypeConverter::stringToWchar_T(string *item)
{
int i = 0;
while((*item)[i] != 0)
{
this->wchar_t_buffer[i] = (*item)[i];
i++;
}
this->wchar_t_buffer[i] = '\0';
return this->wchar_t_buffer;
}
const wchar_t* TypeConverter::stringToConstWchar_T(string* item)
{
return stringToWchar_T(item);
}
//~STRING
void TypeConverter::ShowTest()
{
this->set_intToCharSize(11);
cout.setf( ios_base::fixed, ios_base::floatfield );
cout.precision(10);
cout<<"#######################################"<<endl;
cout<<"###############CONVERTER###############"<<endl;
cout<<"#######################################"<<endl;
cout<<"Typ INT: "<<int1<<endl;
cout<<"Typ INT64: "<<int64<<endl;
cout<<"Typ INT64: "<<int642<<endl;
cout<<"Typ DOUBLE: "<<doub<<endl;
cout<<"Typ DOUBLE: "<<doub2<<endl;
cout<<"Typ FLOAT: "<<flo<<endl;
cout<<"Typ CHAR: "<<satz<<endl;
cout<<"Typ CHAR: "<<ch<<endl;
wcout<<"Typ WCHAR_T: "<<wchar<<endl;
wcout<<"Typ WCHAR_T: "<<wsatz<<endl;
cout<<"Typ STRING: "<<str<<endl;
cout<<"Typ STRING: "<<str2<<endl;
cout<<"<---------------INTEGER--------------->"<<endl;
cout<<"intToChar: "<<this->intToChar(&int1)<<endl;
cout<<"intToConstChar: "<<this->intToConstChar(&a)<<endl;
wcout<<"intToWChar: "<<this->intToWChar(&int1)<<endl;
wcout<<"intToConstWChar: "<<this->intToConstWChar(&int1)<<endl;
cout<<"intToString: "<<this->intToString(&int1)<<endl;
cout<<"intToConstString: "<<this->intToConstString(&int1)<<endl;
cout<<"intToDouble: "<<this->intToDouble(&int1)<<endl;
cout<<"intToConstDouble: "<<this->intToConstDouble(&int1)<<endl;
cout<<"intToFloat: "<<this->intToFloat(&int1)<<endl;
cout<<"intToConstFloat: "<<this->intToConstFloat(&int1)<<endl;
cout<<"intToInt64: "<<this->intToInt64(&int1)<<endl;
cout<<"intToConstInt64: "<<this->intToConstInt64(&int1)<<endl;
cout<<"<----------INTEGER-ENDE--------------->"<<endl;
cout<<"<--------------INT64------------------>"<<endl;
cout<<"int64ToChar: "<<this->int64ToChar(&int64)<<endl;
cout<<"int64ToConstChar: "<<this->int64ToConstChar(&int64)<<endl;
wcout<<"int64ToWChar: "<<this->int64ToWChar(&int64)<<endl;
wcout<<"int64ToConstChar: "<<this->int64ToConstWChar(&int64)<<endl;
cout<<"int64ToDouble: "<<this->int64ToDouble(&int64)<<endl;
cout<<"int64ToConstDouble: "<<this->int64ToConstDouble(&int64)<<endl;
cout<<"int64ToInt: "<<this->int64ToInt(&int64)<<endl;
cout<<"int64ToConstInt: "<<this->int64ToConstInt(&int64)<<endl;
cout<<"int64ToString: "<<this->int64ToString(&int64)<<endl;
cout<<"int64ToConstString: "<<this->int64ToConstString(&int64)<<endl;
cout<<"int64ToFloat: "<<this->int64ToFloat(&int64)<<endl;
cout<<"int64ToConstFloat: "<<this->int64ToConstFloat(&int64)<<endl;
cout<<"<-------------INT 64 Ende------------->"<<endl;
cout<<"<--------------DOUBLE----------------->"<<endl;
cout<<"doubleToChar: "<<this->doubleToChar(&doub)<<endl;
cout<<"doubleToChat(12345.678901,5,10,true): "<<this->doubleToChar(&doub2,5,10,true)<<endl;
cout<<"doubleToConstChar: "<<this->doubleToConstChar(&doub)<<endl;
cout<<"doubleToConstChar(12345.678901,5,10,true): "<<this->doubleToConstChar(&doub2,5,10,true)<<endl;
wcout<<"doubleToWChar: "<<this->doubleToWChar(&doub2)<<endl;
wcout<<"doubleToConstWchar: "<<this->doubleToConstWChar(&doub)<<endl;
cout<<"doubleToString(nachkomma 1): "<<this->doubleToString(&doub2,1)<<endl;
cout<<"doubleToString(nachkomma 10): "<<this->doubleToString(&doub2,10)<<endl;
cout<<"doubleToConstString(nachkomma 1): "<<this->doubleToConstString(&doub,1)<<endl;
cout<<"doubleToConstString(nachkomma 10): "<<this->doubleToConstString(&doub,10)<<endl;
cout<<"doubleToInt: "<<this->doubleToInt(&doub2)<<endl;
cout<<"doubleToConstInt: "<<this->doubleToConstInt(&doub2)<<endl;
cout<<"doubleToInt64: "<<this->doubleToInt64(&doub2)<<endl;
cout<<"doubleToConstInt64: "<<this->doubleToConstInt64(&doub2)<<endl;
cout<<"doubleToFloat: "<<this->doubleToFloat(&doub2)<<endl;
cout<<"doubleToConstFloat: "<<this->doubleToConstFloat(&doub2)<<endl;
cout<<"<----------------DOUBLE ENDE----------->"<<endl;
cout<<"<-----------------FLOAT---------------->"<<endl;
cout<<"floatToChar: "<<this->floatToChar(&flo)<<endl;
cout<<"floatToConstChar: "<<this->flaotToConstChar(&flo)<<endl;
wcout<<"floatToWChar: "<<this->floatToWChar(&flo)<<endl;
wcout<<"floatToConstWChar: "<<this->floatToConstWChar(&flo)<<endl;
cout<<"floatToString(nachkomma 1): "<<this->floatToString(&flo,1)<<endl;
cout<<"floatToString(nachkomma 10): "<<this->floatToString(&flo,10)<<endl;
cout<<"floatToConstString(nachkomma 1): "<<this->floatToConstString(&flo,1)<<endl;
cout<<"floatToConstString(nachkomma 10): "<<this->floatToConstString(&flo,10)<<endl;
cout<<"floatToInt: "<<this->floatToInt(&flo)<<endl;
cout<<"floatToConstInt: "<<this->floatToConstInt(&flo)<<endl;
cout<<"floatToInt64: "<<this->floatToInt64(&flo)<<endl;
cout<<"floatToConstInt64: "<<this->floatToConstInt64(&flo)<<endl;
cout<<"floatToDouble: "<<this->floatToDouble(&flo)<<endl;
cout<<"floatToConstDouble: "<<this->floatToConstDouble(&flo)<<endl;
cout<<"<-----------------FLOAT ENDE ----------->"<<endl;
cout<<"<-------------------CHAR---------------->"<<endl;
cout<<"charToInt: "<<this->charToInt(ch)<<endl;
cout<<"charToConstInt: "<<this->charToConstInt(ch)<<endl;
cout<<"charToInt64: "<<this->charToInt64(ch)<<endl;
cout<<"charToConstInt64: "<<this->charToConstInt64(ch)<<endl;
cout<<"charToFloat: "<<this->charToFloat(ch)<<endl;
cout<<"charToConstFloat: "<<this->charToConstFloat(ch)<<endl;
cout<<"charToDouble: "<<this->charToDouble(ch)<<endl;
cout<<"charToConstDouble: "<<this->charToConstDouble(ch)<<endl;
cout<<"charToString: "<<this->charToString(satz)<<endl;
cout<<"charToConstString: "<<this->charToConstString(satz)<<endl;
wcout<<"charToWChar: "<<this->charToWChar(satz)<<endl;
wcout<<"charToConstWChar: "<<this->charToConstWChar(satz)<<endl;
cout<<"<-----------------CHAR ENDE------------->"<<endl;
cout<<"<------------------WCHAR_T-------------->"<<endl;
cout<<"wchar_tToInt: "<<this->wchar_tToInt(wchar)<<endl;
cout<<"wchar_tToConstInt: "<<this->wchar_tToConstInt(wchar)<<endl;
cout<<"wchar_tToInt64: "<<this->wchar_tToInt64(wchar)<<endl;
cout<<"wchar_tToConstInt64: "<<this->wchar_tToConstInt64(wchar)<<endl;
cout<<"wchar_tToFloat: "<<this->wchar_tToFloat(wchar)<<endl;
cout<<"wchar_tToConstFloat: "<<this->wchar_tToConstFloat(wchar)<<endl;
cout<<"wchar_tToDouble: "<<this->wchar_tToDouble(wchar)<<endl;
cout<<"wchar_tToConstDouble: "<<this->wchar_tToConstDouble(wchar)<<endl;
cout<<"wchar_tToString: "<<this->wchar_tToString(wsatz)<<endl;
cout<<"wchar_tToConstString: "<<this->wchar_tToConstString(wsatz)<<endl;
cout<<"wchar_tToChar: "<<this->wchar_tToChar(wsatz)<<endl;
cout<<"wchar_tToConstChar: "<<this->wchar_tToConstChar(wsatz)<<endl;
cout<<"<-----------------WCHAR_T ENDE---------->"<<endl;
cout<<"<------------------STRING--------------->"<<endl;
cout<<"stringToInt: "<<this->stringToInt(&str)<<endl;
cout<<"stringToConstInt: "<<this->stringToConstInt(&str)<<endl;
cout<<"stringToInt64: "<<this->stringToInt64(&str)<<endl;
cout<<"stringToConstInt64: "<<this->stringToConstInt64(&str)<<endl;
cout<<"stringToFloat: "<<this->stringToFloat(&str)<<endl;
cout<<"stringToConstFloat: "<<this->stringToConstFloat(&str)<<endl;
cout<<"stringToDouble: "<<this->stringToDouble(&str)<<endl;
cout<<"stringToConstDouble: "<<this->stringToConstDouble(&str)<<endl;
cout<<"stringToChar: "<<this->stringToChar(&str2)<<endl;
cout<<"stringToConstChar: "<<this->stringToConstChar(&str2)<<endl;
wcout<<"stringToWchar_T: "<<this->stringToWchar_T(&str2)<<endl;
wcout<<"stringToConstWchar_T: "<<this->stringToConstWchar_T(&str2)<<endl;
cout<<"<----------------STRING ENDE------------>"<<endl;
}
void TypeConverter::set_intToCharSize(int size)
{
intToCharSize = size;
}
int TypeConverter::get_intToCharSize()
{
return intToCharSize;
}