3. int füllen

int füllen

  • S

    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.

    0
  • ?

    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

    0
  • ?
     

    #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.

    0
  • S

    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.

    0
  • ?

    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.

    0
  • S

    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. 🙂 😉

    0
  • S

    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; 
}
    0
  • ?

    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?

    0
  • ?

    b4nan1 schrieb:

    Wäre das falsch bzw schwachsin?

    ja und ja

    0
  • ?

    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?

    0
  • N

    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.

    0
  • Mod

    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.

    0
  • ?

    Ok, und warum funzt das?

    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.

    0
  • N

    b4nan1 schrieb:

    Ok, und warum funzt das?

    Zufall.

    0
  • ?

    Volkard schrieb:

    nonsens detect0r schrieb:

    warum wurde mein code gelöscht?

    Hab's für Trollerei gehalten.

    @nonsens detect0r:
    dein code hat zu sehr nach c ausgesehen. du musst schon was mit templates oder der boost library posten, sonst ist das zu einfach und wird als trollerei eingestuft!

    0
  • ?

    Ok stimmt, das funzt doch net immer.

    hmmm ok, ja ich möchte nicht meine Klasse hier Posten die ich gerade schreibe, das Problem ist, ich muss den array in int füllen, und das geht anscheind nicht so einfach, da ich entweder die größe deffinieren muss was zum problem führt, da sonst nur noch 0 hinten sind, die er entweder mit copy mit kopiert und was komisches raus kommt, oder copy geht erst nicht, wenn das array keine größe angegeben hat.

    Was macht man da?

    0
  • N

    std::array nutzen.

    0
  • ?

    Naja ok, ich Poste doch mal die Klasse hier rein.

    Vorab, das soll ein int crypt werden da ich es für mein programm brauche.
    Dwer int soll eine zahl bekommen, womit kein Mensch arbeiten kann bzw ändern kann, ohne zu wissen was das wirklich für eine Zhal ist.
    Da die zahlen in einer datei stehen die man öffnen kann, sollen die alle einen anderen wert bekommen, womit nur das programm arbeiten kann.

    PS Ich weiss das ist net gut, aber es reicht mir erstmal auch in die Sprache rein zu kommen, und sicher ist es auch nicht, also bitte kein flame 🙂

    //    CRYPT_H    //

#ifndef CRYPT_H
#define CRYPT_H

#include <iostream>
#include <string>
#include <sstream>

// Variabel zum Auslesen (while schleife)
int k = 0;

// Zähler
int z = 0;

// Index für Key (3Zahlen) Entschlüsseln
int keyindex = 2;

// Schalter für AN/AUS
bool cryptS = true;
unsigned int keyzahl[2];

#define C0 126
#define C1 405
#define C2 381
#define C3 953
#define C4 735
#define C5 628
#define C6 794
#define C7 761
#define C8 638
#define C9 483

class crypt
{
private:
	// Variabeln
	unsigned int schlüssel[50];
	// unsigned int keyzahl[50];

	// Ergebnis Übergabe INT (Entschlüsselt)
	unsigned int ergebnis;

	// Zerlegter Key (3)
	int key3[3];

	struct codeint
	{
		int code0;
		int code1;
		int code2;
		int code3;
		int code4;
		int code5;
		int code6;
		int code7;
		int code8;
		int code9;
	};

public:

	// INSTACE (INT)
	codeint CODEINT;

	// Erzeuge Code INT
	void erzeugecode ()
	{
		CODEINT.code0 = 94;
		CODEINT.code1 = 63;
		CODEINT.code2 = 72;
		CODEINT.code3 = 41;
		CODEINT.code4 = 21;
		CODEINT.code5 = 11;
		CODEINT.code6 = 35;
		CODEINT.code7 = 85;
		CODEINT.code8 = 56;
		CODEINT.code9 = 88;
	}

	// Prüfe auf INT
	bool pvorhanden (int txt)
	{
		if (txt >= 0)
		{
			return true;
		}
		else
		{
			return false;
		}
	}

	// Auslesen
	void ausleseint (int zahl)
	{
		int temp;
		while(zahl)
		{ 
			temp = zahl%10;
			zahl/=10;
			speicherint (temp);
		}
		cryptS = false;
	}

	// Verschlüssel INT
	void verschlüsselint (int txt)
	{
		// Übergabe zu Schlüssel
		int u = NULL;

		k++;
		while (k == 1)
		{
			ausleseint (txt);
		}

		if (pvorhanden(txt) == true && cryptS == true)
		{
			if (txt == 0)
			{
				u = CODEINT.code0;
				schlüssel[z] = u + C0;
				std::cout << schlüssel[z];
			}else if (txt == 1)
			{
				u = CODEINT.code1;
				schlüssel[z] = u + C1;
				std::cout << schlüssel[z];
			}else if (txt == 2)
			{
				u = CODEINT.code2;
				schlüssel[z] = u + C2;
				std::cout << schlüssel[z];
			}else if (txt == 3)
			{
				u = CODEINT.code3;
				schlüssel[z] = u + C3;
				std::cout << schlüssel[z];
			}else if (txt == 4)
			{
				u = CODEINT.code4;
				schlüssel[z] = u + C4;
				std::cout << schlüssel[z];
			}else if (txt == 5)
			{
				u = CODEINT.code5;
				schlüssel[z] = u + C5;
				std::cout << schlüssel[z];
			}else if (txt == 6)
			{
				u = CODEINT.code6;
				schlüssel[z] = u + C6;
				std::cout << schlüssel[z];
			}else if (txt == 7)
			{
				u = CODEINT.code7;
				schlüssel[z] = u + C7;
				std::cout << schlüssel[z];
			}else if (txt == 8)
			{
				u = CODEINT.code8;
				schlüssel[z] = u + C8;
				std::cout << schlüssel[z];
			}else if (txt == 9)
			{
				u = CODEINT.code9;
				schlüssel[z] = u + C9;
				std::cout << schlüssel[z];
			}
		}
		z++;
	}

