Taxonomía de categorías de expresión en C ++

Un cálculo es cualquier tipo de cálculo que sigue un algoritmo bien definido. Una expresión es una secuencia de operadores y operandos que especifica un cálculo. En otras palabras, una expresión es un identificador o un literal, o una secuencia de ambos, unidos por operadores.En programación, una expresión puede resultar en un valor y / o causar que suceda. Cuando da como resultado un valor, la expresión es glvalue, rvalue, lvalue, xvalue o prvalue. Cada una de estas categorías es un conjunto de expresiones. Cada conjunto tiene una definición y situaciones particulares donde prima su significado, diferenciándolo de otro conjunto. Cada conjunto se denomina categoría de valor.

Nota: Un valor o literal sigue siendo una expresión, por lo que estos términos clasifican expresiones y no valores realmente.

glvalue y rvalue son los dos subconjuntos de la expresión de gran conjunto. glvalue existe en dos subconjuntos más: lvalue y xvalue. rvalue, el otro subconjunto de expresión, también existe en dos subconjuntos más: xvalue y prvalue. Entonces, xvalue es un subconjunto de glvalue y rvalue: es decir, xvalue es la intersección de glvalue y rvalue. El siguiente diagrama de taxonomía, tomado de la especificación C ++, ilustra la relación de todos los conjuntos:

prvalue, xvalue y lvalue son los valores de categoría principal. glvalue es la unión de lvalues y xvalues, mientras que rvalues es la unión de xvalues y prvalues.

Necesita conocimientos básicos de C ++ para comprender este artículo; también necesita conocimientos de Scope en C++.

Contenido del artículo

Lo esencial
lvalor
valor
xvalue
Conjunto de taxonomía de categoría de expresión
Conclusión

Lo esencial

Para comprender realmente la taxonomía de la categoría de expresión, primero debe recordar o conocer las siguientes características básicas: ubicación y objeto, almacenamiento y recurso, inicialización, identificador y referencia, referencias de lvalue y rvalue, puntero, almacenamiento gratuito y reutilización de un recurso.

Ubicación y objeto

Considere la siguiente declaración:

int ident;

Esta es una declaración que identifica una ubicación en la memoria. Una ubicación es un conjunto particular de bytes consecutivos en la memoria. Una ubicación puede constar de un byte, dos bytes, cuatro bytes, sesenta y cuatro bytes, etc. La ubicación de un número entero para una máquina de 32 bits es cuatro bytes. Además, la ubicación se puede identificar mediante un identificador.

En la declaración anterior, la ubicación no tiene ningún contenido. Significa que no tiene ningún valor, ya que el contenido es el valor. Entonces, un identificador identifica una ubicación (pequeño espacio continuo). Cuando la ubicación recibe un contenido particular, el identificador identifica tanto la ubicación como el contenido; es decir, el identificador identifica tanto la ubicación como el valor.

Considere las siguientes declaraciones:

int ident1 = 5;
int ident2 = 100;

Cada una de estas declaraciones es una declaración y una definición. El primer identificador tiene el valor (contenido) 5 y el segundo identificador tiene el valor 100. En una máquina de 32 bits, cada una de estas ubicaciones tiene una longitud de cuatro bytes. El primer identificador identifica tanto una ubicación como un valor. El segundo identificador también identifica tanto.

Un objeto es una región de almacenamiento con nombre en la memoria. Entonces, un objeto es una ubicación sin un valor o una ubicación con un valor.

Almacenamiento de objetos y recursos

La ubicación de un objeto también se denomina almacenamiento o recurso del objeto.

Inicialización

Considere el siguiente segmento de código:

int ident;
ident = 8;

La primera línea declara un identificador. Esta declaración proporciona una ubicación (almacenamiento o recurso) para un objeto entero, identificándolo con el nombre, ident. La siguiente línea pone el valor 8 (en bits) en la ubicación identificada por ident. La puesta de este valor es inicialización.

La siguiente declaración define un vector con contenido, 1, 2, 3, 4, 5, identificado por vtr:

std :: vector vtr 1, 2, 3, 4, 5;

Aquí, la inicialización con 1, 2, 3, 4, 5 se realiza en la misma declaración de la definición (declaración). El operador de asignación no se utiliza. La siguiente declaración define una matriz con contenido 1, 2, 3, 4, 5:

int arr [] = 1, 2, 3, 4, 5;

Esta vez, se ha utilizado un operador de asignación para la inicialización.

Identificador y referencia

Considere el siguiente segmento de código:

int ident = 4;
int & ref1 = ident;
int & ref2 = ident;
cout<< ident <<"<< ref1 <<"<< ref2 << '\n';

La salida es:

4 4 4

ident es un identificador, mientras que ref1 y ref2 son referencias; hacen referencia a la misma ubicación. Una referencia es un sinónimo de un identificador. Convencionalmente, ref1 y ref2 son nombres diferentes de un objeto, mientras que ident es el identificador del mismo objeto. Sin embargo, ident todavía se puede llamar el nombre del objeto, lo que significa que ident, ref1 y ref2 nombran la misma ubicación.

La principal diferencia entre un identificador y una referencia es que, cuando se pasa como un argumento a una función, si se pasa por identificador, se realiza una copia del identificador en la función, mientras que si se pasa por referencia, se usa la misma ubicación dentro del función. Entonces, pasar por identificador termina con dos ubicaciones, mientras que pasar por referencia termina en la misma ubicación.

Referencia de lvalue y referencia de rvalue

La forma normal de crear una referencia es la siguiente:

int ident;
ident = 4;
int & ref = ident;

El almacenamiento (recurso) se ubica e identifica primero (con un nombre como ident), y luego se hace una referencia (con un nombre como ref). Al pasar como argumento a una función, se hará una copia del identificador en la función, mientras que para el caso de una referencia, se usará (se hará referencia) a la ubicación original en la función.

Hoy en día, es posible tener una referencia sin identificarla. Esto significa que es posible crear una referencia primero sin tener un identificador para la ubicación. Esto usa &&, como se muestra en la siguiente declaración:

int && ref = 4;

Aquí, no hay identificación precedente. Para acceder al valor del objeto, simplemente use ref como usaría la identificación de arriba.

Con la declaración &&, no hay posibilidad de pasar un argumento a una función por identificador. La única opción es pasar por referencia. En este caso, solo se usa una ubicación dentro de la función y no la segunda ubicación copiada como con un identificador.

Una declaración de referencia con & se llama referencia de valor l. Una declaración de referencia con && se llama rvalue reference, que también es una referencia prvalue (ver más abajo).

Puntero

Considere el siguiente código:

int ptdInt = 5;
int * ptrInt;
ptrInt = &ptdInt;
cout<< *ptrInt <<'\n';

La salida es 5.

Aquí, ptdInt es un identificador como el ident anterior. Hay dos objetos (ubicaciones) aquí en lugar de uno: el objeto puntiagudo, ptdInt identificado por ptdInt, y el objeto puntero, ptrInt identificado por ptrInt. & ptdInt devuelve la dirección del objeto puntiagudo y la pone como valor en el objeto puntero ptrInt. Para devolver (obtener) el valor del objeto puntiagudo, utilice el identificador del objeto puntero, como en "* ptrInt".

Nota: ptdInt es un identificador y no una referencia, mientras que el nombre, ref, mencionado anteriormente, es una referencia.

La segunda y tercera líneas del código anterior se pueden reducir a una línea, lo que lleva al siguiente código:

int ptdInt = 5;
int * ptrInt = &ptdInt;
cout<< *ptrInt <<'\n';

Nota: Cuando se incrementa un puntero, apunta a la siguiente ubicación, que no es una suma del valor 1. Cuando un puntero se reduce, apunta a la ubicación anterior, que no es una resta del valor 1.

Tienda gratis

Un sistema operativo asigna memoria para cada programa que se está ejecutando. Una memoria que no está asignada a ningún programa se conoce como la tienda gratuita. La expresión que devuelve una ubicación para un número entero de la tienda gratuita es:

