متغییرها

[mortezashm]

سلام من یه متغییر می خام که حداقل 9 رقم اعشار یا عدد داشته باشه مثلا 258.1234567891235

[Ananas]

double
long double

[mortezashm]

با long امتحان کردم بازم جواب نداد

[ehsan_faal]

مطمئنید؟
تا جایی که من میدونم دابل 15 رقم اعشار رو ساپورت میکنه.شاید چون روی کنسول تا 6 تا رو بیشتر در حالت عادی نشون نمیده فکر کردید که دقتش کمه.
میتونید از iomanip استفاده کنید تا با دقت بیشتری اونها رو روی کنسول ببینید.
البته اگه باز هم دنبال دقت بیشتر هستید کتابخونه های زیادی برای این کار هست که میتونید از اونها استفاده کنید.

[mortezashm]

اره تو محیط کنسول امتحان می کنم مثلا x=256 من این عدد رو تقسیم بر 1000000000می کنم اما به جای چاپ کردن یه همچین اروری میده 2.56e-0071
ممنون میشم روش iomanip رو توضیح بدید

[zero_ox]

این صفحه رو ببین .
http://www.cplusplus.com/reference/iomanip/setprecision/

[mortezashm]

مرسی مشکل حل شد

[Ananas]

اره تو محیط کنسول امتحان می کنم مثلا x=256 من این عدد رو تقسیم بر 1000000000می کنم اما به جای چاپ کردن یه همچین اروری میده 2.56e-0071
ممنون میشم روش iomanip رو توضیح بدید

این ارور نیست! این نمایش عدد به نماد علمی هست. ینی 2.56 ضربدر 10 به توان منهای هفت. که البته اینجا چیزی که نوشتید 71 هست که ظاهرا اشتباه کپی کردید یا عدد 1 رو بلافاصله بعدش چاپ کردید. 256 تقسیم بر 1000000000 میشه 0.000000256 که با 7 بار ضرب کردن در 10 میشه 2.56
اینکارو میکنن که موقع نوشتن و خوندن از صفرهای طولانی خلاص بشیم. وقتی مینویسید 0.000000256 من باید اول تعداد صفر هارو بشمارم ولی با این روش خیلی راحت میفهمم چقدر عدد کوچیک یا بزرگه. حالا فکر کن بخام بنویسم 0.0000000000000000000000000000000000256
اونوقت سخت تر هم میشه. و متن طولانی تر. ولی با نماد علمی میشه 2.56e-35

[Ananas]

این یک نمونه هست که از لابلای کدهام کشیدم بیرون:



#include <iostream.h>
using namespace std;

#include <cstdint>

typedef int32_t MQ_I32;
typedef int64_t MQ_I64;
typedef uint32_t MQ_UI32;
typedef uint64_t MQ_UI64;


typedef float MQ_F32;
typedef double MQ_F64;
typedef long double MQ_F80;

const char * MQCS_0123456789ABCDEF = "0123456789ABCDEF";
#define MQCS_0123456789 MQCS_0123456789ABCDEF
#define MQCS_01 MQCS_0123456789ABCDEF

const wchar_t * MQWCS_0123456789ABCDEF = L"0123456789ABCDEF";
#define MQWCS_0123456789 MQWCS_0123456789ABCDEF
#define MQWCS_01 MQWCS_0123456789ABCDEF

