Thema: Struktur auf beliebigen Speicher anwenden

[bitmaster]

Exakt dieses meinte ich mit uintptr_t... Zumindest wäre das der standard(konforme) Weg dies zu tun. Mit (u32) kriegst du im Longmode offensichtlich Probleme. Wie gesagt, Portabilität ist keine Eigenschaft einer (Hoch-)Sprache (edit: Aber erst Hochsprachen machen Portabilität möglich, falls jetzt wieder einer der Fließbandjungs kommt und nörgelt), sondern eher eine guten Codes.

Jo, ich habe in meinem Code eh noch jede Menge unportierbare Sachen drin, die ich noch ändern muss, wenn ich demnächst auch ne 64 bit Version haben möchte. Muss eh noch schauen wie genau das dann machbar ist. Evtl. braucht man dann den Präprozessor und solche Sachen? Und natürlich irgendwie ne Angabe ob ich jetzt 32 oder 64 bit compilieren / linken möchte. Ne Makefile bzw. Makefiles wären auch nicht schlecht. 

bitmaster

[bluecode]

genau Du hast übrigens meine Frage warum du zu C gewechselt bist nicht beantwortet, obwohl wir deiner Bedingung nachgekommen sind.

[bitmaster]

...obwohl wir deiner Bedingung nachgekommen sind.

Seid ihr? Uups äh *hust* na ja ... 

bitmaster

[bitmaster]

Hmm jetzt meckert gcc wieder und ich weiß nicht was ich machen soll. Also ich habe eine Variable Namens blabla vom Typ u32, die einen Wert beinhaltet, der eine Adresse widerspiegelt, die auf einen Null terminierten String zeigt. Aber folgendes mag gcc dann nicht:

Code: [Auswählen]

strlen(blabla);
und das geht auch net

Code: [Auswählen]

strlen((u32)blabla);
gcc meckert dann mit:

error: passing argument 1 of ‘strlen’ makes pointer from integer without a cast

hmm...

EDIT: arg, ich sollte vielleicht mein bayern fangesang etwas leiser schalten. Es scheint mich wohl doch ein wenig abzulenken. Also so geht es natürlich:

Code: [Auswählen]

strlen((const char *)blabla);
bitmaster

[bitmaster]

So, jetzt kann ich im Kernel ja strlen nutzen, indem ich

Code: [Auswählen]

include <string.h> einfüge und ld die libc.a angebe. Das Gleiche bei Anwendungen natürlich auch. Aber dann hängt ja immer die ganze libc an dem Kernel/an den Anwendungen obwohl nur einzelne Funktionen gebraucht werden. Wenn ich z.B. im Kernel nur strlen brauche, dann hätte ich noch x andere Funktionen, die der Kernel gar nicht benötigt. Oder gibt es eine Möglichkeit nicht benötigte Funktionen nicht mit zu linken? Ich könnte in dem Fall natürlich einfach nur die strlen.o mit linken, nur dann würde es sicher eine Fehlermeldung geben, weil die anderen Prototypen, die in der string.h stehen nicht gefunden werden. Von daher stehe ich jetzt doof/unwissend da. 

bitmaster

[bluecode]

Oder gibt es eine Möglichkeit nicht benötigte Funktionen nicht mit zu linken?

Wenn du eine .a mitlinkst, dann nimmt der Linker m.E. aus der .a wirklich nur die Funktionen mit, die du auch verwendest in den anderen Objektdateien (also denen des Kernels selbst).

Ich könnte in dem Fall natürlich einfach nur die strlen.o mit linken, nur dann würde es sicher eine Fehlermeldung geben, weil die anderen Prototypen, die in der string.h stehen nicht gefunden werden.

Solange du die anderen Funktionen nicht verwendest wird der Linker nicht meckern, insofern funktioniert deine Lösung mit der strlen.o schon, hat aber natürlich den Nachteil, dass du wahrscheinlich öfter mal deine Makefiles anpassen musst.

[bitmaster]

  echt? Ja dann, vielen dank. Muss ich gleich mal ausprobieren.

bitmaster

[bitmaster]

sagt mal, welche Version sollte ich in der string.h stehen haben oder ist das egal?

Code: [Auswählen]

extern size_t strlen(const char *);

Code: [Auswählen]

size_t strlen(const char *);

Code: [Auswählen]

size_t strlen(const char* str);

Code: [Auswählen]

size_t strlen(const char *str);
thx

bitmaster

[bluecode]

The linker will search an archive only once, at the location where it is specified on the command line. If the archive defines a symbol which was undefined in some object which appeared before the archive on the command line, the linker will include the appropriate file(s) from the archive. However, an undefined symbol in an object appearing later on the command line will not cause the linker to search the archive again.

aus dem Manual (unter der Option --library=). Bemerkenswert ist, dass die Datei die das undefinierte Symbol enthält dazugenommen wird, nicht nur das Symbol an sich. Also nicht ganz das gleiche wie ich oben behauptet habe.

[bluecode]

Das sind komplett äquivalente Deklarationen, da zum einen extern implizit verwendet wird, d.h. man bekommt "extern" bei einer Funktionsdeklaration ohne es explizit hinschreiben zu müssen. Die Setzung des Sterns ist eine stylistische Frage und keine semantische (auch wenn es da heiße C vs. C++ Debatten gibt *g*). Das Weglassen des Argumentnamens würde ich aber als unpraktisch ansehen, da man dann zum einen den Parameter nicht über doxygen dokumentieren kann und zum anderen bei modernen IDEs automatisch wenn man zB "strlen(" schreibt einem die Typen und Namen der Parameter angezeigt werden und man am Namen der Parameter gleich erkennt wie die Funktion zu verwenden ist. Beispiel: Wenn ich ein strcpy(char *dest, const char *src) habe und mir wird das angezeigt, dann ist klar(er) von wo nach wo kopiert wird.

[bitmaster]

ah OK vielen dank, also um noch mal sicher zu gehen, folgendes ist das selbe?

Code: [Auswählen]

const char *bla

Code: [Auswählen]

const char* bla
?

bitmaster

[bluecode]

Ja.

[bitmaster]

Ja.

Cool danke, jetzt kann ich mir 100%ig sicher sein, dass Bayern Meister wird. 

bitmaster

[bitmaster]

So, um wieder dem Thema ziemlich nah zu kommen, habe ich jetzt noch eine Frage bezüglich Strukturen. Sagt mal, was genau ist der Unterschied zwischen:

Code: [Auswählen]

struct bla
{
...
};
und

Code: [Auswählen]

typedef struct
{
...
} bla;
vielen dank schon mal

bitmaster

[Jidder]

Bei ersterem heißt der Datentyp "struct bla" bei zweiterem "bla".

[bitmaster]

Bei ersterem heißt der Datentyp "struct bla" bei zweiterem "bla".

ah danke

Ist es irgendwie möglich die selbe Funktion mehrmals auszuführen, aber nur eine Zeile zu benutzen? Also dass man

Code: [Auswählen]

funktion(var1);
funktion(var2);
funktion(var3);
ungefähr so schreiben kann

Code: [Auswählen]

funktion(var1 kA var2 kA var3);
Also dass man nicht so "hässlich" mehrere Zeilen benötigt um hintereinander die selbe Funktion nur mit verschiedenen Parametern auszuführen. Geht das, oder geht das nicht?

thx

bitmaster

[bluecode]

Im Allgemeinen nicht. Wenn überhaupt dann über for-Schleife: Wenn i die Zählvariable ist dann kann man entweder den/die Parameter direkt aus i errechnen oder man kann i als Index in ein Array mit den Parameternwerten machen.
also entweder (f ist der Ausdruck mit dem ich von i zu meinem Parameter komm)

Code: [Auswählen]

for (int i = 0;i < blub;++i)
  func( f(i) );
oder

Code: [Auswählen]

void func(Type param);
Type A[] = { // Insert my first parameter of type Type here
                     // Insert my second parameter of type Type here
                    ...
                    };
for (int i = 0;i < blub;++i)
  func( A[i] );


[bitmaster]

hmm.. schade, na ja, nicht sooo schlimm

[bluecode]

C++0x kann das (zumindest mit einer Hilfsfunktion)

Code: [Auswählen]

void func_helper(){}

template<typename T, void (*func)(T), typename... Args>
void func_helper(T arg1, Args... pack)
{
  func(arg1);
  func_helper(pack...);
}

das ist eine leicht allgemeinere Lösung als die geforderte, man müsste die auch über

Code: [Auswählen]

void func(int);
func_helper<int, func>(1, 2, 3, 4, 5, 6, 7); // something like that
aufrufen. Aber ich kenn mich mit variadic templates noch nicht so ganz gut aus und kann da keine Korrektheit garantieren.

edit: Glatt den Basisfall vergessen

[bitmaster]

So, da bin ich wieder. 

Also ich möchte die Adresse eines Pointers in eine size_t Variable kopieren. Dazu mache ich folgendes:

Code: [Auswählen]

char *pch;
size_t i;
...
i = pch;
Jetzt meckert gcc mit:

error: assignment makes integer from pointer without a cast

Without a cast? Was heißt das? So geht es nämlich auch nicht:

Code: [Auswählen]

i = (char *)pch;
Muss ich da irgendwas spezielles machen, oder wie?

thx

bitmaster