Wie kann ich richtig mit einem void-Zeiger in C?

Einer Sache, zum im Verstand zu halten: C garantiert nicht, dass int werden, die genug Platz für einen Zeiger (einschließlich void*). Das cast ist nicht eine tragbare Sache/gute Idee. Verwenden %p zu printf einen Zeiger.

Ebenfalls, Sie machen einen "schlecht gegossen" hier: void* res = (int*) a sagt der compiler: "ich bin sicher, dass der Wert von a ist eine gültige int*, so sollten Sie Sie als solche behandeln." Es sei denn, Sie wirklich wissen, für eine Tatsache, dass es eine int stored at memory address 30, das ist falsch.

Glücklicherweise sofort überschreiben res mit der Adresse des anderen a. (Sie haben zwei vars namens a und zwei benannte res in main und diejenigen, die in func. Diejenigen, die in func sind Kopien der Wert der in main, wenn Sie es nennen es.) Allgemein, und überschreiben Sie den Wert eines Parameters an eine Funktion ist "schlecht", aber es ist technisch legal. Persönlich empfehle ich, deklarieren alle Ihre Funktionen " Parameter wie const 99% der Zeit (z.B. void func (const int a, const void* res))

Dann, wirkst du res zu einem unsigned short. Ich denke nicht, dass irgendjemand noch auf einen 16-bit Adressraum der CPU (auch ein Apple II vielleicht), so dass definitiv beschädigt den Wert von res von abschneiden.

In der Regel In C, Typumwandlungen sind gefährlich. Du bist die Aufhebung der compiler die Typ-system, und sagen: "schauen Sie hier, Herr Compiler, ich bin der Programmierer, und ich weiß besser als du, was ich hier habe. Also, Sie nur ruhig sein und machen dies geschehen." Casting von einem Zeiger auf eine nicht-pointer-Typ ist fast durchgängig falsch. Casting zwischen Zeiger-Typen ist eher falsch als nicht.

Ich würde vorschlagen, Check-out einige der "Related" - links unten auf dieser Seite finden Sie einen überblick, wie der C-Typen ein Zeiger arbeiten, im Allgemeinen. Manchmal dauert es zu Lesen über ein paar, um wirklich in den Griff bekommen, wie dieses Zeug geht zusammen.

InformationsquelleAutor BRPocock

Einen void-Zeiger in C verwendet als eine Art von generischen Zeiger. Ein void-Zeiger-variable kann verwendet werden, um enthalten die Adresse einer variable Typ. Das problem mit einem void-Zeiger nach der Zuweisung einer Adresse an den Zeiger, der Informationen über den Typ der variable ist nicht mehr verfügbar für den compiler zu überprüfen.

Im Allgemeinen, void-Zeiger sollte vermieden werden, da sich der Typ der Variablen, deren Adresse in der void-Zeiger ist nicht mehr verfügbar, die für den compiler. Auf der anderen Seite gibt es Fälle, wo ein void-Zeiger ist sehr praktisch. Allerdings ist es für den Programmierer wissen, die Art der variable, deren Adresse in der void-Zeiger-variable, und um es richtig zu nutzen.

Viel von älteren C-Quelle C-Stil-casts zwischen Typ Zeiger und void-Zeiger. Dies ist nicht notwendig mit modernen Compilern und sollte vermieden werden.

In der Größe eines void-Zeiger-variable bekannt ist. Was nicht bekannt ist, ist die Größe der variable, deren Zeiger der void-Zeiger variable. Zum Beispiel hier sind einige Quellcode-Beispiele.

//create several different kinds of variables
int iValue;
char aszString[6];
float  fValue;

int  *pIvalue = &iValue;
void *pVoid = 0;

int iSize = sizeof(*pIvalue);   //get size of what int pointer points to, an int

int vSize = sizeof(*pVoid);     //compile error, size of what void pointer points to is unknown
int vSizeVar = sizeof(pVoid);   //compiles fine size of void pointer is known

pVoid = &iValue;        //put the address of iValue into the void pointer variable
pVoid = &aszString[0];  //put the address of char string into the void pointer variable
pVoid = &fValue;        //put the address of float into the void pointer variable

pIvalue = &fValue;      //compiler error, address of float into int pointer not allowed

