PRIMERA CLASE DE C

PRIMERA CLASE DE C
#include <stdio.h>
int main() {
printf("hola mundo\n");
return 0;
}
**********************************************************************
Colocar un ejemplo sencillo en C que involucre todo. Estilo pseudocodigo
Directivas del preprocesador (Por ahora)
Todas las directivas del preprocesador comienzan por el signo # y no terminan en punto
y coma (;) ya que no son instrucciones de lenguaje C.
#include: Indica al preprocesador que lea el archivo fuente (archivo cabecera o de
incusion) que viene a continuacion de ella y su contenido lo inserte en la posicion
donde se encuentra dicha directiva. Forma:
#include <nombreArch.h> o #include "nombreArch.h"
#define: Indica al preprocesador que defina un item de datos u operacion para el
programa C: #define PI 3.14
Declaraciones globales:
Indica al usuario que las constantes o variables declaradasson comunes a todas las
funciones de su probrama, se situan antes de la funcion main. La zona de
declararaciones globales puede incluir declaraciones de variables ademas de
declaraciones de prototipos de funcion.
**********************************************************************
Elementos de un programa en C:
- Identificadores: Nombres que se le dan a las constantes o variables (letras,
digitos,underscores), el primer caracter debe ser una letra, no puede tener el mismo
nombre de las palabras recervadas.
- Palabras reservadas: Caracteristica del lenguaje C asociada a algun significado en
especial.(void, asm).
- Comentarios: Sirven para documentar el compilador los ignora.
// Una linea.
/*
Varias
lineas
*/
- Signos de puntuacion y separadores: Todas las sentencias en C deben terminar con
punto y coma (;). Los separadores son espacios en blanco, tabulaciones, retornos de
carro y avances de linea.
Los signos de puntuacion son: !, %, ...
Tipos de datos en C.
Los tres tipos de datos basicos son: enteros, numeros de coma flotante (reales) y
caracteres.
Tipo
char
short
int
unsigned int
long
float
double
long double
Ejemplo
'c'
-15
1024
42325
262144
10.5
0.0045
1e-8
Tamaño en bytes
1
2
2
2
4
4
8
8
Rango (minimo-maximo)
0,...,255
-128,...,127
-32768,...,32767
0,...,65535
-2147483628,...,2147483637
3.4E-38,...,3.4E38
1.7E-308,...,1.7E308
igual que el double.
Declaracion de variables
<tipo_de_dato> <nom_var1>, <nom_var2>,... <nom_varN>
***********************************************************************************
Tipos de datos enteros
Entero (int)
C
-
permite escribir constantes enteras en difentes bases:
decimal: 16
hexadecimal: 0xA (Anteponer 0x al numero en hexadecimal)
octal: 020 (Anteponer un signo menos al principio)
Exiten tres tipos básicos de enteros:
Tipo C
int
unsigned int
short int
Rango
-32768,...,32767
0,...,65535
-32768,...,32767
Uso
Aritmetica de enteros, bucles for, conteo.
Conteo, bucles for, indices.
Aritmetica de enteros, bucles for, conteo.
Tipos de datos enteros largos.
long
unsigned long
-2147483628,...,2147483637
0,...,4294967295
************************************************************************************
Coma flotante (reales)
Tipo C
float
double
long double
Rango de valores
3.4E-38,...,3.4E38
1.7E-308,...,1.7E308
3.4E-4932,...,1.1E4932
Precision
7 digitos
15 digitos
19 digitos
************************************************************************************
Caracteres (char)
char car = 'b' // Ascii 98
car = car - 32 // Da ya 66 ('B')
************************************************************************************
Tipos de datos logicos
Los compiladores en C no incorporan el tipo de dato logico. C usa el tipo int para
simular el tipo logico interprestando todo valor diferente de cero como verdadero
y el valor de 0 como falso.
************************************************************************************
Constantes
Es un objeto cuyo valor no puede cambiar a lo largo de la ejecucion del programa.
Tipos:
Constantes literales: se clasifican en 4 grupos, asi
- Constantes enteras, sucesion de digitos precedidas o no por el signo - o +.
- Constantes reales. 82.349, .63, 47e-3, 4.5e+12
- Constantes caracter: 'A','a','1'
- Constantes cadena: "Hola mundo".
- Constantes definidas (simbolicas). Las constantes pueden recibir nombre simbolicos
a traves de la directiva #define.
#define nuevaLinea '\n'
#define PI 3.1415929
- Constantes numeradas: Permite la creacion de listas de elementos afines.
enum dias {lunes, martes,miercoles,jueves,viernes,sabado, domingo}; Empieza en 0
Una vez creado un tipo de datos numerado se pueden declarar variables de ese tipo,
como cualquier otro tipo de datos.
*************************************************************************************
Constantes declearaso como const y volatile.
const: permite dar nombres simbolicos a constantes: tipo nombre = valor;
volatile: Actua como const , pero su valor puede ser modificado no solo por el propio
programa, tambien por el hardware o software del sistema.
***************************************************************************************
Declaracion de variables
tipo nombre;
tipo nombre = valor;
***************************************************************************************
Entradas y salidas
Para poder usar funciones de entrada y salida se debe incluir la cabecera stdio.h
Salida
Con la funcion printf() se visualiza en pantalla los datos del programa, transforma los
datos que estan en representacion binaria a codigos ascii asociados, tiene el siguiente
formato general.
printf(cadena_de_control,dato1,dato2,...)
cadena de control: Contiene los tipos de datos y la forma de mostrarlos.
dato1,dato2: Variables, constantes, o en general expresiones de salida.
Codigos de formato mas usados y su significado.
%d
El dato se convierte a entero decimal.
%o
El dato se convierte a entero octal
%x
El dato se convierte a hexadecimal
%u
El dato entero se convierte a entero sin signo
%c
El dato se considera de tipo caracter.
%e
El dato se considera tipo float o double se convierte a notacion cientifica.
%f
El dato se considera tipo float o double se convierte a notacion decimal.
%g
El dato se considera tipo float o double se convierte al codigo %e o %f
depenciendo de la representacion mas corta
%s
El dato ha de ser una cadena de caracteres
[...]
El item de datos es un string que contiene espacios en blanco.
Entrada: La funcion mas utilizada para la entrada de datos es scanf.
scanf(cadena_de_control, va1,var2,...,varN)
cadena_de_control: Contiene los tipos de datos y si se desea su anchura
var1, var2: Variables del tipo de los codigos de control.
printf y scanf son funciones mas generales hay funciones mas especificas asociadas solo
a cadenas de caracteres.
Salida de cadenas de caracteres: Para salida la biblioteca especifica la funcion
puts(), tiene
un solo argumento que es la cadena de caracteres que se desea que salga en pantalla.
Incluye el retorno de carro al final
Entrada de cadena de caracteres: Para entrada desde entrada estandar se usa la funcion
gets(). Asi gets(variable_cadena)
Algunos ejemplos:
cadena="Esto es una cadena";
puts(cadena);
puts(&cadena[8]);
---------char pax[] = "Juan sin miedo"
printf(%s %s\n,pax,&pax[4]);
---------Imprimir la siguiente secuencia
***
*
*
*
*
*****
*
*
*
*
*
*
---------float v1,v2;
printf("Introduzca v1 y v2");
scanf("%d %f",&v1,v2);
Mas sobre la entrada y salida.
* Entrada de un unico caracter.
Para esto se usa la funcion getchar().
Sintaxis: char variable = getchar()
Asi:
char z;
z = getchar();
// Por ejemplo si meto a por teclado z queda con el valo z='a'
Si un end of file (EOD) es encontrado con la funcion getchar entonces el valor de la
constante
simbolica EOF sera devolvido. Esta en stdio.h y vale -1 tipicamente.
Por ejemplo:
char z;
while (z=getchar())!=EOF) {
printf("Todavia no me salgo");
}
* Salida de un unico caracter.
Sintaxis:
putchar(nombre_caracter)
char c='5';
putchar(c);
* Entrando datos de entrada. (scanf)
Ojo recordar que cada nombre de variable debe estar precedido por &.
***************************************************************************************
Operadores y expresiones
Existen varios tipos de operadores:
- Aritméticos, lógicos y relacionales.
- De manipulación de bits.
- Condicionales.
- Especiales.
Cuando concurren en una misma expresion diferentes tipos de operadores se dan las
reglas de prioridad y asociatividad.
Expresion: Sucecion de operadores y operandos debidamente relacionados.
--------------------------------------------------------------------------------------Operador de asignacion (=)
variable = expresion.
Es posible inicializar varias variables con una sola sentencia: a = b = c = 10
Hay cinco operadores de asinacion adicionales proporsionados por c (abreviados)
*=
/=
%=
+=
-=
Ejemplo: a*=b ----> a = a*b;
-----------------------------------------------------------------------------------------Operadores aritmeticos
+, -, *, =, % (En la division si es en entera da el cociente, y el resto da el residuo)
Prioridad
Prioridad (mayor a menor)
+, - (unitario)
*,/,%
+,-
Asociatividad
---> (i-d)
---> (i-d)
---> (i-d)
Hacer el ejemplo de la pagina 38 (7*10-5%3+9)
Operadores de incrementacion y decrementacion (++ y --)
Si se usan como prefijo (predecremento o preincremento): --n, ++n
Si se usan como sufijo (postdecremento o post incremento): n--, n++
n-=1
---- n = n - 1
n=6
m = n++; // m=6 y n quedo en 7, pero se hace primero la asignacion
m = ++n; // m=8 ya que n estaba en 7 y se incremeto primero y luego se asigno.
z= ++n + 4*n++ - 3; // ? Cual sera la salida
--------------------------------------------------------------------------------------Operadores relacionales:
Recordar: C no tiene datos de tipo logico. En lugar de esto lo que hace es usar los
tipos entero asociando
al 0 el falso y a los valores difernetes de 0 el valor de verdadero.
Uso de operadores relacionales: <,>,...
expresion_1 operador_relacional expresion_2
Operadores relacionales
==
Igual a
!=
Diferente a
>
Mayor que
<
Mayor o igual que
>=
Menor que
<=
Mayor o igual que
--------------------------------------------------------------------------------------Operadores logicos
Se utilizan con expresiones para devolver un valor verdadero o falso.
not !
and &&
or ||
prioridad
(1)
(2)
(3)
La asociatividad va de izquierda a derecha.
Evaluacion cortocicuito.
--------------------------------------------------------------------------------------Operadores de manipulacion de bits.
Los operadores de manipulacion o tratamiento se bits (bitwise) ejecutan operaciones
logicas sobre
cada uno de los bits de los operandos. Cada operador de manipulacion de bits realiza
una operacion
logica bit a bit sobre los datos internos. Los operadores de manipulacion de bits solo
se aplican a
variables o constantes char, int y long. y no a datos de coma flotante.
&
|
^ xor
~ complemento a 1 (negacion)
<< Desplazamiento de bits a la izquierda (uso: valor << numero_bits_: n << 1)
>> Desplazamiento de bita a la derecha. (uso: valor >> numero_bits_: n >> 3)
Mas operadores de asignacion (esta vez usando los operadores de manipulacion de bits)
<<=
a<<=b
Desplaza a a la izquierda b bits y asigna el resultado a a.
>>=
a>>=b
&=
a&=b
|=
a|=b
^=
a^=b
--------------------------------------------------------------------------------------Operadores de direcciones.
Permiten manipular las direcciones de las variables y objetos en general.
Operador
*
corresponde como
&
ser
Accion
Lee o modifica el valor apuntado por la expresion. Se
un puntero y el resultado es del tipo apuntado.
Devuelve un puntero al objeto utilizado como operando, que debe
un lvalue (variable dotada de una direccion de memoria). el
resultado
.
estructura).
->
apuntado
es un puntero de tipo identico al operando.
Permite acceder a un miembro de un objeto agrgado (union,
Accede a un miembro de un objeto agregado (union, esctructura)
por el operando de la izquierda.
--------------------------------------------------------------------------------------Operador condicional (Ternario).
expresion_C ? expresion_v : expresion_f
a<b ? a = 1 : a = 2
c = c>=0 ? 1:-1
--------------------------------------------------------------------------------------Operador coma (,)
Permite combinar dos o mas expresiones separadas por coma en una sola linea.
expresion1, expresion2,...,expresionN
Ej:
int i, j, resultado;
int i;
resultado = j = 10, i = j, ++i;
Cual es el valor final de las variables???
---------------------------------------------------------------------------------------
Operadores especiales (), []
Operador (): Es el operador de llamada de funciones. Sirve para encerrar los argumentos
de una funcion,
efectuar conversiones explicitas de tipo, indicar en el seno de una declaracion que un
odentificador
corresponde a una funcion, resolver los conflictos de prioridad entre los operadores.
Operador []: Sirve para dimensionar los arrays y designar un elemento de un array o una
matriz.
--------------------------------------------------------------------------------------Operador sizeof
Toma como argumento (tipo de dato o nombre de la variable (escalar, array,registro,
etc,...)) y obtiene
como resultado el numero de bytes que ocupa. El formato del operador es:
sizeof(nombre_variable)
sizeof(tipo_dato)
sizeof(expresion)
--------------------------------------------------------------------------------------Conversion de tipos
Las conversiones pueden ser implicitas (ejecutadas automaticamente) o explicitas
(solicitadas por el
programador).
Conversion implicita: C hace muchas conversiones implicitas cuando:
- Se asigna un valor de una variable de un tipo a una de otro tipo (short c = 9, int a,
a = c; sizeof(c)???)
- Cuando se convinan tipos mixtos en expresiones (int a =4 ,c ; short b = 3; c=a+b;)
- Cuando se pasan argumentos a funciones
Los tipos fundamentales (basicos) pueden ser mezclados libremente em asignaciones y
expresiones. Las conversiones
se ejecutan automaticamente: Los operandos del tipo mas bajo se convierten a los
operandos del tipo mas alto
de acuerdo con las siguientes reglas: Si cualquier operando es tipo char, short o
enumerado se convierte en tipo
int; si los operandos tienen los siguientes tipos ver la lista a continuacion, esto se
llama promosion integral.
int, unsigned int, long, unsigned long, floaf, double.(El tipo que viene primero en la
lista se convierte en
el segundo...)
Conversion explicita
C fuerza a conversion explicita mediante el operador molde (cast), que tiene el formato
(tiponombre)valor,
asi convierte valor a tipo nombre (Ver: short c; (int)c, sizeof(c) ???)
--------------------------------------------------------------------------------------Prioridad y asociatividad.
Ejemplos revueltos.
Entrada de datos mas exactamente:
Entrada con letras mayusculas y espacios en blanco.
char line[80];
scanf (" %[ ABCDEFGHIJKLMNOPQRSTUWXYZ]",line)
Ejemplo ensayar entrando: Santa Marta y SANTA MARTA. Que sucede (printf("%s",line))
A variation of this feature which is often more useful is to precede the characters
within the square
brackets by a Circumflex (i.e., ^). This causes the subsequent characters within the
brackets to be interpreted
in the opposite manner. Thus, when the program is executed, successive characters will
continue to be read
from the standard input device as long as each input character does not match one of
the characters enclosed
within the brackets.
#include <stdio.h>
main( )
{
char line[80] ;
scanf (" %[ "^\n]" , line) ;
. . . . .
}
se sigue la entrada siempre y cuando los caracters no coincidan con los encerrados en
[]
Mas sobre la funcion scanf: