klasszikus C pointerek, mi a különbség?

Kezdjük az elején.

void *x;
Ekkor x egy olyan változó lesz, ami egy címet tartalmaz, és a cím egy olyan memóriaterületre mutat, ahol egy "void" típusú érték található vagy egy tömb első eleme, amely tömbnek az elemei "void" típusúak.
Így
v = *x;
értékadás az jelenti, hogy behívjuk azt a "void" típusú változót, ami x-ben lévő címen van, és v-be másoljuk.

void **x;
Ekkor az x-ben lévő cím nem közvetlenül "void" típusú elemre (vagy tömbre) mutat, hanem olyan mutatóra (vagy mutató tömbre), ami (vagy aminek az elemei) már tényleg "void" típusú elemre (vagy tömbre) mutat (vagy mutatnak). Tehát a lényeg, hogy x egy másik mutatóra fog mutatni nem pedig "void" típusú memória területre.
Így
pv = *x;
értékadás azt jelenti, hogy egy olyan változónak adjuk át az x által mutatott memóriaterület tartalmát, amit void *pv; módon deklaráltunk. Azaz a pv-ben lévő cím fog majd egy "void" típusú változóra mutatni.

void *nem_void_tipus *x;
Egy ilyen deklarációt az én fordítóm (g++) nem enged meg.
Sőt ezt sem:
void *void *x;
Ezt a szintaktikát én abszolút nem értem. Nem is tudom jelenlegi fogalmaimmal elképzelni, hogy mi lehet.
Lehet, hogy C-ben megengedett, C++-ban pedig nem?
Ha valaki tudja a választ ezekre a kérdésekre, ne hallgassa el! Én is szívesen okulnék belőle.

Egyébként számomra az is érdekes, hogyan lehet egy változó "void" típusú. Mit takar ez?

Elírás lehet a második. Honnan másoltad?

void *tsearch(const void *key, void **rootp, int(*compar)(const void *, const void *));

void *tfind(const void *key, const void **rootp, int(*compar)(const void *, const void *));

Azaz válaszolva a kérdésedre, a különbség egy plussz const, és hogy az egyik el van írva.

Amúgy:
man tsearch
man tfind
-ból másoltam a deklarációkat. Nem tévedhet nagyot. Szerintem első körben ezt használjátok.

A fo kerdesre eddig adott valaszok nem felelnek meg a valosagnak.

void **x;

Itt x egy olyan mutato, amely egy tetszoleges tipusu mutatora mutat.

void *const *x;

Itt x egy olyan mutato, amely egy tetszoleges tipusu konstans mutatora mutat.

Tehat hol kulonbozik a hasznalat:

void **x;
void *const *y;

x = &ptr;         // helyes: x nem konstans
y = &ptr;         // helyes: y nem konstans
*x = &a;          // helyes: x nem konstans mutatora mutat
*y = &a;          // HIBA: y konstans mutatora mutat, nem lehet ertekadas
**x = 3;          // HIBA: **x void tipusu, nem lehet neki erteket adni
**y = 3;          // HIBA: **y void tipusu, nem lehet neki erteket adni
*(int *)*x = 3;   // explicit tipuskonverzio, rendben
*(int *)*y = 3;   // explicit tipuskonverzio, rendben

Nem láttam egyértelmű választ erre eddig a szálban, szóval (kis fejtágítás ^^):
egy mutató kétféleképpen lehet const:

ad1) úgy, hogy az általa megcímzett memóriát rajta keresztül nem lehet módosítani. Ebben az esetben az, hogy a mutató hova mutat, szabadon módosítható a program futása során. Pl:

int i, j;
const int *ip = &i;   // helyes
ip = &j;              // helyes
*ip = 1;              // fordítási hiba

ad2) úgy, hogy a mutató által megcímzett memóriaterület ugyan módosítható rajta keresztül, de az nem, hogy a mutató hova mutasson. Ekkor értelemszerűen inicializáláskor értéket kell adni a mutatónak. Ennek a szintaxisa az az ominózus *const. Pl:

int i, j;
int *const ip = &i;  // helyes
*ip = 1;             // helyes
ip = &j;             // hibás

A kettőt lehet kombinálni is. Ekkor egy "nagyon const" mutatót kapunk valamire, amin semmit nem lehet módosítani. ;)

C-ben a const-ot simán lehet konvertálni nem const-tá, ott nincs sok értelme.
C++ban viszont van, ott komolyan veszik ezt a kulcsszót.

Egyébként C++ban ezért van értelme egy ilyen definíciójú metódusnak:

class A {
    public:
    void aaa();
    void vmi() const;
};

A fenti deklaráció azt jelenti, hogy a vmi() metódushívás nem fogja megváltoztatni az objektumát, ezért akkor is meghívható, ha az objektumhoz csak const referencián/mutatón keresztül férünk hozzá. Pl:

const A *a = ....; // vhogy értéket kap
a->vmi();          // helyes
a->aaa();          // fordítási hiba

Úgy is mondhatnánk, hogy az aaa() metódusban a "this" mutató vhogy így lehet deklarálva:

A *const this = ...;

...míg a vmi() metódusban vhogy így:

const A *const this = ...;

Üdv,
kl223

Át fogom nézni az összes hozzászólást, és kipróbálok néhány variációt. Valószínűleg az sokat fog segíteni a megértésben.