Einer Weise, die void-Zeiger verwendet wurden, ist durch verschiedene Arten von Strukturen, die als argument für eine Funktion, in der Regel irgendeine Art von dispatching-Funktion. Da die Schnittstelle für die Funktion können für verschiedene pointer-Typen, einen void-Zeiger verwendet werden muss, der in der argument Liste. Dann ist der Typ der Variablen hingewiesen wird bestimmt, indem entweder ein zusätzliches argument oder Inspektion der Variablen hingewiesen. Ein Beispiel dieser Art der Verwendung einer Funktion wäre, etwas wie das folgende. In diesem Fall schließen wir eine Anzeige, die den Typ der struct in das erste Mitglied der verschiedenen Permutationen der struct. Solange alle Strukturen, die verwendet werden, mit dieser Funktion als erstes Mitglied einer int Angabe der Art der Struktur, das funktionieren wird.

struct struct_1 {
    int iClass;  //struct type indicator.  must always be first member of struct
    int iValue;
};

struct struct_2 {
    int   iClass;  //struct type indicator.  must always be first member of struct
    float fValue;
};

void func2 (void *pStruct)
{
    struct struct_1 *pStruct_1 = pStruct;
    struct struct_2 *pStruct_2 = pStruct;

    switch (pStruct_1->iClass)  //this works because a struct is a kind of template or pattern for a memory location
    {
    case 1:
        //do things with pStruct_1
        break;
    case 2:
        //do things with pStruct_2
        break;
    default:
        break;
    }
}

void xfunc (void)
{
    struct struct_1 myStruct_1 = {1, 37};
    struct struct_2 myStruct_2 = {2, 755.37f};

    func2 (&myStruct_1);
    func2 (&myStruct_2);
}

Etwas wie die oben genannten hat eine Reihe von software-design-Probleme mit der Kopplung und Kohäsion, so dass es sei denn, Sie haben gute Gründe für die Verwendung dieses Ansatzes ist es besser, neu zu überdenken, Ihr Entwurf. Aber die C-Programmiersprache ermöglicht es Ihnen, dies zu tun.

Es gibt einige Fälle, wo die void-Zeiger erforderlich ist. Zum Beispiel die malloc() Funktion, die Speicher zuweist, liefert einen void-Zeiger enthält die Adresse des Bereichs, der reserviert wurde (oder NULL, wenn die Zuordnung fehlgeschlagen ist). Der void-Zeiger in diesem Fall können für eine einzelne malloc() Funktion zurückgeben kann die Adresse des Speichers, der für jede Art von variable. Das folgende zeigt die Verwendung von malloc() mit verschiedenen Variablen-Typen.

void yfunc (void)
{
    int *pIvalue = malloc(sizeof(int));
    char *paszStr = malloc(sizeof(char)*32);

    struct struct_1 *pStruct_1 = malloc (sizeof(*pStruct_1));
    struct struct_2 *pStruct_2Array = malloc (sizeof(*pStruct_2Array)*21);

    pStruct_1->iClass = 1; pStruct_1->iValue = 23;

    func2(pStruct_1);  //pStruct_1 is already a pointer so address of is not used

    {
        int i;
        for (i = 0; i < 21; i++) {
            pStruct_2Array[i].iClass = 2;
            pStruct_2Array[i].fValue = 123.33f;
            func2 (&pStruct_2Array[i]);  //address of particular array element.  could also use func2 (pStruct_2Array + i)
        }
    }
    free(pStruct_1);
    free(pStruct_2Array);   //free the entire array which was allocated with single malloc()
    free(pIvalue);
    free(paszStr);
}

InformationsquelleAutor Richard Chambers

printf("result = %d\n", (int)res); ist der Druck den Wert von res (pointer) als eine Nummer.
Denken Sie daran, dass ein pointer ist eine Adresse im Speicher, so dass diese gedruckt wird einige random suchen 32bit Zahl.

Wenn Sie etwas drucken wollte, der gespeicherte Wert an der angegebenen Adresse, dann müssen Sie (int)*res - obwohl das (int) ist unnötig.

edit: wenn Sie möchten, drucken Sie den Wert (ie -) der Zeiger dann sollten Sie %p es ist im wesentlichen die gleiche, aber die Formate die es besser versteht und wenn die Größe eines int und eines poitner sind verschiedene über Ihre Plattform

InformationsquelleAutor Martin Beckett

void *res = (int *)a;

a ist ein int aber kein ptr, vielleicht sollte es sein:

void *res = &a;

InformationsquelleAutor zchenah