Appelant la méthode privée en C ++

C'est purement une question théorique, je sais que si l'on déclare une méthode privée, vous ne devriez probablement pas l'appeler. J'ai réussi à appeler privé virtuel des méthodes et des changements de membres privés pour les instances, mais je ne peux pas comprendre comment appeler une méthode virtuelle (sans l'aide de __asm). Est-il un moyen d'obtenir le pointeur de la méthode? Existe-il d'autres façons de le faire?

EDIT: je ne veux pas changer la définition de la classe! Je veux juste un hack/solution de contournement. 🙂

source d'informationauteur Luchian Grigore

c++

#include le fichier d'en-tête, mais:

#define private public
#define class struct

Clairement, vous aurez besoin pour obtenir autour de divers inclusion gardes etc et ce, dans un isolé unité de compilation.

EDIT:
Encore hackish, mais moins:

#include <iostream>

#define private friend class Hack; private

class Foo
{
public:
    Foo(int v) : test_(v) {}
private:
    void bar();
    int test_;
};
#undef private
void Foo::bar() { std::cout << "hello: " << test_ << std::endl; }

class Hack
{
public:
    static void bar(Foo& f) {
        f.bar();
    }
};

int _tmain(int argc, _TCHAR* argv[])
{
    Foo f(42);
    Hack::bar(f);
    system("pause");
    return 0;
}

Voir mon blog. Je vais reposter le code ici

template<typename Tag>
struct result {
  /* export it ... */
  typedef typename Tag::type type;
  static type ptr;
};

template<typename Tag>
typename result<Tag>::type result<Tag>::ptr;

template<typename Tag, typename Tag::type p>
struct rob : result<Tag> {
  /* fill it ... */
  struct filler {
    filler() { result<Tag>::ptr = p; }
  };
  static filler filler_obj;
};

template<typename Tag, typename Tag::type p>
typename rob<Tag, p>::filler rob<Tag, p>::filler_obj;

En classe avec les membres privés

struct A {
private:
  void f() {
    std::cout << "proof!" << std::endl;
  }
};

Et la façon d'y accéder

struct Af { typedef void(A::*type)(); };
template class rob<Af, &A::f>;

int main() {
  A a;
  (a.*result<Af>::ptr)();
}

Il peut être appelée que si un public fonction retourne l'adresse de la private fonction, alors n'importe qui peut utiliser cette adresse pour appeler la fonction privée.

Exemple,

class A
{
   void f() { cout << "private function gets called" << endl; }
 public:
     typedef void (A::*pF)();
     pF get() { return &A::f; }
};

int main() 
{
        A a;
        void (A::*pF)() = a.get();
        (a.*pF)(); //it invokes the private function!
}

De sortie:

private function gets called

Démo à ideone : http://www.ideone.com/zkAw3

2

Vous avez ami des classes et des fonctions.

Je sais que si l'on déclare une méthode privée, vous avez probablement
ne devrait pas l'appeler.

Le point n'est pas "tu ne devrais pas l'appeler", c'est juste "vous ne pouvez pas l'appeler". Que sur la terre qui sont que vous essayez de faire?

La façon la plus simple:

#define private public
#define protected public

1

Appel de la méthode privée à partir d'une fonction publique de la même classe.
1

De suivi de la T. E. D. de répondre: Ne pas modifier l'en-tête. Au lieu de créer votre propre copie de l'en-tête et insérer des friend déclarations que le faux copie de l'en-tête. Dans votre code source, #include ce faux-tête plutôt que de la vraie. Voila!

Modification du privé au public, pourrait changer la faiblesse des symboles qui sont le résultat de méthodes inline, qui à son tour pourrait provoquer l'éditeur de liens pour se plaindre. La faiblesse des symboles qui sont le résultat de méthodes inline aura les mêmes signatures avec le faux et le vrai-têtes si tout ce qui est fait est d'ajouter quelques ami déclarations. Avec ces ami déclarations, vous pouvez maintenant faire toutes sortes de mauvaises choses avec la classe telles que l'accès aux données privées et en appelant les membres privés.

Additif

Cette approche ne fonctionnera pas si l'en-tête en question utilise #pragma once au lieu d'un #include garde pour assurer l'en-tête est idempotent.
0

Bien, le moyen le plus évident serait de modifier le code de sorte qu'il n'est plus privé.

Si vous insistez sur la recherche d'un mal façon de le faire...eh bien...avec certains compilateurs il peut fonctionner à créer votre propre version du fichier d'en-tête où une méthode est public au lieu de private. Le mal a une mauvaise façon de rebondir sur vous (c'est pourquoi nous l'appelons "le mal").
0

Je pense que le plus proche que vous obtiendrez à un hack est-cemais ce n'est pas seulement imprudent, mais comportement indéfini de sorte qu'il n'a pas de sémantique. Si elle arrive à fonctionner de la manière que vous voulez pour n'importe quel programme unique invocation, alors que c'est un pur hasard.
0

Définir une catégorie similaire, qui est le même en dehors de la fonction publique.

Puis transtypage d'un objet avec la fonction privée à la fonction publique, vous pouvez ensuite appeler la fonction publique.

Si nous parlons de MSVC, je pense que la façon la plus simple avec aucune autre mal que le fait d'appeler une méthode privée elle-même est le grand __asm:

class A
{
private:
    void TestA () {};
};

A a;
__asm
{
    //MSVC assumes (this) to be in the ecx.
    //We cannot use mov since (a) is located on the stack
    //(i.e. [ebp + ...] or [esp - ...])
    lea     ecx, [a]
    call    A::TestA
}

Pour GCC, il peut être fait en utilisant une déformation du nom d'une fonction.

#include <stdio.h>

class A {
public:
    A() {
        f(); //the function should be used somewhere to force gcc to generate it
    }
private:
    void f() { printf("\nf"); }
};

typedef void(A::*TF)();

union U {
    TF f;
    size_t i;
};

int main(/*int argc, char *argv[]*/) {
    A a;
    //a.f(); //error
    U u;
    //u.f = &A::f; //error

    //load effective address of the function
    asm("lea %0, _ZN1A1fEv"
    : "=r" (u.i));
    (a.*u.f)();
    return 0;
}

Les noms déformés peut être trouvé en nm *.o fichiers.

Ajoutez -masm=intel option du compilateur

Sources: GCC erreur: Ne peut pas appliquer offsetof à la fonction de membre de MyClass::Mafonction
https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html

Vous devez vous connecter pour publier un commentaire.