Forum: Compiler & IDEs Stern Stern, Bedeutung


Announcement: there is an English version of this forum on EmbDev.net. Posts you create there will be displayed on Mikrocontroller.net and EmbDev.net.
von Erdling (Gast)


Bewertung
0 lesenswert
nicht lesenswert
Hier ein Schnipsel von einem DMA-Example für den Raspberry Pi.
Was genau passiert in der ersten Zeile nach dem Kommentar?
    //force page into RAM and then lock it there:
    ((int*)*virtAddr)[0] = 1;
    mlock(*virtAddr, PAGE_SIZE);
    memset(*virtAddr, 0, PAGE_SIZE); //zero-fill the page for convenience

von Dirk B. (dirkb2)


Bewertung
0 lesenswert
nicht lesenswert
Die Adresse, die an der Adresse steht auf die virtAddr zeigt, wird als 
Zeiger auf int aufgefasst und dort (wegen der [0]) der Wert 1 abgelegt.

Der * von *virtAddr ist eine Dreferenzierung.
Das (int*) ist ein cast.

Die Definition von virtAddr sollte in der Art sein:

Typ **virtAddr;

von Karl H. (kbuchegg) (Moderator)


Bewertung
0 lesenswert
nicht lesenswert
virtAddr ist ein Pointer, der auf einen Pointer zeigt, in dem steht mit 
welchem Speicher zu arbeiten ist

  virtAddr
  +--------+
  |    o---------------------+
  +--------+                 |
                             |
                             v
                        +----------+                  +---------------+
                        |      o--------------------->| eigentlicher  |
                        +----------+                  | Speicher-     |
                                                      | Bereich       |
                                                      | für           |
                                                      | die Daten     |
                                                      |               |
                                                      +---------------+

es könnte zb sein, dass der mittlere Pointer einfach nur Teil eines 
Arrays ist, indem die Pointer in den Speicher gesammelt werden und 
mittels virtAddr wird einer dieser Pointer ausgewählt.


  virtAddr
  +--------+                                   +-------------+
  |    o------+                          +---->|             |
  +--------+  |                          |     |             |
              |                          |     |             |
              |         +----------+     |     +-------------+
              |         |      o---------+
              |         +----------+                  +---------------+
              +-------->|      o--------------------->| eigentlicher  |
                        +----------+                  | Speicher-     |
                        |      o-------+              | Bereich       |
                        +----------+   |              | für           |
                                       |              | die Daten     |
                                       |              |               |
                                       v              +---------------+
                                  +-------------+
                                  |             |
                                  |             |
                                  |             |
                                  +-------------+
virtAddr
such dir das Rechteck 'virtAdr' in der Zeichnung

*virtAddr
verfolge den Pfeil, der davon ausgeht. Du landest bei einem weiteren 
Rechteck

(int*)*virtAddr
das was du dort in diesem Rechteck vorfindest, fasse es als Pointer auf 
einen int auf.

((int*)*virtAdr)[0] = 
verfolge den dort ausgehenden Pointer weiter und schreibe dort wo er 
hinzeigt (wegen Array-Pointer Dualität) etwas rein (wobei du den 
speicher als einen int auffasst)

: Bearbeitet durch Moderator
von Erdling (Gast)


Bewertung
0 lesenswert
nicht lesenswert
Autor: Dirk B. (dirkb2) schrieb:

>Die Definition von virtAddr sollte in der Art sein:
>Typ **virtAddr;
Yep.
void makeVirtPhysPage(void** virtAddr, void** physAddr) {
    *virtAddr = valloc(PAGE_SIZE); //allocate one page of RAM

    //force page into RAM and then lock it there:
    ((int*)*virtAddr)[0] = 1;
    mlock(*virtAddr, PAGE_SIZE);
    memset(*virtAddr, 0, PAGE_SIZE); //zero-fill the page for convenience

    //Magic to determine the physical address for this page:
    uint64_t pageInfo;
    int file = open("/proc/self/pagemap", 'r');
    lseek(file, ((uint32_t)*virtAddr)/PAGE_SIZE*8, SEEK_SET);
    read(file, &pageInfo, 8);

    *physAddr = (void*)(uint32_t)(pageInfo*PAGE_SIZE);
    printf("makeVirtPhysPage virtual to phys: %p -> %p\n", *virtAddr, *physAddr);
}



//der Aufruf in main():
    //configure DMA:
    //allocate 1 page for the source and 1 page for the destination:
    void *virtSrcPage, *physSrcPage;
    makeVirtPhysPage(&virtSrcPage, &physSrcPage);

Muß man das wirklich - aus meiner Sicht - so kompliziert gestalten?
Das zu verstehen ist'n zäher Brocken...

von Karl H. (kbuchegg) (Moderator)


Bewertung
0 lesenswert
nicht lesenswert
Erdling schrieb:

> Muß man das wirklich - aus meiner Sicht - so kompliziert gestalten?

Das ist doch nicht kompliziert.

Das ist das ganz normale Ergebnis, das rauskommt, wenn man eine Funktion 
in die Lage versetzen will, beim Aufrufer eine Pointer Variable zu 
verändern.

> Das zu verstehen ist'n zäher Brocken...

Das ist stink normales C. Willkommen in der 2-Stern Programmierung

von Karl H. (kbuchegg) (Moderator)


Bewertung
0 lesenswert
nicht lesenswert
Karl Heinz schrieb:

> Das ist das ganz normale Ergebnis, das rauskommt, wenn man eine Funktion
> in die Lage versetzen will, beim Aufrufer eine Pointer Variable zu
> verändern.

Wie schreibst du das denn, wenn eine Funktion einen int beim Aufrufer 
verändern soll?
Doch wohl so
void foo( int * pI )
{
  *pI = 6;
}

int main()
{
  int j;

  foo( &j );   // j kriegt von foo den Wert 6
}

Was ist das allgemeine Schema?
void foo( T * pointerToVariable )
{
  * pointerToVariable = Wert für die Variable;
}

int main()
{
  T variable;

  foo( &variable );
}


und jetzt setzt du für T einfach mal einen Pointer Datentyp ein. Zb. 
einen void *

Wenn in
    void *virtSrcPage, *physSrcPage;
    makeVirtPhysPage(&virtSrcPage, &physSrcPage);
die Funktion in der Lage sein soll, an virtSrcPage einen neuen Wert 
zuzuweisen (weil die Funktion Speicher allokiert und die Adresse dieses 
allokierten Speichers in virtSrcPage ablegen soll), dann muss die 
Funktion einen Pointer auf die Pointer-Variable virtSrcPage kriegen.
Damit muss logischerweise das Funktionsargument ein void ** sein. Immer 
1 * mehr als der Datentyp der Variablen, die sie verändern können soll.

: Bearbeitet durch Moderator
von Frank M. (ukw) (Moderator) Benutzerseite


Bewertung
0 lesenswert
nicht lesenswert
Erdling schrieb:
> Muß man das wirklich - aus meiner Sicht - so kompliziert gestalten?

Wenn man sich einige Zeit mit Pointern in C intensiv beschäftigt hat, 
ist das überhaupt nicht mehr kompliziert. Den Code (den Du da oben 
gepostet hast) liest sich dann genauso flüssig wie die Tageszeitung am 
Morgen.

Bis dahin ist es aber ein harter weg.

Die doppelten Sternchen sind nur deshalb nötig, damit die Funktion die 
eigentlichen Pointer, die übergeben werden, modifizieren kann. Denk Dir 
erstmal überall ein Sternchen weg. Dann wird es einfacher.

> Das zu verstehen ist'n zäher Brocken...

Das lernt man nicht in ein paar Tagen.... mach Dir nichts draus. Es kann 
auch mal Fälle mit 3 Sternchen hintereinander geben. Dann wirds wirklich 
heftig. ;-)

von Erdling (Gast)


Bewertung
0 lesenswert
nicht lesenswert
Ich glaube dieses vereinfachte Beispiel:

>Was ist das allgemeine Schema?
void foo( T * pointerToVariable )
{
  * pointerToVariable = Wert für die Variable;
}

int main()
{
  T variable;

  foo( &variable );
}

zusammen mit der Ziel WORUM es überhaupt geht:
>Wenn die Funktion in der Lage sein soll, an virtSrcPage einen neuen Wert
>zuzuweisen (weil die Funktion Speicher allokiert und die Adresse dieses
>allokierten Speichers in virtSrcPage ablegen soll), dann muss die
>Funktion einen Pointer auf die Pointer-Variable virtSrcPage kriegen.

hat mir das Tor zum Verständnis geöffnet. Wenn man es versteht fühlt 
sich der Aha!-Effekt nämlich besonders gut an...

Danke für die Mühe.

von Mark B. (markbrandis)


Bewertung
0 lesenswert
nicht lesenswert
Karl Heinz schrieb:
> virtAddr ist ein Pointer, der auf einen Pointer zeigt, in dem steht mit
> welchem Speicher zu arbeiten ist
>
>
> 
>   virtAddr
>   +--------+
>   |    o---------------------+
>   +--------+                 |
>                              |
>                              v
>                         +----------+                  +---------------+
>                         |      o--------------------->| eigentlicher  |
>                         +----------+                  | Speicher-     |
>                                                       | Bereich       |
>                                                       | für           |
>                                                       | die Daten     |
>                                                       |               |
>                                                       +---------------+
> 


Hast Du ein ASCII-Malprogramm dafür? Auch haben will :-)

von Frank M. (ukw) (Moderator) Benutzerseite


Bewertung
0 lesenswert
nicht lesenswert
Mark Brandis schrieb:
> Hast Du ein ASCII-Malprogramm dafür? Auch haben will :-)

Hat jeder, so ein ASCII-Malprogramm nennt sich Text-Editor. ;-)

von Bitflüsterer (Gast)


Bewertung
1 lesenswert
nicht lesenswert
Frank M. schrieb:
> Mark Brandis schrieb:
>> Hast Du ein ASCII-Malprogramm dafür? Auch haben will :-)
>
> Hat jeder, so ein ASCII-Malprogramm nennt sich Text-Editor. ;-)

Ich halte es zwar für durchaus denkbar, daß Karl Heinz die Bilder von 
Hand im Editor malt, aber für Faulpelze wie mich gibts: AACircuit unter 
http://www.tech-chat.de/download.html

von c-lover (Gast)


Bewertung
0 lesenswert
nicht lesenswert
ich liebe es:
zeiger die auf zeiger zeigen->
 ->die auf zeiger zeigen
 ->die auf zeiger zeigen
 ->die auf zeiger zeigen
 ->die auf zeiger zeigen....
das kenn ich zur genüge. nicht c ist schuld sondern der progger.
erinnert mich sehr stark an "objekt orientierten assembler" (borland?)
alle haben es gefordert.
irgendwann kam dann aus der entwicklung:"wer assembler objektorientiert 
programmiert ist pervers..." und man würde sich über das beispiel einer 
funktionoerden applikaton freuen.
c ist halt das werkzeug, das nicht belehrbare psychotiker zu ihren 
programm-konstrukten (ohne kommentare!) motiviert.
und ich bewundere progger die da "add hoc2 noch einen sinn erkennen (so 
er denn eindeutig ist...)

nur mal so frust ablassend (its my daily work)

von Karl H. (kbuchegg) (Moderator)


Bewertung
1 lesenswert
nicht lesenswert
Bitflüsterer schrieb:
> Frank M. schrieb:
>> Mark Brandis schrieb:
>>> Hast Du ein ASCII-Malprogramm dafür? Auch haben will :-)
>>
>> Hat jeder, so ein ASCII-Malprogramm nennt sich Text-Editor. ;-)
>
> Ich halte es zwar für durchaus denkbar, daß Karl Heinz die Bilder von
> Hand im Editor malt

Tue ich.
Wenn man das Bild im Kopf hat, das entstehen soll, geht das relativ 
schnell.

von Mark B. (markbrandis)


Bewertung
0 lesenswert
nicht lesenswert
Karl Heinz schrieb:
> Bitflüsterer schrieb:
>> Frank M. schrieb:
>>> Mark Brandis schrieb:
>>>> Hast Du ein ASCII-Malprogramm dafür? Auch haben will :-)
>>>
>>> Hat jeder, so ein ASCII-Malprogramm nennt sich Text-Editor. ;-)
>>
>> Ich halte es zwar für durchaus denkbar, daß Karl Heinz die Bilder von
>> Hand im Editor malt
>
> Tue ich.
> Wenn man das Bild im Kopf hat, das entstehen soll, geht das relativ
> schnell.

Äh. Nein? Das Problem ist ja das Einfügen von Elementen, was jedes 
andere Element in der gleichen Zeile nach hinten verschiebt.

Also wenn man das von Anfang an richtig im Kopf hat und perfekt 
hinzimmert - dann meinen Respekt. Das krieg ich so nicht hin.

von Markus F. (mfro)


Bewertung
0 lesenswert
nicht lesenswert
Mark Brandis schrieb:
> Äh. Nein? Das Problem ist ja das Einfügen von Elementen, was jedes
> andere Element in der gleichen Zeile nach hinten verschiebt.

Dafür gibt's - seit den Anfängen der IT - die "Insert"-Taste, die 
zwischen Einfügen und überschreiben umschaltet...

