C++ come passare ‘cio’ a riferimento a un puntatore

ho classe principale che mi piace passare il suo riferimento a un puntatore ad oggetti che ho creato, ma mi dà errore :

Di errore 1 errore C2664: “GameController::GameController(GameLayer *&)’ :
impossibile convertire il parametro 1 ‘GameLayer *const’ a ‘GameLayer *&’

ciò che ho in GameLayer ( oggetto principale )

m_pGameController = new GameController(this);

e nel GameController ho questo costruttore

GameController(GameLayer*& GameLayer)
{
 setGameLayer(gameLayer); //to GameLayer memeber ) 
}

il resone ho bisogno di essere in grado di modificare i dati in GameLayer da GameController (GUI roba)

Perché è necessario essere un riferimento? Ho intenzione di andare avanti e scommettere che probabilmente non.
this non è un GameLayer *&. È un GameLayer * o un const GameLayer *, a seconda del constness ‘ attualmente in esecuzione del metodo.
Si noti, inoltre, che, invece di una variabile si utilizza il nome del tipo stesso nel costruttore. GameController(GameLayer*& GameLayer) non dovrebbe essere GameController(GameLayer*& gameLayer)
Si prega di evitare di puntatori: GameController(GameLayer& GameLayer) e di m_GameController = GameController (*); – questo non è l’indirizzo const correttezza

OriginaleL’autore user63898 | 2013-09-01

4 Replies
  1. 5

    Prima, il tipo di this potrebbe essere GameLayer * const o const GameLayer * const a seconda che la funzione membro è const o non. Ma, è un const puntatore.

    Dopo aver detto che, un riferimento a un puntatore type *&ref significa indica che verrà modificato il puntatore del mouse, l’oggetto a cui fa riferimento.

    “In quanto, questo puntatore è un puntatore costante non è possibile assegnare a un non-const pointer(GameLayer * p)” in contesto di riferimenti.

    In caso di riferimenti a un puntatore, è possibile assegnare a un riferimento che consente di modificare il valore in this. Non è possibile assegnare a un punto di riferimento per un non-const puntatore(GameLayer *&p), ma è possibile assegnare un riferimento a un const puntatore cioè GameLayer *const &p.

    Così, cambiando il costruttore per GameController(GameLayer * const & gameLayer) dovrebbe funzionare.

    Ma non vedo alcun utilizzo attualmente.

    E se stai chiamando da un const funzione membro quindi this è il tipo di const *const quindi dovrai cambiare GameController(const GameLayer * const & gameLayer).

    “in Quanto, questo puntatore è un puntatore costante non è possibile assegnare a un non-const pointer(GameLayer * p)” — Sì, è possibile.
    In particolare: l’insieme di tutte le cose che può essere utilizzato per inizializzare GameLayer * è identico a l’insieme di tutte le cose che possono essere utilizzati per inizializzare GameLayer *const. Il const in che posizione ha effetto solo se è possibile assegnare a p, non influiscono su ciò che è possibile inizializzare. La differenza tra l’inizializzazione GameLayer *& e l’inizializzazione di GameLayer *const& è come dici tu.
    Sì, sono d’accordo. Ma non è quello che è scritto sopra è vero?
    No, quello che hai scritto non è del tutto vero. La parte che non è vero, in Quanto, questo puntatore è un puntatore costante non è possibile assegnare a un non-const pointer(GameLayer * p) ma è possibile assegnare ad un puntatore const (GameLayer * const p).”
    Si potrebbe si prega di notare, io sono in grado di ottenere.

    OriginaleL’autore Uchia Itachi

  2. 5

    non so perché stai usando *& ma funzionerà bene se volete fare:

    GameController(GameLayer* GameLayer)
    {
     setGameLayer(gameLayer); //to GameLayer memeber ) 
    }
    Dipende. Se il metodo che esegue la new GameController(this) è const (che sembra essere vera l’interrogante caso), quindi this sarà un const GameLayer * e costruttore di GameController (o un sovraccarico) dovrebbe prendere un const GameLayer *.
    Il metodo non è const in interrogante. Si può capire dal messaggio di errore.
    this può essere di tipo GameLayer * const o const GameLayer * const.
    No, non sono la stessa cosa. GameLayer *const significa che il puntatore è const ma il valore di punti per non.
    href=”http://c-faq.com/ansi/constptrconst.html” >sì, Itachi e hai ragione. Ho bisogno di più di tè.

    OriginaleL’autore No Idea For Name

  3. 1

    ‘ questo’ è un puntatore costante e quindi si può passare come riferimento o const riferimento.

     m_pGameController = new GameController(*this);
    
     GameController(GameLayer& GameLayer) {}
    Non si passa this come riferimento, si passa *this come riferimento. Che è perfettamente valido, ma non che cosa la domanda è di circa.
    D’accordo, ma ho usato di riferimento, perché è più C++

    OriginaleL’autore alexbuisson

  4. 1

    “Nessuna Idea Per il Nome”‘s risposta è quasi certamente di che cosa avete bisogno, ma per ulteriori informazioni il motivo per cui il codice non funziona è che GameLayer*& non significa solo “sono in grado di modificare il GameLayer oggetto a cui si riferisce il valore dell’argomento ho ricevuto”, che significa “io sono passato un riferimento a un puntatore a un GameLayer oggetto che posso modificare, e io posso anche usare questo riferimento per modificare il valore del puntatore stesso”.

    Così, per esempio:

    void foo(GameLayer *&layerptr) {
        layerptr = new GameLayer();
    }
    
    void main() {
        GameLayer *ptr = 0;
        std::cout << (void*)ptr << "\n";
        foo(ptr);
        std::cout << (void*)ptr << "\n";
    }

    Il valore della ptr variabile in main è cambiato. Questo è ciò che passa-da-non-const-il riferimento è per, e quindi non è necessario passare-da-non-const-riferimento qui. Passare un puntatore a un GameLayer oggetto (tipo GameLayer*) o un riferimento (tipo GameLayer&), ma non entrambi.

    Il motivo non è valido per passare this di una funzione che accetta GameLayer*& è che this non è una variabile e non può essere assegnato a — in C++ il gergo non è un lvalue e quindi non si può prendere un lvalue di riferimento. this ti dice cosa oggetto il membro corrente funzione viene chiamata, e non si può decidere all’improvviso che la tua funzione membro sarà operativo su un oggetto diverso.

    OriginaleL’autore Steve Jessop

Lascia un commento