sirven - punteros en c++ ejercicios resueltos pdf

La declaración de múltiples punteros a objetos en una línea causa un error de compilación

Question

cuando hago esto (en mi clase)

public:
    Entity()
    {
        re_sprite_eyes = new sf::Sprite();
        re_sprite_hair = new sf::Sprite();
        re_sprite_body = new sf::Sprite();
    }

private:
    sf::Sprite* re_sprite_hair;
    sf::Sprite* re_sprite_body;
    sf::Sprite* re_sprite_eyes;

Todo funciona bien. Sin embargo, si cambio las declaraciones a esto:

private:
    sf::Sprite* re_sprite_hair, re_sprite_body, re_sprite_eyes;

Me sale este error del compilador:

error: no match for ''operator='' in ''((Entity*)this)->Entity::re_sprite_eyes = (operator new(272u), (<statement>, ((sf::Sprite*)<anonymous>)))

Y luego dice que los candidatos para re_sprite_eyes son objetos y / o referencias sf::Sprite .

¿Por qué esto no funciona? ¿No son las declaraciones lo mismo?

Answer 1

Otra cosa que puede llamar su atención es la línea:

int * p1, * p2;

Esto declara los dos punteros utilizados en el ejemplo anterior. Pero observe que hay un asterisco ( * ) para cada puntero, para que ambos tengan el tipo int* (puntero a int). Esto es necesario debido a las reglas de precedencia. Tenga en cuenta que si, en cambio, el código era:

int * p1, p2;

p1 hecho sería del tipo int* , pero p2 sería del tipo int . Los espacios no importan en absoluto para este propósito. Pero de todos modos, simplemente recordar poner un asterisco por puntero es suficiente para la mayoría de los usuarios interesados ​​en declarar múltiples punteros por instrucción. O incluso mejor: use un parámetro diferente para cada variable.

Desde http://www.cplusplus.com/doc/tutorial/pointers/

Answer 2

El asterisco se enlaza al nombre de la variable de puntero. La forma de recordar esto es notar que en C / C ++, las declaraciones imitan el uso.

Los punteros se pueden utilizar de esta manera:

sf::Sprite *re_sprite_body;
// ...
sf::Sprite sprite_bod = *re_sprite_body;

Similar,

char *foo[3];
// ...
char fooch = *foo[1];

En ambos casos, hay un especificador de tipo subyacente, y el operador u operadores deben "llegar a" un objeto de ese tipo en una expresión.

Answer 3

En C ++ 11 tiene una pequeña solución, que podría ser mejor que desplazar espacios de un lado a otro:

template<typename T> using type=T;
template<typename T> using func=T*;

// I don''t like this style, but type<int*> i, j; works ok
type<int*> i = new int{3},
           j = new int{4};

// But this one, imho, is much more readable than int(*f)(int, int) = ...
func<int(int, int)> f = [](int x, int y){return x + y;},
                    g = [](int x, int y){return x - y;};

Answer 4

Tanto en C como en C ++, el * une al declarador , no al especificador de tipo. En ambos idiomas, las declaraciones se basan en los tipos de expresiones , no en objetos.

Por ejemplo, suponga que tiene un puntero a un int llamado p , y desea acceder al valor int que apunta p ; Para hacerlo, elimine la referencia al puntero con el operador unario * , así:

x = *p;

El tipo de expresión *p es int ; Así, la declaración de p es

int *p;

Esto es cierto sin importar cuántos punteros declare dentro de la misma declaración de declaración; si q y r también necesitan ser declarados como punteros, entonces también necesitan tener al unario * como parte del declarador:

int *p, *q, *r;

porque las expresiones *q y *r tienen tipo int . Es un accidente de la sintaxis de C y C ++ que puede escribir T *p , T* p , o T * p ; Todas esas declaraciones se interpretarán como T (*p) .

Por eso no me gusta el estilo C ++ de declarar punteros y tipos de referencia como

T* p;
T& r;

porque implica una visión incorrecta de cómo funciona la sintaxis de las declaraciones de C y C ++, lo que lleva al tipo exacto de confusión que acaba de experimentar. Sin embargo, he escrito suficiente C ++ para darme cuenta de que hay ocasiones en que ese estilo hace que la intención del código sea más clara, especialmente al definir tipos de contenedores.

Pero todavía está mal.

Answer 5

sf::Sprite* re_sprite_hair, re_sprite_body, re_sprite_eyes;

No declara 3 punteros, es un puntero y 2 objetos.

sf::Sprite* desafortunadamente no se aplica a todas las variables declaradas que lo siguen, solo la primera. Es equivalente a

sf::Sprite* re_sprite_hair;
sf::Sprite re_sprite_body;
sf::Sprite re_sprite_eyes;

Quieres hacer:

sf::Sprite *re_sprite_hair, *re_sprite_body, *re_sprite_eyes;

Necesitas poner una estrella para cada variable. En tales casos, prefiero mantener la estrella del lado de la variable, en lugar del tipo, para aclarar exactamente esta situación.