Tipos de
datos:
Enteros:
Los valores
enteros (tipo de datos int) son aquellos números que se aprendieron a contar
(1, 4, -2, 1354);normalmente, tienen un tamaño de 16 bits, 2 bytes o una
palabra, con rango de -32768 a 32767. En Windows 98 yWindows NT, los valores
enteros tienen un tamaño de 32 bits con un rango de -2147483648 a 2147483647.
Flotantes:
Los valores
en coma flotante (tipo de dato float) son números que tienen una parte
fraccional, como por ejemplo pi(3,14159), y exponentes (7,5631021). También se
conocen como números reales (normalmente, son de 32 bits, 4 byteso 2 palabras,
con un rango de +/-3,4E-38 a 3,4E+38).
Las secuencias de caracteres en las
que el primero es la barra invertida, se denominaron secuencias de escape y aunque originariamente se
utilizaron para la representación de los caracteres de control, por extensión
pueden representarse de este modo todos los códigos ASCII. Además se dispone de
algunos símbolos predefinidos para los caracteres más frecuentes. Por ejemplo, \nse utiliza para representar el carácter nueva línea
(decimal 10). Los símbolos utilizados se muestran en la tabla adjunta.
Secuencia
Valor Símbolo Descripción
\a
0x07
BEL Sonido audible (bell)
\b
0x08 BS Retroceso
(backspace)
\f
0x0C FF Salto
de formato (formfeed)
\n
0x0A
LF Saltar una
línea (linefeed)
\r
0x0D
CR Retorno de
carro (carriage return)
\t
0x09 HT Tabulación
horizontal (H Tab)
\v
0x0B
VT Tabulación
vertical (V Tab)
\\
0x5c
\ Barra
invertida (backslash)
\'
0x27
'
Apóstrofo (comilla simple)
\"
0x22
"
Doble comilla
\?
0x3F
?
Interrogación
\O
cualquiera cualquiera O = cadena de hasta tres
dígitos octales
\xH
cualquiera cualquiera H = cadena de dígitos
hexadecimales
\XH
cualquiera cualquiera H = cadena de dígitos hexadecimales
Ejemplo
char campana = '\a'; // carácter ASCII 7
cout << campana << endl; // genera un sonido audible
La barra invertida ( \ ) se utiliza junto con números octales o hexadecimales para
representar símbolos ASCII , incluyendo los denominados caracteres de control (también llamados caracteres no
imprimibles) que no tienen representación directa en ningún carácter.
En una secuencia de escape se pueden utilizar hasta tres caracteres en
octal o cualquier número de caracteres en hexadecimal. Siempre que los valores
estén dentro del rango legal para el tipochar (de 0 a 0xff para C++Builder).
Operadores matemáticos
Los operadores
aritméticos se usan para
realizar cálculos de aritmética de números reales y de aritmética de punteros.
C++ dispone de los siguientes:
+ Dos posibilidades: Suma binaria; más unitario .
++ Incremento unitario (dos clases )
-
Dos posibilidades: Resta
binaria ; menos unitario .
-- Decremento unitario (dos clases )
* Multiplicación (este símbolo tiene también
otros usos )
/ División
% Resto o módulo
Nota: la aritmética de números reales es la clásica de
la escuela primaria. La de punteros es una aritmética un tanto especial y
rudimentaria .
Los operadores aritméticos pertenecen a dos grupos: unos aceptan
operandos de tipo numérico; otros aceptan operandos de tipo puntero-a-tipoX. Además
son de dos tipos; unarios (que aceptan un solo operando)
y binarios (que aceptan dos). La
clasificación es la siguiente:
Operadores aritméticos unarios:
+ más unitario.
++ Incremento unitario (dos clases)
- menos unitario.
-- Decremento unitario (dos clases)
Operadores artiméticos binaros:
+ Suma binaria.
- Resta binaria.
* Multiplicación
/ División.
% Resto o módulo.
Estos últimos pueden combinarse con el de asignación = para dar origen a operadores
compuestos son los siguientes:
+= Asigna suma
-= Asigna diferencia (resta)
*= Asigna producto
/= Asigna división
%= Asigna resto (módulo)
Siempre tenemos que tener en cuenta que existen distintos operadores enmascarados bajo los mismos
símbolos + y -. Es un caso de sobrecarga incluida en el
propio lenguaje. Como en el resto de los casos de sobrecarga, el compilador
deduce por el contexto de que versión del operador se trata. Como veremos
inmediatamente, en C++ es perfectamente válida una expresión del tipo:
int x = *ptr+-*++ptr;
En el ejemplo siguiente se muestran los casos posibles:
int ai[] = {2, 3};
int* ptr = ai;
int r1 = +ai[0]; // L.3:
más unitario sobre tipo numérico
int r2 = -ai[1] //
L.3: menos unitario sobre tipo numérico
int r3 = ai[0] + ai[1]; // L.4: 2 + 3 suma binaria (de enteros)
int r4 = ai[1] - ai[0] // L.5: 3 - 2 resta binaria (de
enteros)
int r5 = ai[0] + -ai[1]; // L.6: 2 +(-3) suma binaria seguida de menos
unitario
int r6 = *ptr + -*++ptr; // L.7: Suma binaria (de enteros) a + (-b)
Operadores
Relacionales
Se utilizan para establecer una relación entre
dos valores. Luego compara estos valores entre si y esta comparación produce un
resultado de certeza o falsedad (verdadero o falso).
Los operadores relacionales comparan valores
del mismo tipo (numéricos o cadenas). Estos tienen el mismo nivel de prioridad
en su evaluación.
Los operadores relaciónales tiene menor
prioridad que los aritméticos.
Tipos de operadores Relacionales
- >
Mayor que
- <
Menor que
- >
= Mayor o igual que
- <
= Menor o igual que
- <
> Diferente
- =
Igual
Ejemplos:
Si a = 10, b = 20, c = 30
a + b > c
|
Falso
|
|
a - b < c
|
Verdadero
|
|
a - b = c
|
Falso
|
|
a * b < > c
|
Verdadero
|
Ejemplos no lógicos:
a < b < c
10 < 20 < 30
T > 5 < 30
(no es lógico porque tiene diferentes
operandos)
Operadores
Lógicos
Estos operadores se utilizan para establecer
relaciones entre valores lógicos. Estos valores pueden ser resultado de una
expresión relacional.
Tipos de operadores Lógicos
And Y
Or O
Not Negación
Ejemplo:
Para los siguientes ejemplos T significa verdadero
y F falso.
Operador Not Operador Not
Operando
|
Resultado
|
|
T
|
F
|
|
F
|
T
|
Operador And Operador And
Operando1
|
Operador
|
Operando2
|
Resultado
|
|||
T
|
AND
|
T
|
T
|
|||
T
|
F
|
F
|
||||
F
|
T
|
F
|
||||
F
|
F
|
F
|
||||
Operador Or Operador Or
Operando1
|
Operador
|
Operando2
|
Resultado
|
|||
T
|
Or
|
T
|
T
|
|||
T
|
F
|
T
|
||||
F
|
T
|
T
|
||||
F
|
F
|
F
|
||||
Prioridad de los Operadores Lógicos
- Not
- And
- Or
Prioridad
de los Operadores en General
- ( )
- ^
- *,
/, Mod, Not
- +,
-, And
- >,
<, > =, < =, < >, =, Or
Ejemplos:
Sea: a = 10 b = 12 c = 13 d =10
Precedencia del operador y asociativa:
La interpretación de cualquier expresión en C++
está determinada por la precedencia y asociatividad de los operadores en dicha
expresión. Cada operador tiene una precedencia, y los operadores en una
expresión se evalúan en orden de mayor a menor precedencia. La evaluación de
operadores con la misma precedencia viene determinada por su asociatividad. Y, al
igual que en matemáticas, los paréntesis anulan las reglas de precedencia.
En la siguiente tabla se listan los operadores en C++, su precedencia y su asociatividad. Los operadores se listan en orden de prioridad decreciente (los situados más arriba tienen mayor prioridad). Los operadores en la misma línea horizontal tienen la misma precedencia.
En la siguiente tabla se listan los operadores en C++, su precedencia y su asociatividad. Los operadores se listan en orden de prioridad decreciente (los situados más arriba tienen mayor prioridad). Los operadores en la misma línea horizontal tienen la misma precedencia.
|
Operador
|
Propósito
|
Asociatividad
|
|
::
|
Scope
(unario)
|
De
derecha a izquierda
|
|
::
|
Scope
(binario)
|
De
izquierda a derecha
|
|
-> .
|
Selección
de miembros
|
De
izquierda a derecha
|
|
[]
|
Índices
|
De
izquierda a derecha
|
|
()
|
Llamada
a función
|
De
izquierda a derecha
|
|
++
|
Postincremento
|
De
izquierda a derecha
|
|
--
|
Postdecremento
|
De
izquierda a derecha
|
|
sizeof
|
Tamaño
de un objeto
|
De
derecha a izquierda
|
|
++
|
Preincremento
|
De
derecha a izquierda
|
|
--
|
Predecremento
|
De
derecha a izquierda
|
|
* &
+ - ! ~
|
Operadores
unarios
|
De
derecha a izquierda
|
|
new
|
Crea un
objeto
|
De
derecha a izquierda
|
|
delete
|
Borra
un objeto
|
De
derecha a izquierda
|
|
()
|
Conversión
de tipo (type cast)
|
De
derecha a izquierda
|
|
->*
.*
|
Puntero
a un miembro
|
De
izquierda a derecha
|
|
* / %
|
Operadores
multiplicativos
|
De
izquierda a derecha
|
|
+ -
|
Operadores
aditivos
|
De
izquierda a derecha
|
|
<<
>>
|
Operadores
bitwise
|
De
izquierda a derecha
|
|
<
> <= >=
|
Operadores
de relación
|
De
izquierda a derecha
|
|
== !=
|
Operadores
de igualdad
|
De
izquierda a derecha
|
|
&
|
Y
bitwise
|
De
izquierda a derecha
|
|
^
|
bitwise
O exclusivo
|
De
izquierda a derecha
|
|
|
|
bitwise
O inclusivo
|
De
izquierda a derecha
|
|
&&
|
Y
lógico
|
De
izquierda a derecha
|
|
||
|
O
lógico
|
De
izquierda a derecha
|
|
?:
|
Operador
condicional
|
De
derecha a izquierda
|
|
= *= /=
+= -= >*gt;=
&= ^= |= %= <<= |
Operadores
de asignación
|
De
derecha a izquierda
|
|
,
|
Operador
coma
|
De
derecha a izquierda
|
En C++ las reglas de precedencia y asociatividad de operadores
corresponden a las reglas matemáticas. Sin embargo, esto no funcionará, por
ejemplo, con los operadores bitwise. Para tales operadores, se debe utilizar la
tabla anterior, o bien paréntesis.
Manipuladores mas comunes
en c++
Los manipuladores sin argumentos son provistos en <iostream>. Esto
incluye dec, oct,y hex, que hacen las mismas acciones que,
respectivamente, setf(ios::dec, ios::basefield),setf(ios::oct,
ios::basefield), y setf(ios::hex,
ios::basefield), aunque más sucintamente. La cabecera
<iostream> también incluye ws, endl, y flush y el conjunto adicional
mostrado aquí:
Manipulador
Efecto
showbase noshowbase
Indica la base numérica (dec, oct, o hex) cuando imprimimos un entero.
showpos noshowpos
Muestra el signo más (+) para valores positivos.
uppercase nouppercase
Muestra mayúsculas A-F para valores hexadecimales, y muestra E para
valores científicos.
showpoint noshowpoint
Muestra punto decimal y ceros arrastrados para valores de coma flotante.
skipws noskipws
Escapa los espacios en blanco en la entrada.
left right internal
Alineación izquierda, relleno a la derecha. Alineación derecha, relleno
a la izquierda. Rellenar entre el signo o el indicador de base y el valor.
scientific fixed
Indica la preferencia al mostrar la salida para coma flotante (notación
científica versus coma flotante decimal).
5.9.1.
Manipuladores con argumentos
Existen seis manipuladores estándar, como setw(), que toman
argumentos. Están definidos en el fichero de cabecera <iomanip>, y están
enumerados en la siguiente tabla:
Manipulador
Efecto
setiosflags(fmtflags n)
Equivalente a una llamada a setf(n). La activación
continua hasta el siguiente cambio, comoios::setf().
resetiosflags(fmtflags n)
Limpia solo las banderas de formato especificadas por n. La activación permanece
hasta el siguiente cambio, como ios::unsetf().
setbase(base n)
Cambia la base a n, donde n es 10, 8 o 16. (Caulquier otra opción
resulta en 0). Si n es cero, la salida es base 10, pero la entrada usa
convenciones de C: 10 es 10, 010 es 8, y 0xf es 15. Puede usar también dec, oct
y hex para la salida.
setfill(char n)
Cambia el carácter de relleno a n, como ios::fill().
setprecision(int n)
Cambia la precision a n, como ios::precision().
setw(int n)
Cambia la anchura del campo a n, como en ios::width()
Si está usando mucho el formateo, usted puede ver como usar los
manipuladores en vez de llamar a funciones miembro de stream puede limpiar su
código. Como ejemplo, aquí tiene un programa de la sección previa reescrito
para usar los manipuladores. (La macro D() ha sido borrada para hacerlo más
fácil de leer).
//: C04:Manips.cpp
// Format.cpp using
manipulators.
#include <fstream>
#include <iomanip>
#include <iostream>
using namespace std;
int main() {
ofstream trc("trace.out");
int i = 47;
float f =
2300114.414159;
char* s = "Is
there any more?";
trc << setiosflags(ios::unitbuf
| ios::showbase | ios::uppercase
| ios::showpos);
trc << i << endl;
trc << hex << i << endl
<< oct << i << endl;
trc.setf(ios::left, ios::adjustfield);
trc << resetiosflags(ios::showbase)
<< dec << setfill('0');
trc << "fill
char: " << trc.fill() << endl;
trc << setw(10) << i <<
endl;
trc.setf(ios::right, ios::adjustfield);
trc << setw(10) << i <<
endl;
trc.setf(ios::internal, ios::adjustfield);
trc << setw(10) << i <<
endl;
trc << i << endl; // Without
setw(10)
trc << resetiosflags(ios::showpos)
<< setiosflags(ios::showpoint)
<< "prec =
" << trc.precision() << endl;
trc.setf(ios::scientific, ios::floatfield);
trc << f <<
resetiosflags(ios::uppercase) << endl;
trc.setf(ios::fixed, ios::floatfield);
trc << f << endl;
trc << f << endl;
trc << setprecision(20);
trc << "prec =
" << trc.precision() << endl;
trc << f << endl;
trc.setf(ios::scientific, ios::floatfield);
trc << f << endl;
trc.setf(ios::fixed, ios::floatfield);
trc << f << endl;
trc << f << endl;
trc << setw(10) << s <<
endl;
trc << setw(40) << s <<
endl;
trc.setf(ios::left, ios::adjustfield);
trc << setw(40) << s <<
endl;
} ///:~
Se puede ver que un montón de sentencias múltiples han sido condensadas
dentro de una sola inserción encadenada. En el ejemplo se puede notar que la llamada a setiosflags()
en que se pasa el OR binario de las banderas. Esto se podría haber hecho
también con setf() y unsetf() como en el
ejemplo previo.
//: C04:InputWidth.cpp
// Shows limitations of
setw with input.
#include <cassert>
#include <cmath>
#include <iomanip>
#include <limits>
#include <sstream>
#include <string>
using namespace std;
int main() {
istringstream is("one
2.34 five");
string temp;
is >> setw(2) >> temp;
assert(temp == "on");
is >> setw(2) >> temp;
assert(temp == "e");
double x;
is >> setw(2) >> x;
double relerr =
fabs(x - 2.34) / x;
assert(relerr <=
numeric_limits<double>::epsilon());
} ///:~
Problemas de la pagina 134:
Problema 4: Calcular el valor de la operaciones dadas y comparar el resultado arrojado por el problema:
calculado 15/4= 3.75
15%4=3
5*3-(6*4)=-9
Acontinuacion les dejo la imagen del programa con los resultados arrojados:
Originales
1.- Cout << “\n
<< “ 15)
2.- Cout <<
“setw(4)” << 33;
3.- Cout <<
“setprecision(5)” << 526.768;
4.- Hello world! ”
>> cout;
5.- Cout << 47
<< setw(6);
6.- Cout <<
set(10) << 526.768 << setprecision(2);
Errores Encontrados
1.- falta al final (;) quitarlo por el )
que se encuentra al final y mover el 15 al lado izquierdo y colocarle el endl.
cout << "\n 15"<<endl;
2.-No recorrió los espacios correspondientes
a setw(4) se necesita poner después del cout
<<””<< y encerrar del mismo modo el numero 33 y al final
<<””; para que corra de manera correcta:
cout<<""<<setw(4)<<33<<"";
3.- El error marcado es que nos despliega
lo que es el enunciado pero no hace su fincion para que funcione de manera
correta es poniendo después del cout << “”<< y enseguida setprecision(5)
seguido de <<#<< cerrando con “” se le pone \n para que no quede en
la misma liena que la primera
cout<<"\n\n"<<setprecision(5)<<526.768<<"";
4.- no se despliega el mensaje pues le hace
falta el cout al incio y aparte >> estos símbolos están del lado
contrario a como deberían y se tiene que poner \n por k si no se pone en la
misma línea que la primera
cout<<"\n\nhellow
worl"<<endl;
5.- No recorrio los espacios
correspondientes a setw(6) para que funciene se le puso << “\n”<<
al principio y al fin podremos ver los espacios si acomodamos el setw(6) seguido
del numero <<##<< cerrando
con<< “”;
- cout<<"\n"<<setw(6)<<47<<"";
6.- Le hace falta la w a set para que
rocorra los(10) ponemos <<“\n”<< se ke agrega al final<<”;
cout << "\n"<< setw(10)
<< 526.768 << setprecision(2)<<"";
Problema 6:
cout << "|" << 5
<<"|"; = ¦5¦
cout << "|" <<
setw(4) << 5 << "|";
= ¦ 5¦
cout << "|" <<
setw(4) << 56829 << "|"; =
¦56829¦
cout <<
"|" << setw(5) << setiosflags(ios::fixed) <<
setprecision(2) << 5.26 << "|"; =
¦ 5.26¦
cout <<
"|" << setw(5) << setiosflags(ios::fixed) <<
setprecision(2) << 5.267 << "|"; =
¦ 5.27¦
cout <<
"|" << setw(5) << setiosflags(ios::fixed) <<
setprecision(2) << 53.264 << "|"; =
¦53.26¦
cout <<
"|" << setw(5) << setiosflags(ios::fixed) <<
setprecision(2) << 534.264 << "|"; =
¦534.26¦
cout <<
"|" << setw(5) << setiosflags(ios::fixed) <<
setprecision(2) << 534. << "|"; =
¦534.00¦
Problema 7:
A.- cout << "El numero es "
<< setw(6) << setiosflags(ios::fixed) << setprecision(2)
<< 26.27 << endl;
cout << "El numero es "
<< setw(6) << setiosflags(ios::fixed) << setprecision(2)
<< 682.3 << endl;
cout << "El numero es "
<< setw(6) << setiosflags(ios::fixed) << setprecision(2)
<< 1.968 << endl;
El
número es 26.27
El
número es 682.30
El numero es
1.97
B.- cout <<
setw(6) << setiosflags(ios::fixed) << setprecision(2) <<
26.27 << endl;
cout << setw(6)
<< setiosflags(ios::fixed) << setprecision(2) << 682.3
<< endl;
cout << setw(6)
<< setiosflags(ios::fixed) << setprecision(2) << 1.968
<< endl;
cout <<
"------\n";
cout << setw(6)
<< setiosflags(ios::fixed) << setprecision(2) << 26.27 +
682.3 + 1.968 << endl;
26.27
682.30
1.97
------
710.54
C.- cout <<
setw(5) << setiosflags(ios::fixed) << setprecision(2) <<
26.27 << endl;
cout << setw(5)
<< setiosflags(ios::fixed) << setprecision(2) << 682.3
<< endl;
cout << setw(5)
<< setiosflags(ios::fixed) << setprecision(2) << 1.968
<< endl;
cout <<
"------\n";
cout << setw(5)
<< setiosflags(ios::fixed) << setprecision(2) << 26.27 +
682.3 + 1.968 << endl;
cout <<
"\n" << endl;
26.27
682.30
1.97
------
710.54
D.- cout <<
setw(5) << setiosflags(ios::fixed) << setprecision(2) <<
36.164 << endl;
cout << setw(5)
<< setiosflags(ios::fixed) << setprecision(2) << 10.003
<< endl;
cout << "-----" <<
endl;
36.16
10.00
-----
No hay comentarios:
Publicar un comentario