1. Foren
  2. Kommentare
  3. Security
  4. Alle Kommentare zum Artikel
  5. › Raspberry Pi: Das Selbstbau-Handy aus…

****

  1. Thema

Neues Thema Ansicht wechseln


  1. ****

    Autor: ahoihoi 31.12.18 - 10:29

    Ist die ** eigentlich der Star der Story?
    Ich mein der Rest kann es nicht sein, da nichts Weltbewegendes oder Neues.



    1 mal bearbeitet, zuletzt am 09.01.19 15:17 durch ap (Golem.de).

  2. ***

    Autor: Oktavian 31.12.18 - 11:33

    > Ist die **** eigentlich der Star der Story?

    Vor allem, wenn ich mir das Ding so angucke, ist es nicht einmal ****. Es ist eine Plastikdose, die ich öfter im real gesehen habe.



    2 mal bearbeitet, zuletzt am 09.01.19 15:33 durch ap (Golem.de).

  3. ****

    Autor: ahoihoi 31.12.18 - 11:43

    Skandal!



    1 mal bearbeitet, zuletzt am 09.01.19 15:18 durch ap (Golem.de).

  4. ******

    Autor: korona 31.12.18 - 12:20

    Verstehe ich auch nicht. Vor allem gibt es Gehäuse mit Displays oder wenn sie schon in einem Hacker Spacey war hatte sie sich ja selber eines entwerfen und drucken können. Davon hätte sie ja eine Anleitung rein stellen können...



    1 mal bearbeitet, zuletzt am 09.01.19 15:18 durch ap (Golem.de).

  5. ******

    Autor: Eheran 01.01.19 - 13:00

    Dafür müsste man aber noch CAD können. Man kann als Anfänger aber nicht alles.

    Ich verzweifel beim Programmieren auch immer wieder und schaffe es aktuell nicht, eine Library ein bisschen anzupassen. Weil deren Programmierung gefühlt eine ganz andere Welt ist, als einfach C++. Was da für komische "Operatoren" zu sehen sind... keine Ahnung, was die machen. Ich weiß nicht mal, wie ich danach googlen soll, weil mir die Begriffe dafür komplett fehlen. Hier, das ist für mich nur WTF:

    for (ppelt = &this->customElts; *ppelt != NULL; ppelt = &(*ppelt)->next)
    {
    int cmp = strcmp(sentenceName, (*ppelt)->sentenceName);
    if (cmp < 0 || (cmp == 0 && termNumber < (*ppelt)->termNumber))
    break;
    }

    Was ist das , wie nennt man es, welche Funktion haben diese Sachen:
    ->
    *
    = &
    = &(*ppelt)-> (Warum die extra Klammer)



    1 mal bearbeitet, zuletzt am 09.01.19 15:18 durch ap (Golem.de).

  6. ******

    Autor: Ach 01.01.19 - 13:18

    korona schrieb:
    --------------------------------------------------------------------------------
    > Verstehe ich auch nicht. Vor allem gibt es Gehäuse mit Displays oder wenn
    > sie schon in einem Hacker Spacey war hatte sie sich ja selber eines
    > entwerfen und drucken können. Davon hätte sie ja eine Anleitung rein
    > stellen können...

    Das wären dann aber keine Hausmittel mehr. Damit es wirklich jeder Laie nachstellen kann, sollte zumindest für das Design nur auf Wohnutensilien zurückgegriffen werden, finde ich. Z.B. eine Gabel als Antenne, einen Topflappen als Etui, wenn du weist was ich meine. Was dabei heraus käme wäre "Ninapp " [Ninapp is not a professionell Phone].

    Damit hätte das Projekt zumindest etwas Herausstehendes, nachdem ich nach nur einem kurzen Amazon Besuch feststellen musste, dass tatsächlich schon sehr viel mit selbst gebastelten Telefonen experimentiert wird. Oder der Vortrag hätte einen Überblick geben müssen, was inzwischen bereits alles machbar ist.



    2 mal bearbeitet, zuletzt am 09.01.19 15:30 durch ap (Golem.de).

  7. *****

    Autor: Tuxgamer12 02.01.19 - 13:56

    Eheran schrieb:
    --------------------------------------------------------------------------------
    > Weil deren Programmierung
    > gefühlt eine ganz andere Welt ist, als einfach C++. Was da für komische
    > "Operatoren" zu sehen sind... keine Ahnung, was die machen. Ich weiß nicht
    > mal, wie ich danach googlen soll, weil mir die Begriffe dafür komplett
    > fehlen.

    Am besten suchst mal nach "C-Tutorial" ;).

    C ist nicht wirklich schwer, aber auch nicht nur "gefühlt" eine ganz andere Welt als C++.



    1 mal bearbeitet, zuletzt am 09.01.19 15:19 durch ap (Golem.de).

  8. ******

    Autor: janoP 02.01.19 - 18:03

    Eheran schrieb:
    --------------------------------------------------------------------------------
    > Dafür müsste man aber noch CAD können. Man kann als Anfänger aber nicht
    > alles.
    >
    > Ich verzweifel beim Programmieren auch immer wieder und schaffe es aktuell
    > nicht, eine Library ein bisschen anzupassen. Weil deren Programmierung
    > gefühlt eine ganz andere Welt ist, als einfach C++. Was da für komische
    > "Operatoren" zu sehen sind... keine Ahnung, was die machen. Ich weiß nicht
    > mal, wie ich danach googlen soll, weil mir die Begriffe dafür komplett
    > fehlen. Hier, das ist für mich nur WTF:
    >
    > for (ppelt = &this->customElts; *ppelt != NULL; ppelt = &(*ppelt)->next)
    > {
    > int cmp = strcmp(sentenceName, (*ppelt)->sentenceName);
    > if (cmp < 0 || (cmp == 0 && termNumber < (*ppelt)->termNumber))
    > break;
    > }
    >
    > Was ist das , wie nennt man es, welche Funktion haben diese Sachen:
    > ->
    > *
    > = &
    > = &(*ppelt)-> (Warum die extra Klammer)

    * bei einer Variablendeklaration deklariert einen Pointer, * bei einer Zuweisung löst einen Pointer wieder auf.

    Ein Pointer ist eine Referenz auf eine Speicheradresse. Wenn du also schreibst
    int funktion(char *variable){
    , dann ist „variable“ in der Funktion quasi ein Integer, der eine Adresse im Speicher beinhaltet. Wenn du den eigentlichen Inhalt dieser Adresse, also das was an dieser Stelle im Speicher liegt, haben willst, kannst du das per *variable auflösen.

    printf(variable);
    gibt die also die Speicheradresse;
    printf(*variable);
    gibt dir den Wert, der tatsächlich dahinter liegt.

    Wenn du die Funktion jetzt aufrufen willst, darfst du ihr natürlich nicht direkt einen char übergeben, sonst arbeitest du in der Funktion mit einem Pointer auf eine Speicheadresse, die dem ASCII-Wert des Zeichens entspricht. Wenn du also funktion('A'); aufrufen würdest, dann würde die Variable „variable“ in der Funktion auf die Stelle 65 im Speicher zeigen (weil 'A' das 65. ASCII-Zeichen ist). Das willst du wahrscheinlich nicht. Du musst die Speicheradresse einer vorher deklarierten Variable übergeben.

    Das macht & – du kannst also schreiben
    char buchstabe = 'A';
    funktion(&buchstabe);

    Dann wird die Speichedresse von der Variable buchstabe übergeben, und du kannst in der Funktion mit *variable arbeiten, was dann 'A' ist. Das coole (oder auch verwirrende) daran: Wenn du in der Funktion *variable veränderst, ändert sich auch buchstabe außerhalb der Funktion. Denn variable zeigt ja auf die Speicheradrese von buchstabe.

    Das gleiche Prinzip gibt es auch in Objektorientierten Sprachen – da werden bei Objekten meistens nur die Referenzen übergeben, mitunter gibt es dann die Unterscheidung von primitiven Datentypen, die standardmäßig bei Funktionaufrufen kopiert werden. Das ist bei C anders, da gibt es nur primitive Datentypen, und wenn man eine Referenz braucht, muss man das schreiben.

    Fun Fact: Pointer und Arrays sind bei C das gleiche. Die Syntax variable[0] ist identisch mit *variable (löst die Speicheradresse von variable auf), variable[1] löst die Speicheradresse eine Speichereinheit hinter variable auf. Damit kann man viel Unfug bauen – wenn für variable nur eine Speichereinheit allokiert ist, greift man damit auf nicht für diese Variable allokierten Speicher über und verändert random irgendwelche Speicheradressen, in denen potentiell irgendwas anderes (wichtiges) steht. Also bei so was immer aufpassen.

    Das erklärt aber auch, warum die main-Funktion als Argumente char **args übergeben kriegt: Das ist ein doppelter Pointer, also ein doppeltes Array. Einfache char-Arrays sind Strings, also ist es ein Array von Strings. Jeder String ist ein Argument, das dem Programm in der Kommandozeile übergeben wurde.

    Ach ja, und wegen ->: Das ist nur ein coolerer Weg um den Inhalt eines Structs aus einem Pointer auszulesen. Anstatt den Pointer per * aufzulösen und dann . zu machen (also (*structpointer).element ) schreibt man structpointer->element und der Pointer wird automatisch aufgelöst. Das hat man wohl eingeführt, weil structs sehr häufig als Pointer übergeben werden.



    3 mal bearbeitet, zuletzt am 09.01.19 15:19 durch ap (Golem.de).

  9. ******

    Autor: Eheran 02.01.19 - 19:37

    Wow, danke für die Erklärung.

    Dann macht dieser Ausdruck also folgendes:
    for (ppelt = &this->customElts; *ppelt != NULL; ppelt = &(*ppelt)->next)
    { }

    "customElts" wird der Inhalt von "this" zugewiesen, welcher an der Adresse von "this" liegt, welche durch das & ausgegeben wurde?
    for(){} beginnt also mit einem Wert von "ppelt" der diesem gleichgesetzt wurde, der Inhalt der bei der Adresse von "this" liegt?
    for(){} läuft dann so lange, wie der Wert (darum *) "ppelt" ungleich NULL ist?
    Hochgezählt wird ppelt (oder dessen Adresse?) über die Adresse des Wertes von "ppelt", welche in "next" eingetragen wird...? Was zählt denn dann da?

    Ist & und * nicht gegensätzlich? Das & verweist auf die Adresse und * hingegen auf den Wert, der dort hinterlegt ist?



    1 mal bearbeitet, zuletzt am 09.01.19 15:19 durch ap (Golem.de).

  10. *******

    Autor: Dakkaron 03.01.19 - 10:41

    Zu ppelt = &(*ppelt)->next:

    Im letzten Segment des for-Statements muss nicht direkt hochgezählt werden. Technisch gesehen wird dieses Statement einfach genauso aufgerufen, wie wenn es als letzte Zeile in der for-Schleife ausgeführt wird.

    for (a;b;c) {
    d;
    }

    Ist also equivalent zu

    a;
    while (b) {
    d;
    c;
    }

    Für c darf also beliebiger Code eingesetzt werden. Da muss nicht mal eine Zuweisung stehen.

    Was hier also gemacht wird ist, sobald die Schleife durch ist, wird ppelt befüllt mit dem next-Element im vorherigen ppelt. Ich tippe, das ist eine Linked List oder so, wo hald jedes Element eine Referenz auf das nächste Element beinhaltet.

    Der Teil mit dem &(*ppelt)->next klingt hier etwas verwirrend, kommt aber daher in welcher Reihenfolge diese Operatoren greifen. Nämlich bindet der Pfeil am stärksten. Wäre also die Klammer nicht, dann würde zuerst der Pfeil ausgeführt und auf das Ergebnis dann erst * und dann &, die sich beide gegenseitig aufheben würden.

    So wird zuerst *ppelt ausgeführt (ppelt wird also dereferenziert), dann von dem Ergebnis mit -> das next-Element geholt, davon mit & die Referenz geholt und das Ergebnis wird dann nach ppelt geschrieben.



    1 mal bearbeitet, zuletzt am 09.01.19 15:31 durch ap (Golem.de).

  11. *****

    Autor: Eheran 03.01.19 - 11:20

    Danke :)



    1 mal bearbeitet, zuletzt am 09.01.19 15:31 durch ap (Golem.de).

  12. *****

    Autor: janoP 06.01.19 - 00:31

    Eheran schrieb:
    --------------------------------------------------------------------------------
    > Wow, danke für die Erklärung.
    >
    > Dann macht dieser Ausdruck also folgendes:
    > for (ppelt = &this->customElts; *ppelt != NULL; ppelt = &(*ppelt)->next)
    > { }
    >
    > "customElts" wird der Inhalt von "this" zugewiesen, welcher an der Adresse
    > von "this" liegt, welche durch das & ausgegeben wurde?
    > for(){} beginnt also mit einem Wert von "ppelt" der diesem gleichgesetzt
    > wurde, der Inhalt der bei der Adresse von "this" liegt?
    > for(){} läuft dann so lange, wie der Wert (darum *) "ppelt" ungleich NULL
    > ist?
    > Hochgezählt wird ppelt (oder dessen Adresse?) über die Adresse des Wertes
    > von "ppelt", welche in "next" eingetragen wird...? Was zählt denn dann da?
    >
    > Ist & und * nicht gegensätzlich? Das & verweist auf die Adresse und *
    > hingegen auf den Wert, der dort hinterlegt ist?

    Ich glaube, hier hätten die Entwickler mit Klammerung mehr Klarheit schaffen können. Hab lange nicht mehr C programmiert, aber ich glaube, dass die zeile so interpetiert wird:

    for (ppelt = &(this->customElts); *ppelt != NULL; ppelt = &((*ppelt)->next))

    this->customElts scheint so was wie eine Nodelist zu sein, also ein Struct, der ein Element next enthält, desen Typ ebenfalls so ein Node ist. Darüber hinaus hat dieser Node dann irgendeinen Inhalt, in diesem Fall wahrscheinlich sentenceName und noch irgendwas.

    Mit ppelt = &(this->customElts) zeigt ppelt also auf die Speicheradresse eines Pointers zum ersten Node (es scheint ein doppelter Pointer zu sein, denn er wird immer zwei Mal dereferenziert), mit ppelt = &((*ppelt)->next) wird dann einen Schritt in der Nodelist weitergegangen, also ppelt wird die Speicheradresse zum Pointer zum nächsten Nodeelement.

    Irgendwann ist die Liste zuende, dann zeigt (*ppelt)->next nach NULL – sobald dan noch einmal ppelt = &((*ppelt)->next) ausgeführt wird, stimmt die Bedingung *ppelt != NULL nicht mehr, und die Schleife ist zuende.



    1 mal bearbeitet, zuletzt am 09.01.19 15:20 durch ap (Golem.de).

  13. ******

    Autor: Eheran 06.01.19 - 01:52

    Ah, der ergibt Sinn. Es handelt sich dabei um NMEA (GPS, GNSS) Daten, die sehen z.B. so aus:
    $GPGLL,4916.45,N,12311.12,W,225444,A,*1D
    Das ganze "durchsucht" dann diese chars nach den gewünschten. Daher wohl ein doppelter Pointer.

    Aber die Bedingung "*ppelt != NULL" trifft doch die ganze Zeit zu? Wieso sollte die Schleife erst abbrechen, wenn es einmalig true war? Oder ist *ppelt irgendwie doch die ganze Zeit NULL?



    1 mal bearbeitet, zuletzt am 09.01.19 15:20 durch ap (Golem.de).

  14. *****

    Autor: janoP 06.01.19 - 01:59

    Eheran schrieb:
    --------------------------------------------------------------------------------
    > Ah, der ergibt Sinn. Es handelt sich dabei um NMEA (GPS, GNSS) Daten, die
    > sehen z.B. so aus:
    > $GPGLL,4916.45,N,12311.12,W,225444,A,*1D
    > Das ganze "durchsucht" dann diese chars nach den gewünschten. Daher wohl
    > ein doppelter Pointer.
    >
    > Aber die Bedingung "*ppelt != NULL" trifft doch die ganze Zeit zu? Wieso
    > sollte die Schleife erst abbrechen, wenn es einmalig true war? Oder ist
    > *ppelt irgendwie doch die ganze Zeit NULL?

    Nein, *ppelt ist, wie du am Anfang richtig geschrieben hast, die ganze Zeit != NULL. Die Schleife wird so lange auseführt, wie die Bedingung true ist. Erst wenn *ppelt = NULL ist (die Nodelist das Ende erreicht hat), ist die Bedingung *ppelt != NULL false und die Schleife bricht ab.



    2 mal bearbeitet, zuletzt am 09.01.19 15:20 durch ap (Golem.de).

  15. ****

    Autor: Eheran 06.01.19 - 02:01

    Natürlich!. Ich hab grad falschrum gedacht: Es bricht ja nicht ab, wenn die Bedingung zutrifft, sondern läuft nur dann weiter. Die Bedinung muss "true" sein, sonst bricht es ab. Und die ist es, solange es nicht NULL ist.



    1 mal bearbeitet, zuletzt am 09.01.19 15:30 durch ap (Golem.de).

  1. Thema

Neues Thema Ansicht wechseln


Um zu kommentieren, loggen Sie sich bitte ein oder registrieren Sie sich. Sie müssen ausserdem in Ihrem Account-Profil unter Forum einen Nutzernamen vergeben haben. Zum Login

Stellenmarkt
  1. IT-Koordinator (m/w/d)
    Landesförderinstitut Mecklenburg-Vorpommern, Schwerin
  2. Referent (m/w/d) Data Center Services ERV Application Platforms
    ITERGO Informationstechnologie GmbH, München
  3. IT-Techniker (m/w/d)
    ENERGY Radio NRJ GmbH, Hamburg, Berlin
  4. System Engineer (m/w/d) Big Data-Plattform
    Fiducia & GAD IT AG, Karlsruhe, München, Münster

Detailsuche


Golem pur
  • Golem.de ohne Werbung nutzen

Anzeige
Hardware-Angebote


Haben wir etwas übersehen?

E-Mail an news@golem.de