¿Qué hace "* ptrInt ++"?

Estoy implementando un contenedor de puntero de plantilla similar en functionaltiy al boost::shared_ptr.¿Qué hace "* ptrInt ++"?

Tengo un puntero a un número entero ptrInt.

Lo que quiero hacer: Incrementar los puntos ptrInt enteros a.

Mi código inicial fue la siguiente: *ptrInt ++;, aunque también probé el mismo usando (*ptrInt) ++;

Aparentemente, sin embargo, esto no parece hacer lo que yo esperaba. Al final he conseguido que funcione utilizando *ptrInt += 1;, sin embargo yo estoy preguntando a mí mismo:

¿Qué hace exactamente *ptrInt ++; hacer?
¿Existe una solución más elegante para usar *ptrInt += 1;?

Fuente

2011-07-02 Klitschko

¿Qué parece hacer? –

Estoy implementando un contenedor de puntero de plantilla ** PARE ** no lo haga. Incluso los mejores programadores de C++ se equivocan. Use las herramientas proporcionadas sin reinventar la rueda (habrá tiempo para eso más adelante). –

*p++ // Return value of object that p points to and then increment the pointer 
(*p)++ // As above, but increment the object afterwards, not the pointer 
*p += 1 // Add one to the object p points to

Los dos últimos incremento tanto del objeto, así que no estoy seguro de por qué no se cree que funcionó. Si la expresión se usa como un valor, la forma final devolverá el valor después de ser incrementada pero los otros devolverán el valor antes.

x = (*p)++; // original value in x 

(*p)++; 
x = *p;  // new value in X

x = ++*p; // increment object and store new value in x

Fuente

2011-07-02 20:32:34 DigitalRoss

@Caleb: la primera línea funciona más o menos como describe @DigitalRoss. El puntero se incrementa y el resultado de la operación es * el valor anterior * que luego se desreferencia. –

@Martinho, me sirve para no intentarlo primero. Gracias por la corrección. – Caleb

*ptr++ equivalente a *(ptr++)

Fuente

2011-07-02 20:32:58

-1

*ptrInt++ en su caso no incrementar el puntero, nada más (antes de que se obtiene el valor de la posición en la tira a la basura. De Por supuesto, si lo usa en una expresión más compleja, lo usará)

(*ptrInt)++ hace w que estás buscando

Fuente

2011-07-02 20:34:02

Nunca entendí por qué las personas votaron negativamente –

*ptrInt ++ se

incremento PtrInt por 1
eliminar la referencia de valor antiguo de PtrInt

y (*ptrInt) ++, así como *ptrInt += 1 va a hacer lo que quiera.

Ver Operator Precedence.

Fuente

2011-07-02 20:35:11 kilotaras

La expresión se evalúa utilizando las reglas para la precedencia del operador.

La versión postfix de ++ (aquella donde viene después de la variable ++) tiene una precedencia mayor que el operador * (indirección).

Es por eso que *ptr++ es equivalente a .

Fuente

2011-07-02 20:37:59 Andrei

Quiere (*ptrInt)++, que incrementa el objeto, que generalmente hace lo mismo que *ptrInt += 1. ¿Tal vez ha sobrecargado el operador +=, pero no los operadores ++ (operadores de incremento de prefijo y posfijo)?

Fuente

2011-07-02 20:38:08 Antti

La más manera elegante es lo que haya intentado antes. es decir, (*ptrInt) ++;

Dado que no está satisfecho con eso, puede deberse al incremento posterior.

Diga, std::cout<<(*ptrInt) ++; le habría mostrado el valor no incrementado.

Por lo tanto, pruebe dando ++(*ptrInt); que podría comportarse como esperaba.

Fuente

2011-07-02 20:40:11 liaK

(* ptr) ++ debería hacerlo, a menos que esté usando su valor de inmediato. Use ++ * ptr, que es equivalente a ++ (* ptr) debido a la asociatividad de derecha a izquierda.

En una nota al margen, here is my smart pointer implementation, quizás pueda ayudarlo a escribir el suyo.

Fuente

2011-07-03 08:27:40 Frigo

Respuesta

Cuestiones relacionadas