int füllen

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?

b4nan1 schrieb:

Wäre das falsch bzw schwachsin?

ja und ja

hmm ok, und warum genau?

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?

Nathan

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.

SeppJ

Nathan schrieb:

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.