Array Liste übergeben

  • Moin,
    mit

    Code
    static int ra8875_init_sequence[] = {
    	0x0A, 0x02,
    	0x0C, 0x82,
    	0x3B, 0x00, 0x01, 0x00, 0x05,
    	0x0F, 0x01, 0x02, 0x00, 0x07, 0x00, 0x09};


    kann ich ein Array deklarieren UND auch gleich befüllen.

    Wie kann ich die "Liste" {0x0A, 0x02, ......} zur Laufzeit übergeben, ohne mit einer Schleife auf jedes Element einzeln zuzugreifen?

    klappen hier nicht!

    Gruß
    Pf@nne

  • Hallo, altes Bratrohr ;) ...

    äh ... ich versteh jetzt nicht, wo die Übergabe erfolgt ... :s
    n' bisschen unglücklich/verwirrend wie ich finde.
    Was ich da sehe, sind zwei Versuche einer Definition ... aber keine Übergabe.
    Vielleicht magst Du das ja mal etwas ausführlicher erklären ... evtl. mit Pseudo-Code.

    //EDIT:
    hmm ... gerade erst gesehen, sorry:
    Einem Array kannst Du niemals was übergeben. Übergeben kannst Du z.B. etwas an eine Funktion.
    Was Du meinst, ist wohl eine Zuweisung?
    Da würden Pointer zum Einsatz kommen. Aber so genau kann ich das jetzt nicht sagen, weil ich noch nicht richtig verstanden habe, was Du willst.

    ciao,
    -ds-

  • Hallo zusammen,
    vielleicht meint er so etwas (ist jetzt aber Python):

    angenommen dies sei ein array (in Python gibt es keine arrays):

    Code
    blablub = {1, ..., n}

    und jetzt will er anstelle von:

    Code
    liste = []
    for item in blablub:
        liste.append(item)

    so etwas haben (in einem Rutsch):

    Code
    bliblab = list(blablub)

    so long
    Perlchamp

    --- wer lesen kann, ist klar im Vorteil ---

    --- man sollte keine Dummheit zweimal begehen, die Auswahl ist schließlich groß genug ---

    --- der Fortschritt der Menschheit ist das Werk der Unzufriedenen ---

    --- Freude entsteht aus Mangel an Information ---

    --- Scheiße ist, wenn der Furz etwas wiegt ---

  • Hallo Pfanne,

    geht's mit

    Code
    return ra8875_init_sequence

    Das wäre mein erster Versuch ...


    Beste Grüße

    Andreas

    Ich bin wirklich nicht darauf aus, Microsoft zu zerstören. Das wird nur ein völlig unbeabsichtigter Nebeneffekt sein.
    Linus Torvalds - "Vater" von Linux

    Linux is like a wigwam, no windows, no gates, but with an apache inside dancing samba, very hungry eating a yacc, a gnu and a bison.

  • Jippp, so isses.....

    Zitat

    Was Du meinst, ist wohl eine Zuweisung?


    Ja, ist richtig, da habe ich mich "etwas" unklar ausgedrückt......
    Die Frage sollte heißen, wie kann ich einem Rutsch mehreren Elementen eines vorhandenen Arrays Werte zuweisen ohne dabei z.B.

    • jedes Element einzeln anzusprechen z.B. Array[0] = 0x20
    • die Daten aus einem anderen bereits vorhandenen Array mit z.B. memcpy zu verwenden.

    Ich denke die Antwort wurde schon gegeben...

    Zitat

    > Wie kann ich zur Laufzeit einem Array eine "Liste" in der Form übergeben?
    Gar nicht. Diese Form versteht nur der Compiler.


    Das klingt plausibel, die Zuweisung nach der Initialisierung übernimmt dann wohl der Compiler.

    Da es bei der Deklaration möglich ist, hätte gedacht, dass es zu Laufzeit auch mit einer Art Liste {Wert1, Wert2, ....} möglich wäre.

    Gruß
    Pf@nne

    Einmal editiert, zuletzt von Pfanne (8. Juni 2014 um 13:00)

  • Hi pfanne ... und alle anderen auch, logisch :) ...

    Zunächst hat Tell da recht. Hintergrund:
    Variable sind per default nur lokal sichtbar und liegen deshalb z.B. auf dem Stack. Nach Ende der Funktion wird der wieder an das System zurückgegeben, und somit sind die Variaben (Speicherzellen) weg ... es ist also durchaus sinnvoll, dass das nicht geht.

    Möglicher workaround wären jetzt pointer ( mein Lieblingsthema :) ).
    Das erste Element eines char[] ist vom Prinzip her nichts anderes als ein char*.

    Spoiler anzeigen


    main() {
    char hello[] = "Hello World"
    //
    // Du kannst also entweder:
    //
    printf("%s\n", hello);
    //
    // oder
    //
    printf("%s\n", &hello[0]);
    //
    // angeben, funktioniert beides.
    //
    }

    oder

    main() {
    char *hello = "Hello World"
    //
    // Hier kannst Du genauso:
    //
    printf("%s\n", hello);
    //
    // sagen, oder auch
    //
    printf("%s\n", &hello[0]);
    //
    // sagen, obwohl es auf den ersten Blick kein Element [0] gibt.
    //
    }

    Das gilt jetzt nicht nur für den Typen char, sondern für alle anderen Typen inkl. Strukturen, Unions und was da sonst noch so kreucht und fleucht.
    Ebenfalls gleich ist bei allen, dass die Elemente mit dem Index ansprechbar sind.
    Der Unterschied ist jetzt die Speichertechnik, aber lassen wir diese technischen Details ;) ...

    Wenn Du jetzt statt eines int[] einen int* verwendest, kannst du diesen Pointer sehr wohl verändern, so dass er nachher auf einen anderen Bereich zeigt.
    Forderst Du jetzt z.B. mit malloc(), calloc(), ... einen Bereich an, kannst Du da Deine Werte ablegen.
    Dieser Bereich ist wiederum nicht lokal, sondern er wird reserviert, bis Du ihn explizit freigibst.
    Nun, und da es nicht nur char[] gibt, sondern auch int[], geht das wiederum auch mit allen Typen.

    Kannst Du folgen?
    Soll ich weitermachen, oder schaust Du lieber nach, ob es nicht einen Listentyp in C++ gibt, den Du dann einfach zuweisen kannst ;) ...

    cheers,
    -ds-

  • > Soll ich weitermachen, oder schaust Du lieber nach, ob es nicht einen Listentyp
    > in C++ gibt, den Du dann einfach zuweisen kannst
    In diesem Fall nicht std::list sondern std::vector verwenden.

    Der kann problemlos zugewiesen werden und hat praktischerweise auch eine
    size-Methode. In C++ besser den verwenden als ein Array.

    In C++11 gibt es sogar einen Overload von operator= der eine Initializer-List
    nimmt ;-). Es ist also moeglich, dass vec = { 1, 2, 3 } tatsaechlich compiliert.
    Wenn nicht, braucht es halt eine explizite Initializer-List.

    Bei C++11 gibt es zudem ein std::array, wenn es unbedingt eine fixe
    Groesse haben soll. So auf die Schnelle habe ich aber keinen operator=
    gefunden.

    Einmal editiert, zuletzt von Tell (8. Juni 2014 um 16:42)

  • Danke erstmal.....

    Wir wollen es nicht unnötig kompliziert machen......
    War ja ne Frage ob es so etwas in C nicht in "einfach" gibt.
    Bevor ich jetzt noch anfange im Kernel-Modul Zeiger zu verbiegen mache ich es lieber klassisch...... :shy:

    Um das ganze abzuschließen hier noch der zugehörige Code-Abschnitt:

    Ich möchte verschiedene statische (Konstanten) Arrays (alle gleich groß)


    je nach Auflösung in ein leeres Array kopieren, um dieses dann weiter zu verwenden.

    Ich könnte natürlich auch innerhalb der If-Abfrage jedes Element einzeln zuweisen

    Code
    ra8875_init_sequence[0] = 0x01
    ra8875_init_sequence[1] = 0x02
    ....

    Ich finde die Variante mit den Konstanten aber schöner / übersichtlicher und habe sie deshalb gewählt.

    Daher wäre so etwas schön gewesen:

    Code
    if ((par->info->var.xres == 640) && (par->info->var.yres == 480)) {
    		display_size = 3;
    		ra8875_init_sequence[] = {
    		0x0B, 0x02,
    		0x0C, 0x01,
    		0x4F, 0x05, 0x0F, 0x01, 0x00,
    		0xDF, 0x01, 0x0A, 0x00, 0x0E, 0x00, 0x01};
    	}


    Gruß
    Pf@nne

  • > War ja ne Frage ob es so etwas in C nicht in "einfach" gibt.
    Hmm, warum nicht gleich diesen Code posten ?

    Jetzt koennen wir naemlich genau die richtige Antwort geben: POINTER !

    init_sequence kann jetzt genau wie ein Array verwendet werden.

    Es gibt nur zwei Unterschiede zum Array:
    * sizeof gibt einen kleineren Wert als beim Array
    * Man kann init_sequence an einen anderen Ort zeigen lassen

    Noch was: sollten die Elemente im Array nicht eher unsigned char sein ?

    Einmal editiert, zuletzt von Tell (8. Juni 2014 um 21:32)

  • Zitat

    > War ja ne Frage ob es so etwas in C nicht in "einfach" gibt.
    Hmm, warum nicht gleich diesen Code posten ?


    Konnte ja keiner ahnen, dass wir hier voll einsteigen....:rolleyes:

    Den Vorschlag werde ich morgen gleich umsetzen.....
    Ich hoffe, dass das auch in einem Kernel-Modul funktioniert.....

    Vielen Dank....
    Wieder was dazu gelernt, womöglich gewöhne ich mich noch an C.....:auslachen:


    Gruß
    Pf@nne

    EDIT:
    Char würde in diesem Fall (1Byte) auch gehen, kann aber auch mal ein Word (2Byte) werden.

    Einmal editiert, zuletzt von Pfanne (8. Juni 2014 um 21:59)

  • Hi Pfanne,
    ha! sach ich doch ... Pointer ... :thumbs1:

    zum Thema Kernelmodul:
    das ist etwas kniffliger ...
    Wenn Du Daten aus dem User-Space in den Kernel bzw. vom Kernel-Space in den User-Space kopieren willst, dann musst Du copyin(), copyout() verwenden ( siehe -> hier <- ). Das ist zwar jetzt BSD, ist aber erst mal egal.
    So was ist typisch für Parameterübergaben via ioctl() usw., denn sonst bekommst Du Ärger mit dem Memory-Manager.
    Es ist nicht möglich, vom User-Space auf den Kernel-Space zuzugeifen und vice versa.

    Ach ja: Das mit dem Word ist so ne Sache ...
    So was führt gerne mal zu Missverständnissen. Früher hiess das mal Maschinenwort - der Clou ist, das wäre eine Registerbreite und damit entweder 8, 16, 32, 64 Bit ...

    Besser: uint16_t oder int16_t ...

    Dann einfach den grösseren Wert nehmen und gut ist ...


    ...
    Wieder was dazu gelernt, womöglich gewöhne ich mich noch an C.....:auslachen:
    ...

    Du wirst es lieben, wenn wir hier mit Dir fertig sind :fies: ...

    Bis denne,
    -ds-

Jetzt mitmachen!

Du hast noch kein Benutzerkonto auf unserer Seite? Registriere dich kostenlos und nimm an unserer Community teil!