Ich bin hier neu und auch kein Profi in C++.

Ich habe was gebastelt wo ich jetzt vor ein Problem stehe, und zwar möchte ich ein int füllen mit zahlen.

z.B

int zahl;

int Array [2] = {2,3};

Ich möchte jetzt das in int zahl 23 steht, also auf gut deutsch 23, ist das möglich?

Habe schon geuscht und nix darüber gefunden, und auch schon viel selbst Probiert, aber noch kein erfolg gehabt.

Kann mir da einer Helfen?

mfg

Kai

Zu deiner Frage:

int zahl = 23;

Ne gibs da eine lösung?
bzw wie kann es machen?

int zahl;
int Array[2] = {2,3};

zahl = Array[0] ?? Array[1];

?? Was für ein Operator ??

const int arrsize=2;
int arr[arrsize] = {2,3};
int zahl;
std::string tmp = "";
for(int i=0; i<arrsize;++i)
{
std::ostringstream str;
ostrstr << arr[i];
tmp += ostrstr.str();
}
zahl = atoi(tmp);

ungetestet

int Array[2] = {2,3};

int zahl = 10*Array[0] + Array[1];

Oder ne kleine Schleife:

int zahl=0;
int Array[] = {2,3};
int count = sizeof(Array)/sizeof(Array[0]);
for(int i=0;i<count;++i)
{
	zahl+=Array[i];
	if(i<count-1)
		zahl*=10;
}

Super Forum und leutz hier.

Ich habe mal das Mathematische genommen was bei 3 zahlen klapt, aber bei 4 oder 5 array wird sone rechnung voller klammern xDD

Ich habe mal das Mathematische genommen was bei 3 zahlen klapt, aber bei 4 oder 5 array wird sone rechnung voller klammern xDD

Wenn es doch bloß eine Maschine gäbe, die man programmieren könnte, so dass sie einem sich wiederholende Arbeiten abnimmt. Sollte man unbedingt mal erfinden.

unsigned Array[] = {2,3}; 
std::stringstream stream;
std::copy( std::begin(Array), std::end(Array), std::ostream_iterator<unsigned>(stream) );
auto zahl = *std::istream_iterator<unsigned long>(stream);

Naja, oder man ist ein ganz böser und geht den unperformanten Weg:

unsigned Array[] = {2,3}; 
std::stringstream stream;
std::copy( std::begin(Array), std::end(Array), std::ostream_iterator<unsigned>(stream) );
auto zahl = *std::istream_iterator<unsigned long>(stream);

Magst du nicht noch den Stringstream per zeichenweisem Copy in einen String stopfen, den du dann mit strtol in Zahlen umwandelst, die du dann mit itoa in einen vector<char> packst und den dann analysierst? Das fände ich viel naheliegender und direkter.

Ich sehe paar sachen mit dem ich nicht viel anfangen kann, gibs den da für einezlne include zb. (iostream) alle std:: optionen eine erklärung?
bzw nen Buch etc.. wo das besprochen wird? Oder eine seite geht auch.

wie gesagt lern gerade C++, und kenne schon einige sachen, außer kleine außnahmen die vil wichtig sind.

mfg

Kai

Sone schrieb:

Naja, oder man ist ein ganz böser und geht den unperformanten Weg:

unsigned Array[] = {2,3}; 
std::stringstream stream;
std::copy( std::begin(Array), std::end(Array), std::ostream_iterator<unsigned>(stream) );
auto zahl = *std::istream_iterator<unsigned long>(stream);

Magst du nicht noch den Stringstream per zeichenweisem Copy in einen String stopfen, den du dann mit strtol in Zahlen umwandelst, die du dann mit itoa in einen vector<char> packst und den dann analysierst? Das fände ich viel naheliegender und direkter.

Mein Weg ist bisher der korrekteste. Man sollte nämlich daran denken, dass in Array nicht nur Ziffern sein könnten, sondern auch zweistellige Zahlen.