wchar_t * MQInt64ToWCStr(wchar_t * pOutWCStr, const MQ_I64 i64, const int radix = 10)
{
#define DIGITS_0TOF MQWCS_0123456789ABCDEF
if (i64 == 0)
{
pOutWCStr[0] = L'0';
pOutWCStr[1] = wchar_t(0);
return pOutWCStr;
};
int index = 0;
wchar_t invStr[256];
MQ_I64 i64_ = i64;
if (i64_ < 0)
i64_ = -i64_;
MQ_I64 remainder;
while (i64_ > 0)
{
remainder = i64_ % radix;
invStr[255 - index] = DIGITS_0TOF[remainder];// + wchar_t(L'0');
i64_ /= radix;
index++;
};
if (i64 < 0)
{
invStr[255 - index] = wchar_t(L'-');
index++;
};
memcpy(pOutWCStr, &(invStr[256 - index]), sizeof(wchar_t) * index);
pOutWCStr[index] = wchar_t(0);
return pOutWCStr;
#undef DIGITS_0TOF
}
wchar_t * MQUInt64ToWCStr(
wchar_t * pOutWCStr,
const MQ_UI64 ui64,
const int radix = 16,
const unsigned __int8 ForceMinDigit = 16)
{
#define DIGITS_1TOF MQWCS_0123456789ABCDEF
/*
if (ui64 == 0)
{
pOutWCStr[0] = L'0';
pOutWCStr[1] = wchar_t(0);
return pOutWCStr;
};
*/
int index = 0;
wchar_t invStr[256];
MQ_UI64 ui64_ = ui64;
MQ_UI64 remainder;
while (ui64_ > 0)
{
remainder = ui64_ % radix;
invStr[255 - index] = DIGITS_1TOF[remainder];// + wchar_t(L'0');
ui64_ /= radix;
index++;
};
while (int(ForceMinDigit) > index)
{
invStr[255 - index] = L'0';
index++;
};
memcpy(pOutWCStr, &(invStr[256 - index]), sizeof(wchar_t) * index);
pOutWCStr[index] = wchar_t(0);
return pOutWCStr;
#undef DIGITS_1TOF
};

wchar_t * MQInt32ToWCStr(wchar_t * pOutWCStr, const MQ_I32 i32, const int radix = 10)
{
return MQInt64ToWCStr(pOutWCStr, (MQ_I64)i32, radix);
};

wchar_t * MQUInt32ToWCStr(
wchar_t * pOutWCStr,
const MQ_UI32 ui32,
const int radix = 16,
const unsigned __int8 ForceMinDigit = 8)
{
return MQUInt64ToWCStr(pOutWCStr, (MQ_UI64)ui32, radix, ForceMinDigit);
};


wchar_t * MQSmallFloat32ToWCStr(wchar_t * pOutStr, const MQ_F32 x, const int realDig)
{
int realdigcount = abs(realDig);
if (realdigcount > 7)
realdigcount = 7;
MQ_F32 mul10 = 1.0f;
switch (realdigcount)
{
case 0 : mul10 = 1.0f; break;
case 1 : mul10 = 10.0f; break;
case 2 : mul10 = 100.0f; break;
case 3 : mul10 = 1000.0f; break;
case 4 : mul10 = 10000.0f; break;
case 5 : mul10 = 100000.0f; break;
case 6 : mul10 = 1000000.0f; break;
default: mul10 = 10000000.0f;
};
MQ_F32 abs_x = -fabs(x);
bool if_1_1 = (abs_x < 1.0f) && (abs_x > -1.0f);
if (if_1_1)
abs_x -= 1.0f;
MQ_I64 i64 = MQ_I64(mul10 * abs_x);
MQInt64ToWCStr(pOutStr, i64, 10);
int len = wcslen(pOutStr);
int dotindex = len - realdigcount;
pOutStr[len + 1] = wchar_t(0);
for (int i = len; i >= dotindex; i--)
{
pOutStr[i + 1] = pOutStr[i];
};
if (realdigcount == 0)
{
pOutStr[len + 1] = L'0';
pOutStr[len + 2] = wchar_t(0);
}
else
{
int i = len;
while ((i > (dotindex + 1)) && (pOutStr[i] == L'0'))
{
pOutStr[i] = wchar_t(0);
i--;
};
};
pOutStr[dotindex] = L'.';
if (x >= 0.0f) pOutStr[0] = L' '; // positive
if (if_1_1) pOutStr[1] = L'0';

return pOutStr;
};