von Mark B. (markbrandis)


Bewertung
0 lesenswert
nicht lesenswert
Markus F. schrieb:
> Dafür gibt's - seit den Anfängen der IT - die "Insert"-Taste, die
> zwischen Einfügen und überschreiben umschaltet...

Ach wer benutzt die schon ;-)

von Rolf Magnus (Gast)


Bewertung
0 lesenswert
nicht lesenswert
Markus F. schrieb:
> Dafür gibt's - seit den Anfängen der IT - die "Insert"-Taste, die
> zwischen Einfügen und überschreiben umschaltet...

... aber leider in der Regel das Entfernen nicht entsprechend mit 
umschaltet. Also ich tippe irgendwo ein Zeichen rein, und alles danach 
bleibt, wie es ist und verschiebt sich nicht. Ich lösche das Zeichen 
wieder, weil an der falschen Stelle, und alles verschiebt sich. Ich will 
dafür ein Leerzeichen einfügen, was aber stattdessen das nächste Zeichen 
auch noch mit was falschem überschreibt, weil ich erst wieder auf 
einfügen hätte umschalten müssen. Das hat mich schon einiges an Nerven 
gekostet. ;-)

c-lover schrieb:
> ich liebe es:
> zeiger die auf zeiger zeigen->
>  ->die auf zeiger zeigen
>  ->die auf zeiger zeigen
>  ->die auf zeiger zeigen
>  ->die auf zeiger zeigen....
> das kenn ich zur genüge. nicht c ist schuld sondern der progger.

Wie würdest du das denn machen? Wenn man aus eine Funktion etwas über 
einen Parameter rausgeben will, macht man einen Zeiger darauf. Wenn das, 
was man rausgibt, auch schon ein Zeiger ist, ergibt sich logischerweise 
ein Zeiger auf einen Zeiger.

> c ist halt das werkzeug, das nicht belehrbare psychotiker zu ihren
> programm-konstrukten (ohne kommentare!) motiviert.

Wer sich "progger" nennt, und die Großmachtaste nicht findet, sollte 
nicht so große Töne spucken.

von rmu (Gast)


Bewertung
0 lesenswert
nicht lesenswert
c-lover schrieb:
> ich liebe es:
> zeiger die auf zeiger zeigen->
>  ->die auf zeiger zeigen
>  ->die auf zeiger zeigen
>  ->die auf zeiger zeigen
>  ->die auf zeiger zeigen....
> das kenn ich zur genüge. nicht c ist schuld sondern der progger.

Sowas kommt doch dauernd vor, verkettete Liste z.B.

Verkehrt in C ist die Syntax, wie man Variablen, vor allem Pointer, 
deklariert (Zeiger auf Funktion, die einen Zeiger auf ein Array aus 
Funktionszeigern mit selber Signatur returniert?).

Hirnrissig wirds dann beim Derefenzieren von (mehreren) Pointern, das 
schreibt sich in Pascal z.B. viel verständlicher. Das haben auch die 
Schöpfer der Go-Sprache erkannt (die teilweise ja auch C aus den Windeln 
geholfen haben), und dort die Syntax repariert: 
http://blog.golang.org/gos-declaration-syntax

