int füllen

Hallo,

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

daddy_felix

Du brauchst ganz dringend ein gutes Grundlagenbuch.

Zu deiner Frage:

int zahl = 23;

Ja ich bin ja dabei C++ mir an zu eignen, bloß stecke ich da jetzt fest

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 ??

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

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

Vorschlag, der von den anderen zerrissen wird, und das sicherlich auch zu recht:

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

ahh super

wat schrieb:

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;
}

ahh danke nochmal

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

SeppJ

b4nan1 schrieb:

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.

Sone

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);

int arr[] = { 1, 2, 3 };
int val = std::accumulate(std::begin(arr), std::end(arr), 0, [](int x, int y) { return x * 10 + y; });

SeppJ

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.

Ok

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

SeppJ schrieb:

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.

Jo nice one, das ist echt die beste lösung.

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

#include <iostream>
#include <numeric>

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

int main() {
  int arr[] = { 1, 23, 4, 567, 89, 0 };
  int val = std::accumulate(std::begin(arr), std::end(arr), 0, append_number);

  std::cout << val << '\n';
}

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.

Sone

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.

Hältst du es wirklich für eine sinnvolle Idee, beim Rechnen mit Zahlen den Umweg über Stringstreams und menschenlesbare Darstellungen zu gehen? Das ist doch albern. Und selbstverständlich muss man beim Arbeiten mit Streams beachten, dass da eine Locale zwischenhängt.

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.

Sone

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.

Sone

Ergebnis: Meins ist ca. 3-4 mal schneller.
http://ideone.com/xaVu7H

Kein Wunder bei

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

Wieso nicht

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?