wchar_t * MQSmallFloat64ToWCStr(wchar_t * pOutStr, const MQ_F64 x, const int realDig)
{
int realdigcount = abs(realDig);
if (realdigcount > 14)
realdigcount = 14;
MQ_F64 mul10 = 1.0;
switch (realdigcount)
{
case 0 : mul10 = 1.0; break;
case 1 : mul10 = 10.0; break;
case 2 : mul10 = 100.0; break;
case 3 : mul10 = 1000.0; break;
case 4 : mul10 = 10000.0; break;
case 5 : mul10 = 100000.0; break;
case 6 : mul10 = 1000000.0; break;
case 7 : mul10 = 10000000.0; break;
case 8 : mul10 = 100000000.0; break;
case 9 : mul10 = 1000000000.0; break;
case 10 : mul10 = 10000000000.0; break;
case 11 : mul10 = 100000000000.0; break;
case 12 : mul10 = 1000000000000.0; break;
case 13 : mul10 = 10000000000000.0; break;
default : mul10 = 100000000000000.0;
};
MQ_F64 abs_x = -fabs(x);
bool if_1_1 = (abs_x < 1.0) && (abs_x > -1.0);
if (if_1_1)
abs_x -= 1.0;
MQ_I64 i64 = MQ_I64(mul10 * abs_x);
MQInt64ToWCStr(pOutStr, i64, 10);
int len = wcslen(pOutStr);
int dotindex = len - realdigcount;
pOutStr[len + 1] = wchar_t(0);
for (int i = len; i >= dotindex; i--)
{
pOutStr[i + 1] = pOutStr[i];
};
if (realdigcount == 0)
{
pOutStr[len + 1] = L'0';
pOutStr[len + 2] = wchar_t(0);
}
else
{
int i = len;
while ((i > (dotindex + 1)) && (pOutStr[i] == L'0'))
{
pOutStr[i] = wchar_t(0);
i--;
};
};
pOutStr[dotindex] = L'.';
if (x >= 0.0) pOutStr[0] = L' '; // positive
if (if_1_1) pOutStr[1] = L'0';

return pOutStr;
};

wchar_t * MQSmallFloat80ToWCStr(wchar_t * pOutStr, const MQ_F80 x, const int realDig)
{
int realdigcount = abs(realDig);
if (realdigcount > 17)
realdigcount = 17;
MQ_F80 mul10 = 1.0L;
switch (realdigcount)
{
case 0 : mul10 = 1.0L; break;
case 1 : mul10 = 10.0L; break;
case 2 : mul10 = 100.0L; break;
case 3 : mul10 = 1000.0L; break;
case 4 : mul10 = 10000.0L; break;
case 5 : mul10 = 100000.0L; break;
case 6 : mul10 = 1000000.0L; break;
case 7 : mul10 = 10000000.0L; break;
case 8 : mul10 = 100000000.0L; break;
case 9 : mul10 = 1000000000.0L; break;
case 10 : mul10 = 10000000000.0L; break;
case 11 : mul10 = 100000000000.0L; break;
case 12 : mul10 = 1000000000000.0L; break;
case 13 : mul10 = 10000000000000.0L; break;
case 14 : mul10 = 100000000000000.0L; break;
case 15 : mul10 = 1000000000000000.0L; break;
case 16 : mul10 = 10000000000000000.0L; break;
default : mul10 = 100000000000000000.0L;
};
MQ_F80 abs_x = -fabsl(x);
bool if_1_1 = (abs_x < 1.0L) && (abs_x > -1.0L);
if (if_1_1)
abs_x -= 1.0L;
MQ_I64 i64 = MQ_I64(mul10 * abs_x);
MQInt64ToWCStr(pOutStr, i64, 10);
int len = wcslen(pOutStr);
int dotindex = len - realdigcount;
pOutStr[len + 1] = wchar_t(0);
for (int i = len; i >= dotindex; i--)
{
pOutStr[i + 1] = pOutStr[i];
};
if (realdigcount == 0)
{
pOutStr[len + 1] = L'0';
pOutStr[len + 2] = wchar_t(0);
}
else
{
int i = len;
while ((i > (dotindex + 1)) && (pOutStr[i] == L'0'))
{
pOutStr[i] = wchar_t(0);
i--;
};
};
pOutStr[dotindex] = L'.';
if (x >= 0.0L) pOutStr[0] = L' '; // positive
if (if_1_1) pOutStr[1] = L'0';

return pOutStr;
};

