Buscar..
Introducción
Tradicionalmente, un literal es una expresión que denota una constante cuyo tipo y valor son evidentes a partir de su ortografía. Por ejemplo, 42 es un literal, mientras que x no lo es, ya que uno debe ver su declaración para conocer su tipo y leer las líneas de código anteriores para conocer su valor.
Sin embargo, C ++ 11 también agregó literales definidos por el usuario , que no son literales en el sentido tradicional, pero se pueden usar como una abreviatura para llamadas a funciones.
cierto
Una palabra clave que denota uno de los dos valores posibles de tipo bool .
bool ok = true;
if (!f()) {
ok = false;
goto end;
}
falso
Una palabra clave que denota uno de los dos valores posibles de tipo bool .
bool ok = true;
if (!f()) {
ok = false;
goto end;
}
nullptr
Una palabra clave que denota una constante de puntero nula. Se puede convertir a cualquier tipo de puntero o puntero a miembro, produciendo un puntero nulo del tipo resultante.
Widget* p = new Widget();
delete p;
p = nullptr; // set the pointer to null after deletion
Tenga en cuenta que nullptr no es en sí mismo un puntero. El tipo de nullptr es un tipo fundamental conocido como std::nullptr_t .
void f(int* p);
template <class T>
void g(T* p);
void h(std::nullptr_t p);
int main() {
f(nullptr); // ok
g(nullptr); // error
h(nullptr); // ok
}
esta
Dentro de una función miembro de una clase, la palabra clave de this es un puntero a la instancia de la clase en la que se llama a la función. this no se puede utilizar en una función miembro estática.
struct S {
int x;
S& operator=(const S& other) {
x = other.x;
// return a reference to the object being assigned to
return *this;
}
};
El tipo de this depende de la calificación cv de la función miembro: si X::f es const , entonces el tipo de this dentro de f es const X* , por this que no se puede usar para modificar miembros de datos no estáticos desde dentro Función miembro const . Del mismo modo, this hereda la calificación volatile de la función en la que aparece.
this también se puede usar en un inicializador de paréntesis o igual para un miembro de datos no estáticos.
struct S;
struct T {
T(const S* s);
// ...
};
struct S {
// ...
T t{this};
};
this es un valor, por lo que no se puede asignar a.
Literal entero
Un literal entero es una expresión primaria de la forma
- decimal-literal
Es un dígito decimal distinto de cero (1, 2, 3, 4, 5, 6, 7, 8, 9), seguido de cero o más dígitos decimales (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
int d = 42;
- octal-literal
Es el dígito cero (0) seguido de cero o más dígitos octales (0, 1, 2, 3, 4, 5, 6, 7)
int o = 052
- hex-literal
Es la secuencia de caracteres 0x o la secuencia de caracteres 0X seguida de uno o más dígitos hexadecimales (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, A, b, B, c, C , d, D, e, E, f, F)
int x = 0x2a; int X = 0X2A;
- literal binario (desde C ++ 14)
Es la secuencia de caracteres 0b o la secuencia de caracteres 0B seguida de uno o más dígitos binarios (0, 1)
int b = 0b101010; // C++14
El sufijo entero, si se proporciona, puede contener uno o ambos de los siguientes (si se proporcionan ambos, pueden aparecer en cualquier orden:
- sufijo sin signo (el carácter u o el carácter U)
unsigned int u_1 = 42u;
- sufijo largo (el carácter l o el carácter L) o el sufijo largo-largo (la secuencia de caracteres ll o la secuencia de caracteres LL) (desde C ++ 11)
Las siguientes variables también se inicializan al mismo valor:
unsigned long long l1 = 18446744073709550592ull; // C++11
unsigned long long l2 = 18'446'744'073'709'550'592llu; // C++14
unsigned long long l3 = 1844'6744'0737'0955'0592uLL; // C++14
unsigned long long l4 = 184467'440737'0'95505'92LLU; // C++14
Notas
Las letras en los literales enteros no distinguen entre mayúsculas y minúsculas: 0xDeAdBaBeU y 0XdeadBABEu representan el mismo número (una excepción es el sufijo long-long, que es ll o LL, nunca lL o Ll)
No hay literales enteros negativos. Expresiones como -1 aplican el operador menos unario al valor representado por el literal, que puede implicar conversiones de tipo implícitas.
En C antes de C99 (pero no en C ++), se permite que los valores decimales sin sufijo que no caben en long int tengan el tipo unsigned long int.
Cuando se usa en una expresión de control de #if o #elif, todas las constantes enteras con signo actúan como si tuvieran el tipo std :: intmax_t y todas las constantes enteras sin signo actúen como si tuvieran el tipo std :: uintmax_t.