Länge von Int Array bestimmen



  • Hallo,

    ich will die Länge von einem Int Array bestimmen, von dem ich eigentlich nicht weiss wie lang es wird. Bei Char Arrays kann ich ja mit

    if (variable[index] != '\0')...
    

    aber wie überprüfe ich wie lang der/das/die Array wird. Wie funktioniert das bei Int Arrays ?


  • Mod

    Bei char-Arrays geht das auch nicht. Das geht bei char-Arrays, die sich an die Konvention halten, ihr letztes Element mit 0 zu markieren, sogenannte C-Strings. Entsprechend würde das natürlich auch bei ints funktionieren, aber im Gegensatz zu Zeichenketten möchte man normalerweise keinem int einen Sonderwert zuschreiben. Allgemeine Lösung: Größe einfach merken.

    (Ganz spezielle Lösung, falls du tatsächlich ein echtes Array und keinen Zeiger auf ein Array hast: sizeof(dein_array)/sizeof(*dein_array) ist die Anzahl der Elemente)



  • sizeof(intArr). Funktioniert natürlich nicht, wenn das Array per malloc() erstellt wurde.
    EDIT: Nicht ganz korrekt. SeppJ hat die richtige Lösung.



  • int array[10]; 
    	printf("%d\n", sizeof(array) / sizeof(array[0]) );
    

    Funktioniert nicht bei dynamisch allozierten Arrays.



  • Ich habe noch eine Frage, wie kommt es, dass :

    int intarray [10240];
    
    	 while(intarray[i] != '\0') 
         {    
            fprintf(stream,"%x ",intarray [i]); 
            i++;
         }
    

    trotzdem funktioniert ?
    Ich trage ja Werte in die Array ein z.B. 5 6 7 8 und jetzt wäre die Anzahl der eingetragenen Zahlen ja 4, von Index 0 bis 3. Und falls ich es mit den angegeben Codes sowohl von icarus2 als auch von SeppJ versuche zeigt er mir halt "10240" an und hängt sich dann auf.



  • Rawr Tiger schrieb:

    Ich habe noch eine Frage, wie kommt es, dass :
    trotzdem funktioniert ?

    Was soll denn der Code ueberhaupt machen?

    Rawr Tiger schrieb:

    Ich trage ja Werte in die Array ein z.B. 5 6 7 8 und jetzt wäre die Anzahl der eingetragenen Zahlen ja 4, von Index 0 bis 3.

    Ich sehe nicht, dass irgendwelche Zahlen eingetragen werden.

    Du sollst wissen, dass

    while(intarray[i] != '\0')
    

    aequivalent ist zu

    while(intarray[i] != 0)
    

    (Ich hoffe zumindest, dass alle Implementierungen 0 verwenden, um '\0' zu codieren).



  • Du musst auch zwischen Größe des Arrays und Anzahl der gültigen Werte (Länge der Daten) unterscheiden.

    Bei char text[200] = "Hallo Welt"; ist das Array 200 Zeichen groß. Davon sind 11 Zeichen belegt (inklusive der '\0').

    Mit strlen() bekommst du 10 heraus.



  • Ich versuche eine "Verschlüsselung" zu programmieren. Hier vielleicht erst der Code und dann die Erklärung wie ich mir das Vorstelle.

    #include <stdio.h>
    #include <string.h>
    #include <time.h>
    #include <stdlib.h>
    
    int caesar (char);
    
    void crypt_retrorsum ();
    int crypt_meth2 (int*);
    int crypt_meth3 (int*);
    int crypt_meth4 (int*);
    int crypt_meth5 (int*);
    int crypt_meth6 (int*);
    int crypt_meth7 (int*);
    int crypt_meth8 (int*);
    int crypt_meth9 (int*);
    int crypt_meth10 (int*);
    int crypt_meth11 (int*);
    int crypt_meth12 (int*);
    int crypt_meth13 (int*);
    int crypt_meth14 (int*);
    int crypt_meth15 (int*);
    int crypt_meth16 (int*);
    int crypt_meth17 (int*);
    int crypt_meth18 (int*);
    int crypt_meth19 (int*);
    int crypt_meth20 (int*);
    
    void write_files (int*,bool*);
    
    int text_caesar [10240];
    
    main () {
    
         char text [10240];
         bool methlist [20];
         int i = 0;
    
         srand((unsigned)time(NULL));
    
         printf("Methodenliste: ");
    
         for(i=0; i<20; ++i)
         {  
            methlist[i] = rand() % 2;
            printf("%i", methlist[i]);
         }
    
         i = 0;
         printf("\n\nVerf\x81gbare Zeichen\n================================\n\nabcdefghijklmnopqrstuvwxyz\nABCDEFGHIJKLMNOPQRSTUVWXYZ\n0123456789\n!?,.:\"\n\x81\x84\x94 \x9A\x8E\x99\n\n(sonstige Zeichen werden nicht verschl\x81sselt)");
    
         printf("\n\nBitte Text eingeben\n================================\n\n");
         gets(text);
         printf("\n================================\n\n");
    
         while(text[i] != '\0') 
         {
            text_caesar [i] = caesar (text[i]);
            i++;
         } 
    
         crypt_retrorsum ();
    
         write_files (text_caesar,methlist);
    
    }
    
    int caesar (char textan) {
    
         switch (textan) 
               {
                case ' ' : return 42; break;
    
                case 'e' : return 7; break;
                case 'n' : return 8; break;
                case 'i' : return 9; break;
                case 's' : return 1; break;
                case 'r' : return 2; break;
                case 'a' : return 3; break;
                case 't' : return 4; break;
                case 'd' : return 5; break;
                case 'h' : return 6; break;
                case 'u' : return 15; break;
                case 'l' : return 16; break;
                case 'c' : return 17; break;
                case 'g' : return 18; break;
                case 'm' : return 19; break;
                case 'o' : return 11; break;
                case 'b' : return 12; break;
                case 'w' : return 13; break;
                case 'f' : return 14; break;
                case 'k' : return 20; break;
                case 'z' : return 26; break;
                case 'p' : return 27; break;
                case 'v' : return 28; break;
                case 'ß' : return 29; break;
                case 'j' : return 21; break;
                case 'y' : return 22; break;
                case 'x' : return 23; break;
                case 'q' : return 24; break;
    
                case 'E' : return 25; break;
                case 'N' : return 30; break;
                case 'I' : return 37; break;
                case 'S' : return 38; break;
                case 'R' : return 39; break;
                case 'A' : return 31; break;
                case 'T' : return 32; break;
                case 'D' : return 33; break;
                case 'H' : return 34; break;
                case 'U' : return 35; break;
                case 'L' : return 36; break;
                case 'C' : return 40; break;
                case 'G' : return 48; break;
                case 'M' : return 49; break;
                case 'O' : return 41; break;
                case 'B' : return 43; break;
                case 'W' : return 44; break;
                case 'F' : return 45; break;
                case 'K' : return 46; break;
                case 'Z' : return 47; break;
                case 'P' : return 50; break;
                case 'V' : return 51; break;
                case 'J' : return 52; break;
                case 'Y' : return 53; break;
                case 'X' : return 54; break;
                case 'Q' : return 55; break;
    
                case '0' : return 56; break;
                case '1' : return 57; break;
                case '2' : return 58; break;
                case '3' : return 59; break;
                case '4' : return 60; break;
                case '5' : return 65; break;
                case '6' : return 66; break;
                case '7' : return 67; break;
                case '8' : return 68; break;
                case '9' : return 69; break;
    
                case '!' : return 61; break;
                case '"' : return 62; break;
                case '.' : return 63; break;
                case ',' : return 64; break;
                case ':' : return 70; break;
                case '?' : return 71; break;
    
                case 0x81 : return 77; break; //ü
                case 0x84 : return 78; break; //ä
                case 0x94 : return 79; break; //ö
    
                case 0x9A : return 72; break; //Ü
                case 0x8E : return 73; break; //Ä
                case 0x99 : return 74; break; //Ö
    
                default : return 0;
                }
    }
    
    void write_files (int *text_caesar, bool *methlist) {  
    
         FILE *stream;
         int i = 0;
    
         if((stream = fopen("crypt","w")) == NULL) 
         {       
    		printf("\nFehler beim Oeffnen!");
    		exit(1);
    	 }
    
    	 while(text_caesar[i] != '\0') 
         {    
            fprintf(stream,"%x ",text_caesar [i]); 
            i++;
         } 
    
    	 fclose(stream);
    
    	 i = 0;
    
         if((stream = fopen("methodenliste.txt","w")) == NULL) 
         {       
    		printf("\nFehler beim Oeffnen!");
    		exit(1);
    	 }
    
         while(i != 20) 
         {    
            fprintf(stream,"%i",methlist [i]);
            i++;
         } 
    
    	 fclose(stream);
    }
    
    void crypt_retrorsum () {
    
        int text_temp [10240];
        int i = 0, r = 0;
    
        while (text_caesar[i] != '\0') {i++;}
    
        while (i != 0) 
        {
            text_temp [r] = text_caesar[i];
            i--;
            r++;
        }      
    }
    

    So, Zuerst wird halt eine "Methodenliste" erstellt, 20 stellig. Davon wird später abhängig sein, wie der Text dann verstellt wird. int crypt_meth2 - int crypt_meth20 sind provisorisch. Die erste Methode ist praktisch den Text rückwärts zu setzten. Falls nun in der Methodenliste der Index [0] = 1 ist soll die Funktion "crypt_retrorsum" den Text umstellen.
    Zum Schluss wird halt der umgestellte Text in einer Datei gespeichert und zusätzlich die Methodenliste, damit man später diese eintippen kann und das Programm zum Entschlüsseln weiss, welche Methoden verwendet wurden.

    Nachträglich editiert :

    while (text_caesar[i] != '\0') {i++;}
    

    war

    while (text_caesar[i] != '0') {i++;}
    
    for(i=0; i<20; ++i)
    

    war

    while (i != 20)
    


  • Also du willst im Prinzip Caesar implementieren? Oder sehe ich das falsch 😕



  • Warum ist text_caesar ein int-Array?
    Und warum ist es global?

    Ist bei while (text_caesar[i] != '0') {i++;} wirklich das Zeichen '0' gemeint? Das ist etwas anderes als '\0'.

    Dein crypt_retrorsum kopiert die Stelle text_caesar[0] nicht, weil die Schleife vorher abbricht.

    Zeile 45 ist eigentlisch ein Fall für eine for-Schleife. Und in C wird in Zählschleifen meist auf < statt != getestet. Also for(i=0; i<20; ++i)



  • DirkB schrieb:

    Warum ist text_caesar ein int-Array?
    Und warum ist es global?

    Ist bei while (text_caesar[i] != '0') {i++;} wirklich das Zeichen '0' gemeint? Das ist etwas anderes als '\0'.

    Dein crypt_retrorsum kopiert die Stelle text_caesar[0] nicht, weil die Schleife vorher abbricht.

    Zeile 45 ist eigentlisch ein Fall für eine for-Schleife. Und in C wird in Zählschleifen meist auf < statt != getestet. Also for(i=0; i<20; ++i)

    Naja, ich habe gelesen, dass Int Zahlen für den Computer am "natürlichsten" sind und er damit am besten arbeiten kann. Deshalb ersetzte ich erst alle eingegeben Zeichen durch Int Zahlen und stelle das um, dadurch kann man auch vielleicht schlechter nachvollziehen, dass 7 eigentlich "e" ist.
    Und Global ist es, weil ich damit vorraussichtlich öfters arbeiten werde.
    Das mit dem "\0" war es wohl. 🙄
    Aufjedenfall wurde das nun verbessert und funktioniert. Ich editiere das am besten oben, damit ich nicht wieder den ganzen Quellcode posten muss.


  • Mod

    Rawr Tiger schrieb:

    Naja, ich habe gelesen, dass Int Zahlen für den Computer am "natürlichsten" sind und er damit am besten arbeiten kann.

    Richtig und doch so falsch. Ein Computer kann nur mit Zahlen arbeiten. Deshalb sind Zeichen auch Zahlen.

    Deshalb ersetzte ich erst alle eingegeben Zeichen durch Int Zahlen und stelle das um, dadurch kann man auch vielleicht schlechter nachvollziehen, dass 7 eigentlich "e" ist.

    🙄 Du implementierst Cäsar und argumentierst mit Sicherheitsargumenten? Und noch dazu mit einem Obscurity Argument? Das ist, wie nicht zu schnell Fahrrad zu fahren, damit man nicht zu viel Benzin verbraucht.

    Und Global ist es, weil ich damit vorraussichtlich öfters arbeiten werde.

    Das ist ein besonders guter Grund, es nicht global zu machen. Denn je häufiger du ein globales Objekt benutzt, desto wahrscheinlicher bekommst du die Nachteile globaler Variablen zu spüren.


Anmelden zum Antworten