Bei Exzessivem *-Gebrauch wird man von bösen Zungen auch Zweistern- oder 
Dreistern-Programmierer geschimpft 
(http://c2.com/cgi/wiki?ThreeStarProgrammer).

von Rufus Τ. F. (rufus) (Moderator) Benutzerseite


Bewertung
0 lesenswert
nicht lesenswert
rmu schrieb:
> Verkehrt in C ist die Syntax

Vielleicht nicht "verkehrt", sondern Dir unverständlich?

von rmu (Gast)


Bewertung
0 lesenswert
nicht lesenswert
Rufus Τ. Firefly schrieb:
> rmu schrieb:
>> Verkehrt in C ist die Syntax
>
> Vielleicht nicht "verkehrt", sondern Dir unverständlich?

Unverständlich nicht, aber trotzdem verkehrt, wie in "die Reihenfolge 
stimmt nicht", auf mehreren Ebenen.

Intuitiv wäre m.E. das pascal-artige "lass p einen Zeiger auf int sein" 
und nicht das C-artige "lass int den Typ sein, der beim Derefenzieren 
von p herauskommt".

In manchen Coding Conventions wird "verboten", sowas wie
int *p, i;
zu schreiben, sondern verlangen
int* p; // pointer: stern beim Typ, eigene Zeile notwendig
int i;
mit dem Stern (oder in C++ auch das & für Referenz) beim Typ.

von Frank M. (ukw) (Moderator) Benutzerseite


Bewertung
0 lesenswert
nicht lesenswert
rmu schrieb:
> In manchen Coding Conventions wird "verboten", sowas wie
>
> int *p, i;
> 
> zu schreiben, sondern verlangen
>
> int* p; // pointer: stern beim Typ, eigene Zeile notwendig
> int i;
> 
> mit dem Stern (oder in C++ auch das & für Referenz) beim Typ.

Ich schreibe:
int * p;

:-P

von Rolf Magnus (Gast)


Bewertung
0 lesenswert
nicht lesenswert
rmu schrieb:
> Sowas kommt doch dauernd vor, verkettete Liste z.B.
>
> Verkehrt in C ist die Syntax, wie man Variablen, vor allem Pointer,
> deklariert (Zeiger auf Funktion, die einen Zeiger auf ein Array aus
> Funktionszeigern mit selber Signatur returniert?).

Paradebeispiel für schwer verständliche Deklarationen ist die 
Standard-Funktion signal():
void (*signal(int sig, void (*handler)(int)))(int); 

Aber das läßt sich recht leicht entschärfen:
typedef void (*sighandler_t)(int); 
sighandler_t signal(int sig, sighandler_t handler);

rmu schrieb:
> Intuitiv wäre m.E. das pascal-artige "lass p einen Zeiger auf int sein"
> und nicht das C-artige "lass int den Typ sein, der beim Derefenzieren
> von p herauskommt".

Diese verdrehte Logik bei der Deklaraton in C fand ich auch schon immer 
eher unglücklich. Urspügnlich war das ja geacht, um's intuitiver zu 
machen, aber das ist meines Erachtens nach hinten losgegangen.

von rmu (Gast)


Bewertung
0 lesenswert
nicht lesenswert
Rolf Magnus schrieb:
> rmu schrieb:
>> Intuitiv wäre m.E. das pascal-artige "lass p einen Zeiger auf int sein"
>> und nicht das C-artige "lass int den Typ sein, der beim Derefenzieren
>> von p herauskommt".
>
> Diese verdrehte Logik bei der Deklaraton in C fand ich auch schon immer
> eher unglücklich. Ursprünglich war das ja gedacht, um's intuitiver zu
> machen, aber das ist meines Erachtens nach hinten losgegangen.

Ich denke eher, dass das eine Folge einer Optimierung des Compilers war, 
da sich so der Ausdruck-Parser auch für die Variablen-und 
Typ-Deklarationen missbrauchen lässt. Das ist ja auf einem Rechner 
entstanden, der 64k 18bit-Worte RAM Maximalausbau hatte.

Wenn man mit Funktionszeigern jongliert kann man gar nicht genug 
typedefs verwenden, das hilft definitiv, sonst wirds wie bei der 
signal-decl oben schnell mal unklar, wo man welchen Namen hinschreibt, 
und wie der resultierende Typ dann eigentlich heisst.

Zum Glück wurde der "->" Operator vorgesehen, man stelle sich vor, was 
man sonst für Konvolute aus verklammerten * und . schreiben müsste...

Ansonsten seh ich das recht fatalistisch, man kann nix ändern daran, 
verschwinden wird C auch nicht, und schliesslich gewöhnt man sich 
irgendwann eh an alles... ;-)

Um auch was sinnvolles beizutragen, hier 
http://cm.bell-labs.com/cm/cs/who/dmr/chist.html gibts die Geschichte 
von C aus der Sicht von Dennis M. Ritchie.

von Karl H. (kbuchegg) (Moderator)


Bewertung
0 lesenswert
nicht lesenswert
rmu schrieb:
> Rolf Magnus schrieb:
>
>> Diese verdrehte Logik bei der Deklaraton in C fand ich auch schon immer
>> eher unglücklich. Ursprünglich war das ja gedacht, um's intuitiver zu
>> machen, aber das ist meines Erachtens nach hinten losgegangen.
>
> Ich denke eher, dass das eine Folge einer Optimierung des Compilers war,
> da sich so der Ausdruck-Parser auch für die Variablen-und
> Typ-Deklarationen missbrauchen lässt. Das ist ja auf einem Rechner
> entstanden, der 64k 18bit-Worte RAM Maximalausbau hatte.

Denke ich eher nicht.
Denn bei Casts musst du die Datentypen ohne den Variablennamen an der 
richtigen Stelle parsen.
Casts gabs auch bei K&R C schon.

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.