Nicolas Aunai writes:je comprends l'intéret d'une variable static dans une classe,
mais pas celui d'une méthode static... que sont-elles et à
quoi servent-elles ?
Elles sont des fonctions membres auxquelles on ne passe pas de pointeur
this.
Nicolas Aunai <nicolas.aunai@free.fr> writes:
je comprends l'intéret d'une variable static dans une classe,
mais pas celui d'une méthode static... que sont-elles et à
quoi servent-elles ?
Elles sont des fonctions membres auxquelles on ne passe pas de pointeur
this.
Nicolas Aunai writes:je comprends l'intéret d'une variable static dans une classe,
mais pas celui d'une méthode static... que sont-elles et à
quoi servent-elles ?
Elles sont des fonctions membres auxquelles on ne passe pas de pointeur
this.
Le gros avantage est qu'une méthode statique est en tout point similaire
à une fonction (pointeurs, appels, etc).
Il est généralement nécessaire d'y avoir recours pour des
fonctionnalités encapsulées dans une classe mais nécessitant un passage
de pointeur sur fonction (pour un classe CThread par exemple).
Le gros avantage est qu'une méthode statique est en tout point similaire
à une fonction (pointeurs, appels, etc).
Il est généralement nécessaire d'y avoir recours pour des
fonctionnalités encapsulées dans une classe mais nécessitant un passage
de pointeur sur fonction (pour un classe CThread par exemple).
Le gros avantage est qu'une méthode statique est en tout point similaire
à une fonction (pointeurs, appels, etc).
Il est généralement nécessaire d'y avoir recours pour des
fonctionnalités encapsulées dans une classe mais nécessitant un passage
de pointeur sur fonction (pour un classe CThread par exemple).
Le gros avantage est qu'une méthode statique est en tout point similaire
à une fonction (pointeurs, appels, etc).
Il est généralement nécessaire d'y avoir recours pour des
fonctionnalités encapsulées dans une classe mais nécessitant un passage
de pointeur sur fonction (pour un classe CThread par exemple).
A moins que je n'ai pas compris votre propos, il est tout à fait
possible de faire des pointeurs vers des méthodes de classes non
statiques.
Le gros avantage est qu'une méthode statique est en tout point similaire
à une fonction (pointeurs, appels, etc).
Il est généralement nécessaire d'y avoir recours pour des
fonctionnalités encapsulées dans une classe mais nécessitant un passage
de pointeur sur fonction (pour un classe CThread par exemple).
A moins que je n'ai pas compris votre propos, il est tout à fait
possible de faire des pointeurs vers des méthodes de classes non
statiques.
Le gros avantage est qu'une méthode statique est en tout point similaire
à une fonction (pointeurs, appels, etc).
Il est généralement nécessaire d'y avoir recours pour des
fonctionnalités encapsulées dans une classe mais nécessitant un passage
de pointeur sur fonction (pour un classe CThread par exemple).
A moins que je n'ai pas compris votre propos, il est tout à fait
possible de faire des pointeurs vers des méthodes de classes non
statiques.
James Kanze wrote:Nicolas Aunai writes:je comprends l'intéret d'une variable static dans une classe,
mais pas celui d'une méthode static... que sont-elles et à quoi
servent-elles ?
Elles sont des fonctions membres auxquelles on ne passe pas de
pointeur this.
Le fait qu'elles n'aient pas le pointeur this par défaut en fait
surtout des fonctions (et non pas des méthodes) qui sont simplement
encapsulées dans la classe comme des fonctions le seraient dans un
namespace.
Le gros avantage est qu'une méthode statique est en tout point
similaire à une fonction (pointeurs, appels, etc).
Il est généralement nécessaire d'y avoir recours pour des
fonctionnalités encapsulées dans une classe mais nécessitant un
passage de pointeur sur fonction (pour un classe CThread par exemple).
James Kanze wrote:
Nicolas Aunai <nicolas.aunai@free.fr> writes:
je comprends l'intéret d'une variable static dans une classe,
mais pas celui d'une méthode static... que sont-elles et à quoi
servent-elles ?
Elles sont des fonctions membres auxquelles on ne passe pas de
pointeur this.
Le fait qu'elles n'aient pas le pointeur this par défaut en fait
surtout des fonctions (et non pas des méthodes) qui sont simplement
encapsulées dans la classe comme des fonctions le seraient dans un
namespace.
Le gros avantage est qu'une méthode statique est en tout point
similaire à une fonction (pointeurs, appels, etc).
Il est généralement nécessaire d'y avoir recours pour des
fonctionnalités encapsulées dans une classe mais nécessitant un
passage de pointeur sur fonction (pour un classe CThread par exemple).
James Kanze wrote:Nicolas Aunai writes:je comprends l'intéret d'une variable static dans une classe,
mais pas celui d'une méthode static... que sont-elles et à quoi
servent-elles ?
Elles sont des fonctions membres auxquelles on ne passe pas de
pointeur this.
Le fait qu'elles n'aient pas le pointeur this par défaut en fait
surtout des fonctions (et non pas des méthodes) qui sont simplement
encapsulées dans la classe comme des fonctions le seraient dans un
namespace.
Le gros avantage est qu'une méthode statique est en tout point
similaire à une fonction (pointeurs, appels, etc).
Il est généralement nécessaire d'y avoir recours pour des
fonctionnalités encapsulées dans une classe mais nécessitant un
passage de pointeur sur fonction (pour un classe CThread par exemple).
Le gros avantage est qu'une méthode statique est en tout point similaire
à une fonction (pointeurs, appels, etc).
Il est généralement nécessaire d'y avoir recours pour des
fonctionnalités encapsulées dans une classe mais nécessitant un passage
de pointeur sur fonction (pour un classe CThread par exemple).
A moins que je n'ai pas compris votre propos, il est tout à fait
possible de faire des pointeurs vers des méthodes de classes non
statiques.
Vi vi, vu que pas mal de gens ici savent ça, il semble qu'effectivement
le propos t'ait échappé - mais c'est pas grave, on ne peut pas suivre
tout dans les moindres détails.
Le gros avantage est qu'une méthode statique est en tout point similaire
à une fonction (pointeurs, appels, etc).
Il est généralement nécessaire d'y avoir recours pour des
fonctionnalités encapsulées dans une classe mais nécessitant un passage
de pointeur sur fonction (pour un classe CThread par exemple).
A moins que je n'ai pas compris votre propos, il est tout à fait
possible de faire des pointeurs vers des méthodes de classes non
statiques.
Vi vi, vu que pas mal de gens ici savent ça, il semble qu'effectivement
le propos t'ait échappé - mais c'est pas grave, on ne peut pas suivre
tout dans les moindres détails.
Le gros avantage est qu'une méthode statique est en tout point similaire
à une fonction (pointeurs, appels, etc).
Il est généralement nécessaire d'y avoir recours pour des
fonctionnalités encapsulées dans une classe mais nécessitant un passage
de pointeur sur fonction (pour un classe CThread par exemple).
A moins que je n'ai pas compris votre propos, il est tout à fait
possible de faire des pointeurs vers des méthodes de classes non
statiques.
Vi vi, vu que pas mal de gens ici savent ça, il semble qu'effectivement
le propos t'ait échappé - mais c'est pas grave, on ne peut pas suivre
tout dans les moindres détails.
Le gros avantage est qu'une méthode statique est en tout point similaire
à une fonction (pointeurs, appels, etc).
Il est généralement nécessaire d'y avoir recours pour des
fonctionnalités encapsulées dans une classe mais nécessitant un passage
de pointeur sur fonction (pour un classe CThread par exemple).
A moins que je n'ai pas compris votre propos, il est tout à fait
possible de faire des pointeurs vers des méthodes de classes non statiques.
Le gros avantage est qu'une méthode statique est en tout point similaire
à une fonction (pointeurs, appels, etc).
Il est généralement nécessaire d'y avoir recours pour des
fonctionnalités encapsulées dans une classe mais nécessitant un passage
de pointeur sur fonction (pour un classe CThread par exemple).
A moins que je n'ai pas compris votre propos, il est tout à fait
possible de faire des pointeurs vers des méthodes de classes non statiques.
Le gros avantage est qu'une méthode statique est en tout point similaire
à une fonction (pointeurs, appels, etc).
Il est généralement nécessaire d'y avoir recours pour des
fonctionnalités encapsulées dans une classe mais nécessitant un passage
de pointeur sur fonction (pour un classe CThread par exemple).
A moins que je n'ai pas compris votre propos, il est tout à fait
possible de faire des pointeurs vers des méthodes de classes non statiques.
Par contre, ma solution actuelle utilise un truc pas très joli, pour
permettre au callback d'accéder aux données de l'unique objet de cette
classe : une variable globale. Si j'essaye de schématiser, ça nous donne
quelque chose comme :
class A {
public:
A () {
// ...
objet_sdl.callback = mon_callback;
objet_sdl.pseudo_this = 0; // utilisé comme argument
};
private:
type_sdl objet_sdl;
int i; // diverses données
static void mon_callback (void* pseudo_this, int& p);
// pas grand chose en paramètres
};
A le_A; // promis, c'est pas de moi ;-P
void A::mon_callback (void* pseudo_this, int& p) {
// ...
p = le_A.i; // des choses du genre
}
A part «c'est moche», qu'est-ce que vous en pensez ?
Je devrais utiliser le paramètre prévu par SDL pour tenir lieu de this
(mais c'est un void* !- ) ?
Je fais de ma variable globale un membre statique ? (Ah mais non, j'ai
pas prévu d'en faire un pointeur...) Je change ma classe en namespace
? Autre chose ? Ou bien je garde ce que j'ai et j'arrête de poser des
questions bêtes ?-)
Par contre, ma solution actuelle utilise un truc pas très joli, pour
permettre au callback d'accéder aux données de l'unique objet de cette
classe : une variable globale. Si j'essaye de schématiser, ça nous donne
quelque chose comme :
class A {
public:
A () {
// ...
objet_sdl.callback = mon_callback;
objet_sdl.pseudo_this = 0; // utilisé comme argument
};
private:
type_sdl objet_sdl;
int i; // diverses données
static void mon_callback (void* pseudo_this, int& p);
// pas grand chose en paramètres
};
A le_A; // promis, c'est pas de moi ;-P
void A::mon_callback (void* pseudo_this, int& p) {
// ...
p = le_A.i; // des choses du genre
}
A part «c'est moche», qu'est-ce que vous en pensez ?
Je devrais utiliser le paramètre prévu par SDL pour tenir lieu de this
(mais c'est un void* !- ) ?
Je fais de ma variable globale un membre statique ? (Ah mais non, j'ai
pas prévu d'en faire un pointeur...) Je change ma classe en namespace
? Autre chose ? Ou bien je garde ce que j'ai et j'arrête de poser des
questions bêtes ?-)
Par contre, ma solution actuelle utilise un truc pas très joli, pour
permettre au callback d'accéder aux données de l'unique objet de cette
classe : une variable globale. Si j'essaye de schématiser, ça nous donne
quelque chose comme :
class A {
public:
A () {
// ...
objet_sdl.callback = mon_callback;
objet_sdl.pseudo_this = 0; // utilisé comme argument
};
private:
type_sdl objet_sdl;
int i; // diverses données
static void mon_callback (void* pseudo_this, int& p);
// pas grand chose en paramètres
};
A le_A; // promis, c'est pas de moi ;-P
void A::mon_callback (void* pseudo_this, int& p) {
// ...
p = le_A.i; // des choses du genre
}
A part «c'est moche», qu'est-ce que vous en pensez ?
Je devrais utiliser le paramètre prévu par SDL pour tenir lieu de this
(mais c'est un void* !- ) ?
Je fais de ma variable globale un membre statique ? (Ah mais non, j'ai
pas prévu d'en faire un pointeur...) Je change ma classe en namespace
? Autre chose ? Ou bien je garde ce que j'ai et j'arrête de poser des
questions bêtes ?-)
