Desarrollo en programación C++

Manipuladores de flujo. Indicadores de formato

  • Enviado por: María Gabriela Rodríguez
  • Idioma: castellano
  • País: España España
  • 3 páginas
publicidad
publicidad

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++