wchar_t * MQFloat32ToWCStrScientific(wchar_t * pOutStr, const MQ_F32 x, const int realDig)
{
int log10_x = (int)log10(x);
MQ_F32 x_1_1 = x / pow(10.0f, log10_x);
if (log10_x < 0)
{
log10_x--;
x_1_1 *= 10.0f;
};
int i = wcslen(MQSmallFloat32ToWCStr(pOutStr, x_1_1, realDig));
if (log10_x != 0)
{
pOutStr[i] = L'e'; i++;
if (log10_x < 0)
{
pOutStr[i] = L'-';
i++;
log10_x *= -1;
};
if (log10_x >= 10)
{
pOutStr[i] = (log10_x / 10) + L'0';
i++;
};
pOutStr[i] = log10_x % 10 + L'0'; i++;
pOutStr[i] = wchar_t(0);
};
return pOutStr;
};

wchar_t * MQFloat64ToWCStrScientific(wchar_t * pOutStr, const MQ_F64 x, const int realDig)
{
int log10_x = (int)log10(x);
MQ_F64 x_1_1 = x / pow(10.0, log10_x);
if (log10_x < 0)
{
log10_x--;
x_1_1 *= 10.0;
};
int i = wcslen(MQSmallFloat64ToWCStr(pOutStr, x_1_1, realDig));
if (log10_x != 0)
{
pOutStr[i] = L'e'; i++;
if (log10_x < 0)
{
pOutStr[i] = L'-';
i++;
log10_x *= -1;
};
if (log10_x >= 10)
{
pOutStr[i] = (log10_x / 10) + L'0';
i++;
};
pOutStr[i] = log10_x % 10 + L'0'; i++;
pOutStr[i] = wchar_t(0);
};
return pOutStr;
};

wchar_t * MQFloat80ToWCStrScientific(wchar_t * pOutStr, const MQ_F80 x, const int realDig)
{
int log10_x = (int)log10(x);
MQ_F80 x_1_1 = x / pow(10.0L, log10_x);
if (log10_x < 0)
{
log10_x--;
x_1_1 *= 10.0L;
};
int i = wcslen(MQSmallFloat80ToWCStr(pOutStr, x_1_1, realDig));
if (log10_x != 0)
{
pOutStr[i] = L'e'; i++;
if (log10_x < 0)
{
pOutStr[i] = L'-';
i++;
log10_x *= -1;
};
if (log10_x >= 10)
{
pOutStr[i] = (log10_x / 10) + L'0';
i++;
};
pOutStr[i] = log10_x % 10 + L'0'; i++;
pOutStr[i] = wchar_t(0);
};
return pOutStr;
};

wchar_t * MQFloat32ToWCStr(wchar_t * pOutStr, const MQ_F32 x, const int realDig)
{
MQ_F32 abs_x = fabs(x);
if ((abs_x >= 1.0e7f) || (abs_x <= 1.0e-7f))
{
return MQFloat32ToWCStrScientific(pOutStr, x, realDig);
}
else
{
return MQSmallFloat32ToWCStr(pOutStr, x, realDig);
};
};

wchar_t * MQFloat64ToWCStr(wchar_t * pOutStr, const MQ_F64 x, const int realDig)
{
MQ_F64 abs_x = fabs(x);
if ((abs_x >= 1.0e14) || (abs_x <= 1.0e-14))
{
return MQFloat64ToWCStrScientific(pOutStr, x, realDig);
}
else
{
return MQSmallFloat64ToWCStr(pOutStr, x, realDig);
};
};

wchar_t * MQFloat80ToWCStr(wchar_t * pOutStr, const MQ_F80 x, const int realDig)
{
MQ_F80 abs_x = fabs(x);
if ((abs_x >= 1.0e17L) || (abs_x <= 1.0e-17L))
{
return MQFloat80ToWCStrScientific(pOutStr, x, realDig);
}
else
{
return MQSmallFloat80ToWCStr(pOutStr, x, realDig);
};
};

char * MQWideToAnsi(char * pOutAnsiChar, const wchar_t * pWCStr)
{
int len = wcslen(pWCStr);
for (int i = 0; i <= len; i++)
{
pOutAnsiChar[i] = char(pWCStr[i]);
};
return pOutAnsiChar;
};





int main()
{
long double x = 256.0;
x /= 10000000000000000000.0;
cout << x << endl;

wchar_t wstr[64];
char str[64];
cout << MQWideToAnsi(str, MQFloat80ToWCStr(wstr, x, 20));


getchar();
getchar();

return 0;
}