nuevo int

Esto devuelve una ubicación para un número entero que no está identificado. El siguiente código ilustra cómo usar el puntero con la tienda gratuita:

int * ptrInt = nuevo int;
* ptrInt = 12;
cout<< *ptrInt <<'\n';

La salida es 12.

Para destruir el objeto, use la expresión de eliminación de la siguiente manera:

eliminar ptrInt;

El argumento de la expresión de eliminación es un puntero. El siguiente código ilustra su uso:

int * ptrInt = nuevo int;
* ptrInt = 12;
eliminar ptrInt;
cout<< *ptrInt <<'\n';

La salida es 0, y nada como nulo o indefinido. eliminar reemplaza el valor de la ubicación con el valor predeterminado del tipo particular de ubicación, luego permite la ubicación para su reutilización. El valor predeterminado para una ubicación int es 0.

Reutilizar un recurso

En la taxonomía de categorías de expresión, reutilizar un recurso es lo mismo que reutilizar una ubicación o almacenamiento para un objeto. El siguiente código ilustra cómo se puede reutilizar una ubicación de la tienda gratuita:

int * ptrInt = nuevo int;
* ptrInt = 12;
cout<< *ptrInt <<'\n';
eliminar ptrInt;
cout<< *ptrInt <<'\n';
* ptrInt = 24;
cout<< *ptrInt <<'\n';

La salida es:

12
0
24

Primero se asigna un valor de 12 a la ubicación no identificada. Luego, se elimina el contenido de la ubicación (en teoría, se elimina el objeto). El valor de 24 se reasigna a la misma ubicación.

El siguiente programa muestra cómo se reutiliza una referencia entera devuelta por una función:

#incluir
usando el espacio de nombres std;
int & fn ()

int i = 5;
int & j = i;
return j;

int main ()

int & myInt = fn ();
cout<< myInt <<'\n';
myInt = 17;
cout<< myInt <<'\n';
return 0;

La salida es:

5
17

Un objeto como i, declarado en un ámbito local (ámbito de función), deja de existir al final del ámbito local. Sin embargo, la función fn () anterior, devuelve la referencia de i. A través de esta referencia devuelta, el nombre, myInt en la función main (), reutiliza la ubicación identificada por i para el valor 17.

lvalor

Un lvalue es una expresión cuya evaluación determina la identidad de un objeto, campo de bits o función. La identidad es una identidad oficial como la identificación anterior, o un nombre de referencia de lvalue, un puntero o el nombre de una función. Considere el siguiente código que funciona:

int myInt = 512;
int & myRef = myInt;
int * ptr = &myInt;
int fn ()

++ptr; --ptr;
return myInt;

Aquí, myInt es un lvalue; myRef es una expresión de referencia lvalue; * ptr es una expresión lvalue porque su resultado es identificable con ptr; ++ ptr o -ptr es una expresión lvalue porque su resultado es identificable con el nuevo estado (dirección) de ptr, y fn es un lvalue (expresión).

Considere el siguiente segmento de código:

int a = 2, b = 8;
int c = a + 16 + b + 64;

En la segunda declaración, la ubicación de 'a' tiene 2 y es identificable por 'a', y también lo es un lvalue. La ubicación de b tiene 8 y es identificable por b, al igual que un lvalue. La ubicación de c tendrá la suma, y es identificable por c, al igual que un lvalue. En la segunda declaración, las expresiones o valores de 16 y 64 son valores r (ver más abajo).

Considere el siguiente segmento de código:

char seq [5];
seq [0] = 'l', seq [1] = 'o', seq [2] = 'v', seq [3] = 'e', seq [4] = '\ 0';
cout<< seq[2] <<'\n';

La salida es 'v';

seq es una matriz. La ubicación de 'v' o cualquier valor similar en la matriz se identifica mediante seq [i], donde i es un índice. Entonces, la expresión, seq [i], es una expresión de lvalue. seq, que es el identificador de toda la matriz, también es un lvalue.

