C++ Surcharge Statique de la Fonction avec les Non-Statique de la Fonction

Je voudrais imprimer deux choses différentes en fonction de si une fonction est appelée de façon statique avec Foo::print() ou d'une instance de Foo foo; foo.print();

EDIT: Voici une définition de classe qui certainement ne fonctionne pas, comme répondu par quelques personnes déjà.

class Foo {
    string bla;
    Foo() { bla = "nonstatic"; }

    void print() { cout << bla << endl; }
    static void print() { cout << "static" << endl; }
};

Cependant, est-il un bon moyen d'obtenir cet effet? En gros, je voudrais faire:

if(this is a static call)
    do one thing
else
    do another thing

Formulé d'une autre manière, je sais que PHP peut vérifier si le *this variable est définie ou non pour déterminer si la fonction est appelée de façon statique. Est-ce que C++ ont la même capacité?

Pourquoi ne pas l'essayer et voir?
les deux versions de print() portent la même signature. Et je ne pense pas qu'ils peuvent être surchargés de cette façon.

OriginalL'auteur Alan Turing | 2011-03-19

  1. 55

    Non, c'est directement interdit par la norme:

    ISO 14882:2003 Standard C++ 13.1/2 – Overloadable déclarations

    Certaines déclarations de fonction ne peut pas
    surcharge:

    • Les déclarations de fonction qui ne diffèrent que par le type de retour ne peut pas être surchargé.
    • Membre déclarations de fonction avec le même nom et les mêmes types de paramètre ne peut pas être surchargé
      si l'un d'eux est un static membre de déclaration de fonction (9.4).

    ...

    [Exemple:

    class X {
    static void f();
    void f();                //ill-formed
    void f() const;          //ill-formed
    void f() const volatile; //ill-formed
    void g();
    void g() const;          //OK: no static g
    void g() const volatile; //OK: no static g
};

    la fin de l'exemple]

    ...

    En outre, il serait de toute façon ambiguë puisqu'il est possible d'appeler des fonctions statiques sur les instances:

    ISO 14882:2003 Standard C++ 9.4/2 – membres Statiques

    Un membre statique s de classe X peut être
    appelée à l'aide de la qualifié-id
    expression X::s; il n'est pas nécessaire
    pour utiliser la classe membre de la syntaxe d'accès
    (5.2.5) pour désigner une static member. Un
    static membre peut être appelée à l'aide
    le membre de la classe de la syntaxe d'accès, dans
    auquel cas le object-expression est
    évalué. [Exemple:

    class process {
public:
        static void reschedule();
}
process& g();
void f()
{
        process::reschedule(); //OK: no object necessary
        g().reschedule();      //g() is called
}

    la fin de l'exemple]

    ...

    Donc il n'y aurait ambiguïté avec ce que vous avez:

    class Foo
{
public:
    string bla;
    Foo() { bla = "nonstatic"; }
    void print() { cout << bla << endl; }
    static void print() { cout << "static" << endl; }
};

int main()
{
    Foo f;
    //Call the static or non-static member function?
    //C++ standard 9.4/2 says that static member
    //functions are callable via this syntax. But
    //since there's also a non-static function named
    //"print()", it is ambiguous.
    f.print();
}

    Pour répondre à votre question, à savoir si vous pouvez vérifier quelle instance d'une fonction membre est appelé, il y a le this mot-clé. Le this mot clé de points de l'objet pour lequel la fonction a été appelée. Cependant, la this mot clé sera toujours pointer vers un objet c'est à dire qu'elle ne sera jamais NULL. Par conséquent, il n'est pas possible de vérifier si une fonction est appelée de façon statique ou non à la PHP.

    ISO 14882:2003 Standard C++ 9.3.2/1 – Le pointeur this

    Dans le corps d'un non statiques (9.3)
    fonction membre, le mot-clé this est un
    non lvalue expression dont la valeur est
    l'adresse de l'objet pour lequel
    la fonction est appelée.

    Je vous remercie pour cette réponse très claire, mais j'ai demandé à (mal, je m'en excuse) que le comportement d'une fonction statique pourrait être déterminé sur la base qu'elle est appelée de façon statique ou à partir d'une instance de la classe. Voir la dernière partie de ma question.
    Fridman: je ne pense pas que vous avez demandé à mal. Vous avez demandé "est-ce que C++ ont la même capacité?" et j'ai répondu que vous ne pouvez pas basé sur la norme C++ (définit de la langue).
    Je me sens pire et pour le pire à propos de mon phrasé de la question, en particulier le titre. Il y a en fait deux questions. Tout d'abord, si vous pouvez la surcharge statique avec des non-statique. C'est ce QUE vous avez répondu très bien. La deuxième question est de savoir si vous pouvez déterminer s'il existe une instance de la classe associée à l'appel de la fonction statique. Comme vous l'avez dit, vous pouvez utiliser une fonction statique comme ceci: Foo foo; foo.print(); puis-je accéder à la foo exemple à partir de l'intérieur de cet appel à print(); ?
    Fridman: Ah, d'accord. Vous avez clarifié pour moi, donc ne vous inquiétez pas au sujet de votre phrasé. Je vais répondre à cette partie.

    OriginalL'auteur In silico

  2. 2

    Ce n'est certainement pas autorisé. Je ne vois pas de moyen propre de la réalisation de cet. Quel est exactement le problème que vous voulez résoudre de cette façon?

    C'est un peu compliqué à expliquer mais j'ai quelques non-statique des variables que je voudrais la fonction statique de l'accès lorsqu'il est appelé à partir d'une instance de la classe. Je pourrais juste le nom de la fonction de quelque chose d'autre et de le rendre non-statique, mais j'ai pensé qu'il serait un très beau API cohérente qui a juste une fonction de la disposition de l'utilisateur. Désolé si ce n'est pas logique.
    vous semblez être un malentendu quoi "statique". Vous pas accès non-variables statiques avec une méthode statique; vous n'êtes pas affaire avec une instanciation de la classe. La seule façon de le faire serait de passer à une instanciation de la classe de la méthode statique.
    Je sais que Brian, mais vous pouvez appeler les membres statiques "non-statique", donc au lieu de Foo::print();, utilisez Foo foo; foo.print();
    Vous n'êtes pas à l'appeler "non statique" ... c'est encore d'appeler la même fonction statique dans la classe, et n'a rien à voir avec l'instance de la classe que vous avez là. Ce n'est pas différent Foo::print(); Voir: stackoverflow.com/questions/325555/... - je crois que c'est la source de votre confusion.
    Ah ok, donc l'instance de foo dans ce cas n'a pas de sens et ne peut pas être accessible depuis l'intérieur de print(). Merci pour cette précision Brian

    OriginalL'auteur Janick Bernet

  3. 1

    Vous ne pouvez pas le faire exactement, voir In silico de la réponse.

    Mais vous pouvez faire Foo::print() et Foo foo; print(foo); faire des choses différentes. (Définir void print(Foo& foo) dans le même espace de noms que class Foo, il sera trouvé par ADL).

    En tout cas, ce n'est pas une bonne idée. Vous avez deux fonctions très similaires dans leur nom, qui ne sont des choses complètement différentes, ce qui viole les bons principes de conception.

    Je sais que cela semble comme une mauvaise conception, parce que je ne suis pas en expliquant précisément le problème que j'essaie de résoudre. Il fait réellement sens pour ce que je suis en train de faire. Cependant, dans le contexte de C++, il peut être une mauvaise façon de faire. Je sais que c'est une bonne chose à faire dans un langage interprété comme PHP.
    Les deux fonctions doivent être en train de faire des choses différentes, donc, assurément, l'un d'eux peut avoir un nom différent. Peut-être Foo::PrintLiveFooCount(); et Foo foo; foo.print();?

    OriginalL'auteur Ben Voigt

  4. 1

    La réponse est non, parce que vous ne pouvez pas surcharger basé sur un type de retour.

    Vous pouvez certainement avoir des méthodes statiques dans une classe, mais vous ne pouvez pas avoir:

    static void foo();
void foo();

    Car ils ont la même signature de la méthode.

    EDIT: j'ai vu votre commentaire disant pourquoi vous avez voulu faire cela, et que vous vouliez accéder aux variables membres. Vous devez faire ceci:

    static void print(Foo f);
void print();
....
static void Foo::print(Foo f)
{
    int a = f.a;
    //do something with a
}

    (Ou de créer des accesseurs et mutateurs Foo, etc, mais c'est l'idée générale)

    Mais s'il ne le fait que, la prochaine mainteneur avons un gros WTF moment, en essayant de comprendre pourquoi tout le monde préfère Foo::print(f) sur f.print().

    OriginalL'auteur Brian Roach