Erreur: prendre l'adresse de temporaire [-fpermissive]

J'ai été à la recherche dans ce pour quelques heures, en vain. Fondamentalement, je n'ai

struct rectangle {
    int x, y, w, h;
};

rectangle player::RegionCoordinates() //Region Coord
{
    rectangle temp;
    temp.x = colRegion.x + coordinates.x;
    temp.w = colRegion.w;
    temp.y = colRegion.y + coordinates.y;
    temp.h = colRegion.h;

    return temp;
}

//Collision detect function
bool IsCollision (rectangle * r1, rectangle * r2)
{
    if (r1->x < r2->x + r2->w &&
        r1->x + r1->w > r2->x &&
        r1->y < r2->y + r2->h &&
        r1->y + r1->h > r2->y) 
        {
            return true;
        }
    return false;
}

//blah blah main while loop
if (IsCollision(&player1.RegionCoordinates(), &stick1.RegionCoordinates())) //ERROR
{
    player1.score+=10;
    stick1.x = rand() % 600+1;
    stick1.y = rand() % 400+1;
    play_sample(pickup,128,128,1000,false);
}

Des idées? Je suis sûr que c'est quelque chose de vraiment évident, mais pour la vie de moi je ne peux pas la comprendre.

OriginalL'auteur Jack Riales | 2013-05-10

allegro c++collision collision-detection

RegionCoordinates() retourne un objet par valeur. Cela signifie un appel à RegionCoordinates() renvoie une instance temporaire de rectangle. Comme le message d'erreur dit, vous essayez de prendre l'adresse de cet objet temporaire, qui n'est pas légal en C++.

Pourquoi ne IsCollision() prendre des pointeurs de toute façon? Il serait plus naturel que de prendre ses paramètres par référence const:

bool IsCollision (const rectangle &r1, const rectangle &r2) {
if (r1.x < r2.x + r2.w &&
    r1.x + r1.w > r2.x &&
    r1.y < r2.y + r2.h &&
    r1.y + r1.h > r2.y) {
        return true;
    }
        return false;
}
//blah blah main while loop
if (IsCollision(player1.RegionCoordinates(), stick1.RegionCoordinates())) //no error any more
{
player1.score+=10;
stick1.x = rand() % 600+1;
stick1.y = rand() % 400+1;
play_sample(pickup,128,128,1000,false);
}

OriginalL'auteur Angew

4

Depuis IsCollision prend un rectangle * et vous prenez l'adresse de la suite ici:
```
if (IsCollision(&player1.RegionCoordinates(), &stick1.RegionCoordinates()))
```
Vous sont les plus susceptibles de retourner un rectangle de retour de RegionCoordinates() qui est une variable temporaire, car il va disparaître après la if déclaration est faite. Si vous affectez le résultat de RegionCoordinates() à une variable, alors il ne sera plus que de manière temporaire et vous pouvez ensuite prendre l'adresse:
```
rectangle r1 = player1.RegionCoordinates() ;
rectangle r2 = stick1.RegionCoordinates() ;
if (IsCollision(&r1, &r2))
```
Sinon, vous pouvez prendre les paramètres comme const références qui serait le plus C++ façon de le faire:
```
bool IsCollision (const rectangle &r1, const rectangle  &r2)
```
OriginalL'auteur Shafik Yaghmour
1

Donné le genre d'erreur que vous obtenez, je dois assumer RegionCoordinates() est de retourner un objet par valeur, provoquant la création d'un temporaire, et vous prenez l'adresse de que temporaire.

L'adresse de l'opérateur nécessite une lvalue que son opérande, mais vous êtes en l'appliquant à un rvalue (temporaires sont rvalues).

Vous pourriez le faire (si vous n'êtes pas à l'aide de C++11, remplacer auto avec le type retourné par RegionCoordinates):
```
auto rcPlayer1 = player1.RegionCoordinates();
auto rcStick1 = player1.RegionCoordinates();
if (IsCollision(&rcPlayer1, &rcStick1)) //ERROR
{
    player1.score+=10;
    stick1.x = rand() % 600+1;
    stick1.y = rand() % 400+1;
    play_sample(pickup,128,128,1000,false);
}
```
Alternativement, vous pouvez modifier IsCollision de sorte qu'il accepte références plutôt que des pointeurs, comme suggéré par Angew dans sa réponse.

OriginalL'auteur Andy Prowl

Vous devez vous connecter pour publier un commentaire.