valor

Un prvalue es una expresión cuya evaluación inicializa un objeto o un campo de bits o calcula el valor del operando de un operador, según lo especificado por el contexto en el que aparece.

En la declaración,

int myInt = 256;

256 es un prvalue (expresión prvalue) que inicializa el objeto identificado por myInt. Este objeto no está referenciado.

En la declaración,

int && ref = 4;

4 es un prvalue (expresión prvalue) que inicializa el objeto referenciado por ref. Este objeto no está identificado oficialmente. ref es un ejemplo de una expresión de referencia rvalue o expresión de referencia prvalue; es un nombre, pero no un identificador oficial.

Considere el siguiente segmento de código:

int ident;
ident = 6;
int & ref = ident;

6 es un prvalue que inicializa el objeto identificado por ident; el objeto también es referenciado por ref. Aquí, la ref es una referencia lvalue y no una referencia prvalue.

Considere el siguiente segmento de código:

int a = 2, b = 8;
int c = a + 15 + b + 63;

15 y 63 son cada uno una constante que se calcula a sí misma, produciendo un operando (en bits) para el operador de suma. Entonces, 15 o 63 es una expresión de valor.

Cualquier literal, excepto el literal de cadena, es un prvalue (i.mi., una expresión prvalue). Entonces, un literal como 58 o 58.53, o verdadero o falso, es un valor. Un literal se puede usar para inicializar un objeto o se computaría a sí mismo (en alguna otra forma en bits) como el valor de un operando para un operador. En el código anterior, el literal 2 inicializa el objeto, un. También se calcula a sí mismo como un operando para el operador de asignación.

¿Por qué una cadena literal no es un valor de valor?? Considere el siguiente código:

char str [] = "amar, no odiar";
cout << str <<'\n';
cout << str[5] <<'\n';

La salida es:

amar no odiar
norte

str identifica toda la cadena. Entonces, la expresión, str, y no lo que identifica, es un valor l. Cada carácter de la cadena se puede identificar mediante str [i], donde i es un índice. La expresión, str [5], y no el carácter que identifica, es un valor l. El literal de cadena es un valor l y no un valor pr.

En la siguiente declaración, un literal de matriz inicializa el objeto, arr:

ptrInt ++ o ptrInt--

Aquí, ptrInt es un puntero a una ubicación entera. La expresión completa, y no el valor final de la ubicación a la que apunta, es un prvalue (expresión). Esto se debe a que la expresión, ptrInt ++ o ptrInt-, identifica el primer valor original de su ubicación y no el segundo valor final de la misma ubicación. Por otro lado, -ptrInt o -ptrInt es un lvalue porque identifica el único valor del interés en la ubicación. Otra forma de verlo es que el valor original calcula el segundo valor final.

En la segunda declaración del siguiente código, aob todavía se pueden considerar como un valor pr:

int a = 2, b = 8;
int c = a + 15 + b + 63;

Entonces, aob en la segunda declaración es un lvalue porque identifica un objeto. También es un prvalue ya que calcula el número entero de un operando para el operador de suma.

(new int), y no la ubicación que establece es un prvalue. En la siguiente declaración, la dirección de retorno de la ubicación se asigna a un objeto puntero:

int * ptrInt = nuevo int

Aquí, * ptrInt es un lvalue, mientras que (new int) es un prvalue. Recuerde, un lvalue o un prvalue es una expresión. (new int) no identifica ningún objeto. Devolver la dirección no significa identificar el objeto con un nombre (como ident, arriba). En * ptrInt, el nombre, ptrInt, es lo que realmente identifica al objeto, por lo que * ptrInt es un lvalue. Por otro lado, (new int) es un prvalue, ya que calcula una nueva ubicación a una dirección de valor de operando para el operador de asignación =.

xvalue

Hoy, lvalue son las siglas de Location Value; prvalue significa rvalue "puro" (vea lo que rvalue significa a continuación). Hoy, xvalue significa "eXpiring" lvalue.

La definición de xvalue, citada de la especificación C ++, es la siguiente:

“Un xvalue es un glvalue que denota un objeto o campo de bits cuyos recursos se pueden reutilizar (generalmente porque está cerca del final de su vida útil). [Ejemplo: Ciertos tipos de expresiones que involucran referencias de rvalue producen xvalues, como una llamada a una función cuyo tipo de retorno es una referencia de rvalue o una conversión a un ejemplo de fin de tipo de referencia de rvalue] "

Lo que esto significa es que tanto lvalue como prvalue pueden expirar. El siguiente código (copiado de arriba) muestra cómo el almacenamiento (recurso) de lvalue, * ptrInt se reutiliza después de haber sido eliminado.

int * ptrInt = nuevo int;
* ptrInt = 12;
cout<< *ptrInt <<'\n';
eliminar ptrInt;
cout<< *ptrInt <<'\n';
* ptrInt = 24;
cout<< *ptrInt <<'\n';

La salida es:

12
0
24

El siguiente programa (copiado de arriba) muestra cómo el almacenamiento de una referencia entera, que es una referencia lvalue devuelta por una función, se reutiliza en la función main ():

#incluir
usando el espacio de nombres std;
int & fn ()

int i = 5;
int & j = i;
return j;

int main ()

int & myInt = fn ();
cout<< myInt <<'\n';
myInt = 17;
cout<< myInt <<'\n';
return 0;

La salida es:

5
17

Cuando un objeto como i en la función fn () sale del alcance, naturalmente se destruye. En este caso, el almacenamiento de i todavía se ha reutilizado en la función main ().

Los dos ejemplos de código anteriores ilustran la reutilización del almacenamiento de lvalues. Es posible tener una reutilización de almacenamiento de prvalues (rvalues) (ver más adelante).

La siguiente cita sobre xvalue es de la especificación C ++:

“En general, el efecto de esta regla es que las referencias de valor r con nombre se tratan como valores l y las referencias de valor r sin nombre a objetos se tratan como valores x. Las referencias de rvalue a funciones se tratan como lvalues ya sea que tengan nombre o no." (nos vemos).

Entonces, un xvalue es un lvalue o un prvalue cuyos recursos (almacenamiento) se pueden reutilizar. xvalues es el conjunto de intersección de lvalues y prvalues.

Hay más en xvalue de lo que se ha tratado en este artículo. Sin embargo, xvalue merece un artículo completo por sí solo, por lo que las especificaciones adicionales para xvalue no se tratan en este artículo.

Conjunto de taxonomía de categoría de expresión

Otra cita de la especificación C ++:

"Nota: Históricamente, lvalues y rvalues se denominaban así porque podían aparecer en el lado izquierdo y derecho de una asignación (aunque esto ya no es cierto en general); Los valores gl son valores l "generalizados", los valores pr son valores r "puros" y los valores x son valores l "eXpiring". A pesar de sus nombres, estos términos clasifican expresiones, no valores. - nota final "

Entonces, glvalues es el conjunto de unión de lvalues y xvalues y rvalues son el conjunto de unión de xvalues y prvalues. xvalues es el conjunto de intersección de lvalues y prvalues.

A partir de ahora, la taxonomía de la categoría de expresión se ilustra mejor con un diagrama de Venn de la siguiente manera:

Conclusión

Un lvalue es una expresión cuya evaluación determina la identidad de un objeto, campo de bits o función.

Un prvalue es una expresión cuya evaluación inicializa un objeto o un campo de bits o calcula el valor del operando de un operador, según lo especificado por el contexto en el que aparece.

Un xvalue es un lvalue o prvalue, con la propiedad adicional de que sus recursos (almacenamiento) se pueden reutilizar.

La especificación C ++ ilustra la taxonomía de categorías de expresión con un diagrama de árbol, lo que indica que hay alguna jerarquía en la taxonomía. A partir de ahora, no hay jerarquía en la taxonomía, por lo que algunos autores utilizan un diagrama de Venn, ya que ilustra la taxonomía mejor que el diagrama de árbol.