Ich kannte noch net sstream und copy, aber ok, schau ich mir mal gleich sofort an, wenn ich was gescheites finde.

Aber an sich versteh ich die funktion, thx

mfg

Kai

Ohne das benchmarken zu müssen, kann ich mit Bestimmtheit sagen, dass das bedeutend schneller ist als Sones Lösung. Und auch funktioniert, wenn jemand an std::locale::global herumfummelt.

Ohne das benchmarken zu müssen, kann ich mit Bestimmtheit sagen, dass das bedeutend schneller ist als Sones Lösung.

Natürlich. Meine Variante war eine Lusche, keine Frage.

Und auch funktioniert, wenn jemand an std::locale::global herumfummelt.

Lachhaft. Sollen wir jetzt keine Streams mehr benutzen, weil die Locales befummelt sein könnten?
Genauso beschuldige ich, weil dein Beispiel nach Standard zu einem Überlauf führen wird, wenn int 16 Bit groß ist.

Man kann bestimmte Dinge über Locales annehmen. Dass

stringstream sstr;
int x;

sstr << x;
sstr >> x;

funktioniert, darf man erwarten. Aber

sstr << 1234 << 1234;

kann mit amerikanischer Locale auch mal "1,2341,234" ergeben, und dass das nachher noch parsbar ist, darauf kannst du dich nicht verlassen.

Dass 16-Bit-Integer keine Zahlen über 32767 aufnehmen können, wird sich durch kein Herumgerechne ändern lassen, ob mit oder ohne Streams. Mir ist unklar, wie das hier relevant sein sollte.

kann mit amerikanischer Locale auch mal "1,2341,234" ergeben, und dass das nachher noch parsbar ist, darauf kannst du dich nicht verlassen.

Ja, du hast Recht. Das ist tatsächlich möglich.

Das war eine so schlecht und recht auf die Schnelle hingekotzte Lösung, wo ich nichts bedacht habe.

Aber hier, siehe meine zweite Methode und prüfe gegen deine, mal sehen wer schneller ist:

#include <iostream>
#include <numeric>

int main()
{
    unsigned arr[] = { 1, 23, 4, 567, 89, 0 };

    unsigned* ptr = arr + sizeof(arr)/sizeof(*arr);

    unsigned long value = 0,
                  ct = 1;

    while( ptr-- != arr )
    {
        if( *ptr > 9 )
        {
            value += ct * (*ptr % 10);
            *ptr++ /= 10;
        }
        else
            value += ct * *ptr;

        ct *= 10;
    }

    std::cout << value;
}

Mir ist unklar, wie das hier relevant sein sollte.

Ich wollte dich nur benörgeln.

Kein Wunder bei

int append_number(int x, int y) { 
  return (y < 10 ? x : append_number(x, y / 10)) * 10 + y % 10; 
}

int array [50] = {2,3,4};
int zahl;

int speicherint ()
{
    return array[50];
}

int main ()
{
    zahl = speicherint ();
    return 0;
}

Wäre das falsch bzw schwachsin?

Wäre das falsch bzw schwachsin?

ja und ja

Ich gib der funktion nen array, und ich nim einfach den int wer der funktion was auch klapt.

Was soll da passieren?
Der int wert bekommt doch den wer des arrays hintereinander geschrieben wie ich es möchte.

Oder können da falsche werte raus kommen?

Nee, die Fuktion liefert den Wert des 51. Elements zurück, was noch nicht einmal existiert.
Außerdem werden globale Variablen verwendet, was generell schlecht ist.

Außerdem ist die Idee an sich völlig falsch, abgesehen von Schwächen in der technischen Umsetzung. So kann das nie funktionieren.

Auch wenn das Array so aussieht:

{2,0,0,0,0,0} ?

Ich bekomme trd 20 zurück, wenn er sich gerade die 20 gespeicgert hat.

Warum funzt das?

Weil bei allen anderen lösungen bekomme ich falsche werte raus, mit der funkltion nicht mehr.