mit 64bit int rechnen -> ausgeben

ich hab mir mittlerweile einen wolf gesucht hier und per google
etliches ausprobiert aber nichts hat funktiniert

compiler VC++ 6.0 sp5

die aufgabe:
a) grundrechenarten
b) ergebnis als errocode ausgeben (wird in einem script weiterverwendet)

# include <iostream>
# include <stdio.h>
# include <stdlib.h> 
using namespace std;

# define int64 __int64
//# include <stdint.h>

int main (int argc, char **argv)
{

cout <<"["<<argv[1]<<"]"<<endl<<endl;
cout <<"["<<argv[2]<<"]"<<endl<<endl;
cout <<"["<<argv[3]<<"]"<<endl<<endl;

int64 a,b,result;

//unsigned __int64 a  = atoi(argv[1]);
//unsigned __int64 b  = atoi(argv[3]);

a  = 500000000;
b  = 100000000;

result=a-b;

return result;
}

ergebnis: -294967296

habs auch mit
# include <stdint.h>
versucht

hab auch versucht es per cout auszugeben
error C2593: 'Operator <<' ist mehrdeutig

thx

entelechie

hm.
atoi wandelt ja nur in einen int um.
so ist es auch mit der main funktion, die gibt einen "einfachen" int
zurueck.

leider weiss ich nicht, ob es fuer int64 eine analoge funktion
zu atoi gibt.

aber es gibt noch eine Int64-Struktur. die besitzt eine memberfunktion
Parse.

0x00000001

Es gibt die Funktion _atoi64().

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vccore98/html/_crt_atof.2c_.atoi.2c_._atoi64.2c_.atol.asp

Das Gegenstück ist i64toa().

Aber wie Du einen 64Bit Wert zurückgeben willst weiß ich nicht, ka ob das gehen kann.

hab den code(kot) mal nach euren vorschlaegen abgeaendert, danke an dieser stelle
auch gebe ich jetzt per printf aus

int main (int argc, char **argv)
{

cout <<"["<<argv[1]<<"]"<<endl;
cout <<"["<<argv[2]<<"]"<<endl;
cout <<"["<<argv[3]<<"]"<<endl;

int64 a,b,result;

a  = _atoi64(argv[1]);
b  = _atoi64(argv[3]);
//a  = 5000000000;
//b  = 1000000000;

printf( "argv[1]=""%d\n",a);
printf( "argv[3]=""%d\n",b);

result=a-b;

return result;
}

die ausgabe

rechner1 5000000000 - 1000000000
[5000000000]
[-]
[1000000000]
argv[1]=705032704
argv[3]=1000000000
-294967296

die parameter werden richtig uebergeben
aber danach nach int32 konvertiert und nicht in int64

der compiler meckert auch NICHT das er jetzt in64 nach int verkuerzt haette

um herauszufinden obs an _atoi64 liegt habe ich a mit 5milliarden eingetragen
wanderlt er automatisch nach int32

fuer mich liegt das problem hier:
int64 a,b,result;

obwohl ich ihm sage bitte 64bit nutzt er nur 32

zur ausgabe (errorlevel):
ich denke auch nicht das es moeglich ist 64bit auszugeben
aber wenn ich den 64bit int in einen string konvertiere sollte es gehen?!

Phobos

Dass du nur eine 32 bit Ausgabe hast, liegt daran, dass printf auch keine 64-bit Werte verarbeiten kann. Du solltest mit _i64toa die Zahl in einen String konvertieren und den dann ausgeben.

Oliver

Statt "%d", "%I64d" nehmen.

Erhard Henkes

Genau! Wie geht das eigentlich mit cout << ...? Da habe ich noch nichts für _int64 gefunden. long long verabeitet nicht jeder Compiler (z.B. MSVC++6). Mit aktuellem Dev-C++ kann man gemäß Standard cout und long long verwenden, siehe z.B. http://www.henkessoft.de/cpp_konsole.htm Abschnitt 1.5 letztes Programm.

Oliver

Oder so:

ostream& operator <<(ostream& os,__int64 i)
{
	char num[21];
	return os << _i64toa(i,num,10);
}

ostream& operator <<(ostream& os,unsigned __int64 i)
{
	char num[21];
	return os << _ui64toa(i,num,10);
}

Nemesyzz
vc++ sag dazu nur:

error C2601: '<<' : Lokale Funktionsdefinitionen sind unzulaessig

Oliver

Ja doch nicht innerhalb einer Funktion.

so. z.B.

ostream& operator <<(ostream& os,__int64 i) 
{ 
    char num[21]; 
    return os << _i64toa(i,num,10); 
} 

ostream& operator <<(ostream& os,unsigned __int64 i) 
{ 
    char num[21]; 
    return os << _ui64toa(i,num,10); 
}

int main()
{
    cout << unsigned __int64(-1);
}

Erhard Henkes

Warum ist das eigentlich nicht von Anfang an beim MSVC++6 dabei gewesen? Wenn man _int64 bietet, sollte das doch auch problemlos via cout und nicht nur mittels printf(...) darstellbar sein.
Da lobe ich mir den Dev-C++:

#include <iostream>
#include <conio.h>

int main() 
{ 
    std::cout << static_cast<unsigned short>     (-1) << std::endl; 
    std::cout << static_cast<unsigned long>      (-1) << std::endl; 
    std::cout << static_cast<unsigned long long> (-1) << std::endl; 
	getch();
}

Wie sieht so etwas eigentlich portabel aus? "long long" findet man doch genau so wenig im C++-Standard wie _int64, wenn ich nicht irre.

ISO/IEC 14882:1998(E), 3.9.1 Fundamental types:
"There are four signed integer types: “signed char”, “short int”, “int”, and “long int.” In this list, each type provides at least as much storage as those preceding it in the list. Plain ints have the natural size suggested by the architecture of the execution environment; the other signed integer types are provided to meet special needs."

mit 64bit int rechnen -&gt; ausgeben

mit 64bit int rechnen -> ausgeben