	// Speicher Zerlegten INT - Verschlüssel
	void speicherint (int txt)
	{
		int *ptr = new int;
		*ptr = txt;
		verschlüsselint (*ptr);
		*ptr=0; 
		delete ptr; 
	}

	// Speicher Zerlegten INT - Entschlüssel
	void speicherschlüssel (int txt)
	{
		int *ptr = new int;
		*ptr = txt;
		key3[keyindex] = *ptr;
		keyindex--;
		if (keyindex == -1)
		{
			keyindex = 2;
		}
		*ptr=0; 
		delete ptr;
	}

	// Entschlüssel INT
	void entschlüsselint (unsigned int code)
	{
		// Index
		int g = 0;

		// Zähler für Zerlgen (Schleife)
		int y = 0;

		// Zerlege Code
		while (code)
		{
			while (y<3)
			{
				int temp;
				temp = code%10;
				code/=10;
				speicherschlüssel (temp);
				y++;
			}
			y = 0;
			if (key3[0] == 2 && key3[1] == 2 && key3[2] == 0)
			{
				keyzahl[g] = 0;
				std::cout << keyzahl[g];
				g++;
			}else if (key3[0] == 4 && key3[1] == 6 && key3[2] == 8)
			{
				keyzahl[g] = 1;
				std::cout << keyzahl[g];
				g++;
			}else if (key3[0] == 4 && key3[1] == 5 && key3[2] == 3)
			{
				keyzahl[g] = 2;
				std::cout << keyzahl[g];
				g++;
			}else if (key3[0] == 9 && key3[1] == 9 && key3[2] == 4)
			{
				keyzahl[g] = 3;
				std::cout << keyzahl[g];
				g++;
			}else if (key3[0] == 7 && key3[1] == 5 && key3[2] == 6)
			{
				keyzahl[g] = 4;
				std::cout << keyzahl[g];
				g++;
			}else if (key3[0] == 6 && key3[1] == 3 && key3[2] == 9)
			{
				keyzahl[g] = 5;
				std::cout << keyzahl[g];
				g++;
			}else if (key3[0] == 8 && key3[1] == 2 && key3[2] == 9)
			{
				keyzahl[g] = 6;
				std::cout << keyzahl[g];
				g++;
			}else if (key3[0] == 8 && key3[1] == 4 && key3[2] == 6)
			{
				keyzahl[g] = 7;
				std::cout << keyzahl[g];
				g++;
			}else if (key3[0] == 6 && key3[1] == 9 && key3[2] == 4)
			{
				keyzahl[g] = 8;
				std::cout << keyzahl[g];
				g++;
			}else if (key3[0] == 5 && key3[1] == 7 && key3[2] == 1)
			{
				keyzahl[g] = 9;
				std::cout << keyzahl[g];
				g++;
			}
			else
			{
				system ("cls");
				std::cout << "ERROR";
			}
		}

		if (!code)
		{
			ergebniszahl ();
		}
	}

	// Ergebnis der Entschlüsselung fertig in INT
	int ergebniszahl ()
	{
		/*
		unsigned int tt[] = {2,3,56};
		 std::stringstream stream; 
 std::copy( std::begin(keyzahl), std::end(keyzahl), std::ostream_iterator<unsigned>(stream) ); 
auto zahl = *std::istream_iterator<unsigned long>(stream);
		return zahl;
		*/
	}

	// Konstrukor
	crypt ()
	{
		erzeugecode ();
	}
};

// INSTANCE
extern crypt CRYPT;

#endif
    0
  • Mod

    b4nan1 schrieb:

    Vorab, das soll ein int crypt werden da ich es für mein programm brauche.
    Dwer int soll eine zahl bekommen, womit kein Mensch arbeiten kann bzw ändern kann, ohne zu wissen was das wirklich für eine Zhal ist.
    Da die zahlen in einer datei stehen die man öffnen kann, sollen die alle einen anderen wert bekommen, womit nur das programm arbeiten kann.

    Das ist vergebene Mühe. Alles was dein Programm lokal macht, steht jedem zur Betrachtung offen, egal ob direkt in die Executable geschrieben oder erst zur Laufzeit berechnet.

    0
  • ?

    Wie zu betracht? hier meinste?

    Werte werde ich dann natürlich abändern, oder wie meinste das?

    Ist klar das für Crack- Hack futzis das kein problem ist.

    ICH HABE AUCH NET LINUX GESCHRIEBEN 🙂

    0
Anmelden zum Antworten