Informática
Desarrollo en programación C++
RESUMEN DE OPERADORES
| Símbolo | Significado | Uso |
| :: | determinación de alcance | nombre_de_objeto::miembro |
|
:: | global | ::nombre |
| . | selección de miembro | objeto.miembro |
| -> | selección de miembro | puntero->miembro |
| [] | subíndice | puntero [] |
| () | llamada a función | expr(lista_expr) |
| () | construcción de valor | tipo (lista_expr) |
| sizeof | tamaño de objeto | sizeof expr |
| sizeof | tamaño de tipo | sizeof ( ipo) |
| ++ | post incremento | valor-i++ |
| ++ | pre incremento | ++ valor-i |
| -- | post decremento | valor-i-- |
| -- | pre decremento | -- valor-i |
| ~ | complemento | ~expr |
| ! | negación | !expr |
| - | menos unario | -expr |
| + | más unario | +expr |
| & | dirección de | &valor-i |
| * | indirección de | |
| new | crear(repartir) | new tipo |
| delete | destruir(liberar) | delete puntero |
| delete[] | destruir arreglo | delete[] puntero |
| () | conversión de tipo | (tipo) expr |
RESUMEN DE OPERADORES
| Símbolo | Significado | Uso |
| .* | sección miembro | objeto.puntero_a_ miembro |
| ->* | sección miembro | puntero->puntero_a_ miembro |
| * | multiplicar | expr*expr |
| / | dividir | expr/expr |
| % | residuo | expr%expr |
| + | sumar | expr+expr |
| - | restar | expr-expr |
| << | desplazamiento izquierda | expr<<expr |
| >> | desplazamiento derecha | expr>>expr |
| < | menor que | expr<expr |
| <= | menor igual que | expr<=expr |
| > | mayor que | expr>expr |
| >= | mayor igual que | expr>=expr |
| == | igual a | expr==expr |
| != | diferente de | expr!=expr |
| & | AND bit por bit | expr&expr |
| ^ | OR exclusivo bit por bit | expr^expr |
| | | OR inclusivo bit por bit | expr|expr |
| && | AND lógico | expr&&expr |
| || | OR inclusivo lógico | expr || expr |
| ?: | expresión condicional | expr?expr:expr |
RESUMEN DE OPERADORES
| Símbolo | Significado | Uso |
| = | asignación simple | valor-i=expr |
| *= | multiplicar y asignar | valor-i*=expr |
| /= | dividir y asignar | valor-i /=expr |
| %= | sacar residuo y asignar | valor-i %=expr |
| += | sumar y asignar | valor-i +=expr |
| -= | restar y asignar | valor-i -=expr |
| <<= | desplazar izq. y asignar | valor-i<<=expr |
| >> | desplazar der. y asignar | valor-i>>=expr |
| &= | AND y asignar | valor-i &=expr |
| |= | OR inclusivo y asignar | valor-i |=expr |
| ^= | OR exclusivo y asignar | valor_i ^=expr |
| , | coma(secuencia) | expr, expr, expr |
En las tablas anteriores todo lo que se encuentra en un cuadro tiene el mismo orden de precedencia, los operadores que están en el primer cuadro tienen un orden de precedencia mayor que el del segundo, y así sucesivamente.
Paréntesis
Los paréntesis se usan para :
-
encerrar los argumentos de llamada a funciones
-
para encerrar el tipo en una conversión de tipo
-
para indicar una función en los nombres de tipos
-
para resolver conflictos de precedencia
Operadores lógicos bit por bit
Los operadores lógicos por bits :
& | ^ ~ >> <<
se aplican a enteros (objetos char, long, int, short, unsigned) y los resultados que produce también son enteros
En C++ es frecuente que encontremos vectores de bits implementado como un conjunto cada bit es un entero sin signo que representa un miembro del conjunto, el número de bits limita el número de miembros
El operador binario & se interpetra como intersección
El operador binario | se interpetra como unión
El operador binario ^ se interpetra como diferencia
class ios {
public:
enum io_state{goodbit=0, eofbit=1, failbit=2, badbit=4};
…
};
El estado de un flujo se puede declarar :
cout.state = ios::goodbit; // el prefijo ios:: es necesario para
// evitar confusión de nombres
Es posible determinar si el flujo esta corrompido o una operación ha fallado:
if (cout.state&(ios::badbit|ios::failbit))
Se podría determinar la diferencia entre el estado de dos flujos :
ios::io_state diff = cin.state^cout.state;
Almacenamiento disponible
new: crea objetos a partir de la memoria disponible
delete: destruye los objetos creados con new
Se emplean para construir árboles o listas vinculadas cuyos tamaños no se conocen en el momento de compilación
struct enodo {
valor_compte_léxico oper;
enodo* izq;
enodo* der;
};
enodo* expr()
{
enodo* izq = termino();
for(;;)
switch(compte_actual) {
case MAS:
case MENOS:
obtener_compte_léxico();
enod *n = new nodo;
n->oper = compte_actual;
n->izq = izq;
n->der = término();
izq = n;
break;
default:
return izq;
}
}
Un objeto creado con new existe hasta que delete lo destruye
char* guardar_cadena(const char* p)
{ char* s = new char[strlen(p)+1];
strcpy(s,p);
return s; }
int main(int argc, char* argv[])
{ if(argc < 2) exit(1);
char* p= gurdar_cadena(arg[1]);
delete[] p; // delete[] se emplea para eliminar arreglos}
RESUMEN DE ENUNCIADOS
| enunciado: declaración {lista_de_enunciados} expresiónopc; |
| if (expresión) enunciado if (expresión) enunciado else enunciado switch (expresión) enunciado do enunciado while (expresión) ; for(enunciado-inic-for expresiónopc; expresiónopc) enunciado |
| case expresión-constante : enunciado default : enunciado break; continue; return expresiónopc; goto identificador identificador : enunciado |
| lista de enunciados: enunciado lista-de-enunciados enunciado |
| enunciado-inic-for: declaración expresiónopc ; |
expresión : secuencia de operadores y operandos que especifican un cálculo
valor-i : expresión que se refiere a un objeto (variable, puntero, objeto de clase, etc.) o función
enunciados :
-
rotulado
-
de expresión
-
compuesto o de bloque
-
de selección
-
de iteración
-
de salto
-
de declaración
Una declaración es un enunciado
La asignación y llamada de funciones se manejan como expresiones
Enunciados de selección
if (expresión) enunciado
if (expresión) enunciado else enunciado
switch (expresión) enunciado
Los operadores de comparación : ==, !=, <, <=, >, >=
devuelven : 1 si VERDADERO, 0 si FALSO
Los operadores lógicos : && y || no evaluarán su segundo argumento a menos que sea necesario
En algunos casos es conveniente reemplazar enunciados simples por condicionales aritméticos :
if (a<=b)
max=b; max = (a<b) ? b : a;
else
max=a;
también se puede reemplazar enunciados switch por if
switch (val) {
case 1: if(val == 1)
f(); f();
break; else if(val == 2)
case 2: g();
g(); else
break; h();
default:
h();
break;
}
Enunciados de iteración
while (expresión) enunciado;
do enunciado while (expresión);
for(enunciado-inic-for expresiónopc; expresiónopc)enunciado;
enunciado-inic-for:
enunciado de expresión
enunciado de declaración
En el enunciado while el subenunciado se ejecuta repetidamente hasta que el valor de la expresión se convierte en cero. La prueba se verifica antes cada ejecución del subenunciado
En el enunciado do el subenunciado se ejecuta repetidamente hasta que el valor de la expresión se convierte en cero. La prueba tiene lugar después de cada ejecución del subenunciado.
El enunciado for es equivalente a :
enunciado-inic-for
while (expresión-1) {
enunciado
expresión-2;
}
-
el primer enunciado especifica la iniciación del ciclo
-
la primera expresión especifica una prueba
-
la segunda expresión a menudo especifica un incremento que se efectúa después de cada iteración
-
cualquiera de las expresiones o las dos se pueden omitir
-
si falta la expresión-1 la cláusula while implícita será equivalente a while(1)
-
si el enunciado-inic-for es una declaración, el alcance de los nombres llegan hasta el fin del bloque
Universidad Tecnológica Nacional - Santa Fe - Departamento Sistemas -
Curso : Desarrollos de Programación en C++
Descargar
| Enviado por: | María Gabriela Rodríguez |
| Idioma: | castellano |
| País: | España |
Todos los derechos reservados.