Post on 18-Feb-2016
description
transcript
UNIVERSIDAD CENTROAMERICANA
FACULTAD DE CIENCIA, TECNOLOGÍA Y AMBIENTE
Análisis Numérico y Programación
UNIDAD IV: PROGRAMACIÓN
Managua, Noviembre 2015
Contenido
Introducción al Lenguaje C/C++ ......................................................................................... 1
Tema 1: Origen, características, uso actual y ventajas del lenguaje C/C++. ...................... 1
Introducción.................................................................................................................... 1
¿Porqué el Lenguaje C/C++? ......................................................................................... 1
Transición de C a C++ ................................................................................................... 2
Ventajas del Lenguaje C/C++ ......................................................................................... 3
Características ............................................................................................................... 3
Diferencias entre C y C++. ................................................................................................. 5
El IDE CodeBlock: conociendo el entorno .......................................................................... 8
Entorno de CodeBlocks .................................................................................................. 8
Creación de un proyecto ................................................................................................ 9
Programas en C/C++ ....................................................................................................... 11
Elementos de un programa en C/C++. ......................................................................... 12
Precedencia de Operadores ......................................................................................... 19
Estructura de un programa en C/C++. .......................................................................... 23
Tema 5: Edición, compilación y ejecución de programas en C/C++ ................................. 25
Compilador del IDE CodeBlock .................................................................................... 25
Compilando y ejecutando ............................................................................................. 25
Tipos de errores ........................................................................................................... 25
El Preprocesador ......................................................................................................... 25
La directiva del preprocesador #include ....................................................................... 26
La directiva del preprocesador #define: constantes simbólicas ..................... 26
La directiva del preprocesador #define: macros ..................................................... 26
Depuración ................................................................................................................... 28
Tipos de Datos en C/C++ ................................................................................................ 29
Identificadores y Palabras Claves. ................................................................................... 32
Declaración de Variables y constantes ............................................................................ 33
Variables. ..................................................................................................................... 33
Constantes. .................................................................................................................. 33
Representación de Datos en memoria y tamaño de Variables ......................................... 37
Datos definidos por el programador ................................................................................. 37
Arreglos ........................................................................................................................... 38
Operaciones con Arreglos ............................................................................................... 39
Estructuras (struct) .......................................................................................................... 40
Construcción de expresiones en el lenguaje: aritméticas y lógicas. ................................. 43
Expresiones Aritméticas ............................................................................................... 43
Expresiones Lógicas .................................................................................................... 43
Expresiones Generales ................................................................................................ 44
Sentencias ................................................................................................................... 44
Biblioteca de funciones para C/C++. ................................................................................ 50
Principales Librerías en C/C++ ..................................................................................... 50
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 1
Unidad IV: PROGRAMACION
Introducción al Lenguaje C/C++
Objetivos específicos:
Con el desarrollo de esta unidad se pretende que el estudiante sea capaz de:
1. Comprender las características de un lenguaje de programación de alto nivel, específicamente C/C++.
2. Reconocer la estructura de un programa C/C++ y los elementos que lo componen. 3. Describir los elementos principales del entorno de trabajo del IDE (Integrated Development
Environment, Ambiente de Desarrollo Integrado) y sus capacidades. 4. Demostrar habilidades en la construcción de programas simples usando la sintaxis y
semántica del lenguaje C/C++. 5. Reconocer la importancia y utilidad del uso de bibliotecas de funciones en los lenguajes de
nivel alto.
Tema 1: Origen, características, uso actual y ventajas del lenguaje C/C++.
Introducción
¿Porqué el Lenguaje C/C++?
A pesar de que en la actualidad existen muchos lenguajes de propósito general para el
desarrollo de aplicaciones, C/C++ ha sido desde sus inicios uno de los lenguajes más
aceptados por los programadores debido a sus ventajas y características, que le han permitido
extenderse rápidamente.
1. Poderoso y Flexible Dadas las características del mismo, se pueden hacer diversos proyectos como Sistemas operativos, Procesadores de Texto, Hojas de Cálculo, etc.
2. Lenguaje común Dado que es un lenguaje común, existen una amplia variedad de Compiladores de C y accesorios útiles.
3. Transportable Se puede correr en cualquier tipo de Computadora, ésta característica la aumenta el Estándar C.
4. Pocas Palabras Tiene pocas palabras claves (que son la base sobre la cual está construida la funcionalidad del lenguaje). Esto es una ventaja importante contrariamente a lo que parece.
5. Modular El código de C puede y debe ser escrito en módulos llamado FUNCIONES, estas pueden ser utilizadas y reutilizadas por otras aplicaciones o programas.
C es un lenguaje de programación de empleo general, caracterizado por su síntesis y por
poseer un moderno flujo de control y estructuras de datos, así como un potentado conjunto de
operadores. No es un lenguaje de “muy alto nivel” ni “grande”, no se especializa en un área en
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 2
particular. Su carencia de restricciones y su generalidad lo hacen más eficaz y conveniente
para muchas tareas que otros lenguajes.
C fue diseñado originalmente para crear el sistema operativo UNIX, sin embargo no está ligado
a un hardware o sistema en concreto, siendo fácil escribir programas que ejecuten tareas sin
ningún cambio en cualquier máquina que soporte a C.
El lenguaje no cuenta con operaciones de entrada y salida: no existen instrucciones READ o
WRITE, ni métodos propios de acceso a archivos; todos estos mecanismos de alto nivel deben
ser aportados por funciones llamadas explícitamente.
Aunque las posibilidades de C corresponden a las de muchas computadoras, el lenguaje es
independiente de cualquier arquitectura de máquina en particular y así, con algo de cuidado,
es fácil escribir programas “portátiles”, es decir programas que pueden ejecutarse sin cambios
en una amplia variedad de computadoras.
C posee las estructuras fundamentales de control de flujo sin las cuales no es posible escribir
programas bien estructurados: agrupamiento de sentencias, toma de decisiones (if), ciclos
(bucles), con comprobación de la condición de terminación al principio (while, for) o al final (do)
y selección entre un conjunto de casos posibles (switch).
Finalmente C, igual que cualquier otro lenguaje, tiene sus inconvenientes: algunos de los
operadores tienen precedencia equivocada, algunas partes de la sintaxis podrían ser mejores,
lo poco estricto que es el lenguaje con la comprobación de los tipos de datos (dejando esta
tarea muchas veces en manos del programador).
Transición de C a C++
Reseña de la evolución del lenguaje C hasta llegar a C++:
1967 ............................... Martín Richard Lenguaje BCPL (Prototipo A) 1970 ............................... Ken Thompson
Prototipo B Recodificación del S.O. UNIX
1972 ............................... Dennis Ritchie Lenguaje C Laboratorios Bell Telephone 1980’s ............................ Bjarne Stroustrup Lenguaje C++ ................ AT&T
Se dice que C es un subconjunto de C++, es decir, todo lo que un programador conoce sobre el lenguaje C es aplicable a C++. El lenguaje C++ se comenzó a desarrollar en 1980. Su autor fue B. Stroustrup, de la AT&T. Al comienzo era una extensión del lenguaje C que fue denominada C with classes (C con Clases). Este nuevo lenguaje comenzó a ser utilizado fuera de la AT&T en 1983. El nombre C++ es también de ese año, y hace referencia al carácter del operador incremento de C (++).
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 3
Ante la gran difusión y éxito que iba obteniendo en el mundo de los programadores, la AT&T comenzó a estandarizarlo internamente en 1987. En 1989 se formó un comité ANSI (seguido algún tiempo después por un comité ISO) para estandarizarlo a nivel internacional. En la actualidad, el C++ es un lenguaje versátil, potente y general. Su éxito entre los programadores profesionales le ha llevado a ocupar el primer puesto como herramienta de desarrollo de aplicaciones. El C++ mantiene las ventajas del C en cuanto a riqueza de operadores y expresiones, flexibilidad, concisión y eficiencia. Además, ha eliminado algunas de las dificultades y limitaciones del C original. La evolución de C++ ha continuado con la aparición de Java, un lenguaje creado simplificando algunas cosas de C++ y añadiendo otras, que se utiliza para realizar aplicaciones en Internet. C++ fue originalmente un precompilador, similar al preprocesador de C, el cual convertía construcciones especiales a código en C. Este código era entonces compilado por un compilador normal de C. El “precódigo”, el cual era leído por el precompilador de C++, era usualmente guardado en un archivo con extensión .cc, .C o .cpp. Este archivo se convertía en un archivo de C con extensión .c.
La nomenclatura de C++ permanece igual. El hecho de que el código de C++ usualmente era tratado por un compilador de C es por la razón de que C++ es en principio un supraconjunto de C: C++ ofrece todas las posibilidades de C y algo más. Debido a lo anterior puede pensarse que la transición de C a C++ es muy fácil. Programadores que están familiarizados con C pueden iniciar “programando en C++” usando archivos fuente con extensión .cc o .cpp en vez de .c y de esta manera usar todas las ventajas que C++ ofrece. Sin embargo a lo largo de la historia de C++, programadores acostumbrados a los lenguajes estructurados (C, Fortran, Pascal, etc.) no hacen la transición a C++ de manera simple, pues es necesario cambiar la forma de pensar al momento de programar (Por las características de la POO).
En C++, además de haber más herramientas para la programación, también es posible programar usando diferentes paradigmas como programación modular, programación orientada a objetos y programación genérica.
Ventajas del Lenguaje C/C++
1. Genera los programas más compactos y rápidos
2. El código es altamente transportable
3. Facilidad de aprendizaje
4. Su uso es de propósito general
5. Libertad en la escritura de programas
6. Implementa bastante bien la orientación a objetos (C++)
C++ fue desarrollado para añadirle al lenguaje C los conceptos de orientación a objetos. Utilizan
casi las mismas palabras claves.
Características
El lenguaje C cubre el vacío entre el lenguaje de máquina y los lenguajes de alto nivel más
convencionales. Esta flexibilidad permite el uso de C en la programación de sistemas (por
ejemplo, el diseño de sistemas operativos) así como en la programación de aplicaciones (por
ejemplo, para redactar un programa que resuelva un complicado sistema de ecuaciones
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 4
Características
matemáticas o un programa que escriba las facturas para clientes). C se caracteriza por hacer
posible la redacción de programas muy concisos, debido en gran parte al gran número de
operadores que incluye el lenguaje. Tiene un repertorio de instrucciones relativamente
pequeño, aunque las implementaciones actuales incluyen numerosas funciones de biblioteca
que mejoran las instrucciones básicas. Es más, el lenguaje permite a los usuarios escribir
funciones de biblioteca adicionales para su uso propio. De esta forma las características del
lenguaje se pueden ampliar fácilmente por el usuario.
Una de las características más importantes de C es la portabilidad de sus programas, más que
los escritos en otros programas de alto nivel. La razón de esto es que C deja en manos de las
funciones de biblioteca la mayoría de las funciones dependientes de la computadora. Toda
versión de C se acompaña de su propio conjunto de funciones de biblioteca, que están escritas
para las características particulares de la computadora en la que se instale.
1. Lenguaje de propósito general. 2. Programación estructurada. 3. Economía en las expresiones. 4. Abundancia de operadores y tipos de datos. 5. Codificación de alto y bajo nivel simultáneamente. Pretende ser un lenguaje
de alto nivel con la versatilidad del bajo nivel. 6. Altamente transportable. 7. Eficaz, expresivo y potente. 8. Lenguaje compilado
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 5
Diferencias entre C y C++.
C fue creado en 1972 por Dennis M. Ritchie en los Laboratorios Bell como evolución del anterior
lenguaje B, a su vez basado en BCPL.
C++, por su parte, fue creado a mediados de los años 1980 por Bjarne Stroustrup. La intención
de su creación fue el extender al exitoso lenguaje de programación C con mecanismos que
permitan la manipulación de objetos.
Así que C es el lenguaje original, mientras que C++ es una ampliación de C, por eso el ++.
En C
#include<stdio.h>
int main()
{
printf ("Hola Mundo");
return 0;
}
En C++
#include<iostream>
using namespace std;
int main()
{
cout << "Hola mundo";
return 0;
}
Lo que noté al hacer estos dos programitas es que pedir un dato en C++ es mucho mucho más simple que en C. Sin embargo, el asunto de los << y >> puede llegar a ‘asustar’ a los recién iniciados en la programación.
Pedir un dato en C scanf("modificador", &nombre de la variable);
Pedir un dato en C++ cin >> nombre de la variable;
Mostrar un dato en C printf("Dato: modificador", nombre de la variable);
Mostrar un dato en C++ cout << "Dato: " << nombre de la variable;
Los modificadores son los siguientes: %d para int, %f para float, %s para string, %c para char.
Librerías en C++
Por simple convención las librerías en C terminan en ‘.h’ (punto hache). Todas las librerías de C sirven para C++, sin embargo, también por convención, se elimina la terminación ‘.h’ y mejor se agrega ‘c’ al principio.
Libreria en C Librería en C++
math.h cmath string.h cstring time.h ctime etcetera.
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 7
El ‘namespace’
C como lenguaje tiene un conjunto de palabras reservadas, como por ejemplo: if, for, while, int, float, … C++ es una ampliación, por lo tanto tiene que agregar nuevas palabras reservadas. Éstas palabras reservadas están en un ‘namespace’ (espacio de nombres). En específico cout y cin están el namespace std (standard).
Si no declararamos que vamos a usar el namespace std (using namespace std;), cada vez que quisieramos usar cout, tendríamos que escribir std::cout.
Funciones
En primer lugar, en C cuando una función no toma parámetros, su prototipo tiene la palabra void. Sin embargo en C++ void no es necesario(opcional).
Prototipo en C: char f1(void); Prototipo en C++: char f1();
Otra diferencia entre C y C++ es que en un programa de C++ todas las funciones deben estar en forma de prototipo, en C los prototipos se recomiendan, pero son opcionales. También si una función de C++ es declarada para devolver un valor obligatoriamente la sentencia return debe devolver un valor, en C no es necesario que se devuelva.
Otra diferencia es el lugar donde se declaran las variables locales. En C, deben ser declaradas solo al principio del bloque, mientras que en C++ las variables se pueden declarar en cualquier punto. Aunque es conveniente realizarlo siempre al comienzo de la función.
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 8
El IDE CodeBlock: conociendo el entorno
Entorno de CodeBlocks
Code::Blocks Es un IDE (Integrated Development Environment, Ambiente de Desarrollo
Integrado) para programar en los lenguajes C++ y C, esto es:
Una aplicación que contiene herramientas que facilitan el desarrollo de software enC/C++.
Básicamente, está formado por un editor de código (editor de texto), un compilador (de
C/C++) y un sistema para manejo de proyectos (código fuente y otros elementos para el
desarrollo de un software particular)
La primera vez que ejecutamos nuestro IDE Code::Blocks veremos algo a la siguiente imagen.
Pestaña “Proyectos”: Contiene el árbol del sistema de archivos (headers: .h, .hpp, etc; y fuentes :.c, .cpp, etc) de los proyectos abiertos. Pestaña “Recursos”: Contiene el árbol del sistema de archivos de recursos (frames, panels, etc) elacionados con wxWidgets.
Menús y
barras de
herramientas
Área de trabajo principal
Área de
manejo de
proyectos
Área de notificaciones Barra de
Estado
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 9
Pestaña “Símbolos”: Contiene lista de funciones, variables y typedefs globales, variables del
preprocesador y clases (con sus atributos y métodos)
Área de trabajo principal: Página de bienvenida o editor de código con múltiples pestañas (una por archivo abierto) y diseño de GUI al trabajar en proyectos.
Área de notificaciones: Mensajes de carga y descarga de archivos, detalles de
búsquedas, salida de compilación, salida de debug, etc.
Barra de estado: Ruta absoluta de archivo actual, codificación de caracteres, posición
del cursor, modo de inserción, estado de archivo...
Creación de un proyecto
Ahora, para crear un proyecto vamos a file > new > project.
Nos aparecerá una ventana emergente como esta.
.
Seleccionamos
Console
application (o el tipo
de aplicación que
desea) y
presionamos Go.
Damos clic en next y
nos aparecerá una
ventana para elegir
el lenguaje
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 10
Presionamos next y introducimos el título de la aplicación en, Project title. Y presionamos next.
Nos aparecerá una ventana como esta. Aquí podemos configurar las opciones del espacio de trabajo y donde se guardaran nuestros archivos. Presionamos finish.
Build Targets Contienen los datos que requiere el compilador para construir el software o partes del software.
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 11
Una vez hecho esto, ya podemos empezar a programar solo tenemos que abrir el archivo main.c
para editarlo y compilarlo con F9.
Abrimos el nodo o carpeta azul de la izquierda y seleccionamos main.c, que será el archivo de código fuente de nuestra aplicación.
Al guardar se crea un archivo de extensión .cbp. Los programas fuente se almacenan como archivos
con extensión .c para C y .cpp para C++. Una vez almacenados se compilan, ejecutándose en una
primera fase cualquier directiva del preprocesador tal como #include. Las directivas importan cualquier
archivo necesario, normalmente definiciones de bibliotecas; por ejemplo #include<iostream.h>, incluye
en el programa a la biblioteca IO (Entrada/Salida) donde se encuentran las funciones cout (flujo de salida)
y cin (flujo de entrada). Una vez compilados los archivos del programa y los archivos a incluir se obtiene
un archivo objeto por cada archivo fuente (con extensión .o en Dev-C++). Por último se enlazan los
archivos objeto con los archivos de biblioteca, proporcionando un archivo de programa ejecutable (con
extensión .exe).
Programas en C/C++
Un programa en C/C++ es una colección de funciones que comienza con la ejecución de la función Main
( ).
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 12
Elementos de un programa en C/C++.
Un programa se compone de un conjunto de elementos denominados elementos léxicos (tokens) que el compilador reconoce como una unidad fundamental. Cada elemento léxico se compone de una colección de caracteres que forman el vocabulario básico que reconoce el compilador. Un elemento léxico en C++ es, por ejemplo, main.
Los elementos de un programa C/C++ son la clave para entender la sintaxis del lenguaje como tal, pues muestran al programador cuáles son las herramientas con la que cuenta para la realización de programas, por ejemplo, cuáles son los operadores básicos, palabras reservadas, sintaxis de escritura del lenguaje, etc.
a) Juego de Caracteres C/C++
a b c d e f g h i j k l m n o p q r s t u v w x y z
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
0 1 2 3 4 5 6 7 8 9
+ - * / = { } ( ) [ ] < > ‘ “ ! # ~ ^ % & _ : ; , . ?
| \
Carácter en blanco y tabulador
b) Palabras Reservadas
Las palabras reservadas son elementos de léxico predefinidos para el lenguaje que tienen un significado especial para el compilador de C/C++. Sus definiciones no se pueden cambiar, por ello no pueden utilizarse para usarlas como identificadores del usuario.
Palabras Reservadas ISO/ANSI C++ (Recuerde que C es un subconjunto de C++)
asm* else operator* throw*
auto enum private* true
bool explicit protecte*d try
break extern public* typedef
case false register typeid
catch* float reinterpret_cast typename
char for return union
class* friend* short unsigned
const goto signed using
const_cast if sizeof virtual*
continue inline* static void
default int static_cast volatile
delete* long struct wchar_t
Do mutable switch while
double namespace template*
dynamic_cast new* this*
* Estas palabras no existen en ANSI C
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 13
c) Comentarios
Recordemos que los comentarios son aclaraciones que hace el programador en un programa con el fin de hacerlo más comprensivo para él mismo y para otros programadores. Inicialmente en el lenguaje C los comentarios se escribían usando un símbolo de apertura (/*) y otro de cerradura (*/).
int main ( )
{
int x; /* esto es la declaración de una variable de tipo entero */
}
C++ soporta dos mecanismos para establecer comentarios. El primero, heredado del C, que utiliza los mismos símbolos para definir el rango que comprende el comentario, es decir, un comentario puede iniciar en la línea número uno ( iniciando con /*) y finalizar en la línea número diez (terminando con */).
El segundo tipo de comentario utiliza la pareja de caracteres // que marca el comienzo de un comentario que se extiende estrictamente hasta el final de la misma línea.
int main ( )
{
int x; // esto es la declaración de una variable de tipo entero
}
d) Identificadores
Un identificador es una secuencia de letras, dígitos y caracteres subrayados ( _ )que se usan para asignar como nombre a una variable, función, constante y similares. Las reglas que se deben seguir en la elección de un identificador son:
El primer carácter de un identificador debe comenzar con una letra o un carácter subrayado.
Los caracteres siguientes pueden ser letras, dígitos o subrayados.
No pueden dejarse espacios en blanco.
No pueden usarse caracteres especiales (distintos de A..Z, a..z, 0..9, _ ).
No se acepta un carácter acentuado o el carácter Ñ o ñ (ninguno existe en el idioma inglés).
Los identificadores en C/C++ son sensibles a las mayúsculas. Por ejemplo, Volumen, VOLUMEN, volumen, VOLumen y voluMEN son cinco identificadores distintos.
No se pueden utilizar palabras reservadas tales como int, auto, bool, etc. como nombres de identificadores.
Reglas Prácticas de Creación de Identificadores
Utilizar nombres con letras minúsculas para las variables. En caso de nombres con más de una palabra separar los dos nombres con un subrayado.
primera_prueba numero_de_items hora_por_dia
Utilizar nombres con letras minúsculas para las variables. En caso de nombre con más de una palabra, comenzar cada palabra con una mayúscula.
PrimeraPrueba NumeroDeItems HorasPorDias
Utilizar letras mayúsculas para definir constantes. PI HORAS_POR_DIA UNO DOS
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 14
Identificadores Válidos Identificadores no Válidos x 9 comienza por dígito y 9y comienza por dígito miNombre mi-Nombre incluye un guión alto HORAS_POR_DIA HORASPOR$ incluye $ Numero_Hex_1 Numeros$Hex incluye $ Num_Hex_1 protected palabra reservada _Longitud sizeof palabra reservada _Longitud_ switch palabra reservada base23 año12 incluye ñ
e) Variables
En C/C++ una variable es una posición de memoria con nombre (identificador) donde se almacena
un valor, de un cierto tipo de dato, que puede modificarse. Las variables pueden almacenar todo tipo
de datos: números enteros, números con decimales, cadenas de caracteres, valores lógicos, etc.
Toda variable que se usa en un programa debe ser declarada previamente. En el caso de C++ no se
define dentro del programa un área de declaración de variables (como pasa con ANSI C) sino que el
programador puede hacer la declaración en cualquier lugar del programa antes de usarla.
Una declaración de variable reserva un espacio de almacenamiento en memoria. El proceso para crear
una variable es escribir el tipo de dato, el identificador o nombre de variable y, en ocasiones, un valor
inicial. Por ejemplo: char repuesta;
Las variables pueden ser inicializadas en el momento que se declaran, o bien inicializarlas después de
la declaración. Por supuesto el primer método es el más utilizado.
int total=100; char Caracter=’R’; float valor=3.8;
f) Constantes
Una constante es un lugar en la memoria de la computadora que guarda un valor al igual que una
variable, la diferencia está en el hecho de que el valor que contiene nunca podrá ser modificado durante
toda la ejecución de un programa.
En C/C++ existen cuatro tipo de constantes: constantes de tipo entero, carácter, flotante y cadena.
Sintaxis: <const> <tipo de constante> <nombre de la constante> <=> <valor>;
Ejemplo: const int MAX=100;
const int NUM_MAX=1000;
const char UNIDAD=’A’;
const double V=3.5;
const float C=3.14e+32;
const char CADENA[21]=“Hola a todo el Mundo“;
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 15
El modificador const se usa además en C/C++ para proporcionar protección de sólo lectura a los
parámetros que se pasan a una función. Cuando se hace preceder a un tipo de argumento el modificador
const para indicar que este argumento no se puede cambiar, el argumento al que se le aplica no se
puede asignar un valor ni cambiar.
void copia(const int a, int b)
Los valores de las constantes tipo carácter se representan entre comillas simples:
const char X=’s’;
Entonces, ¿cómo se representa el carácter ‘ si es un elemento sintáctico del lenguaje?, es decir ¿cómo
usarlo si ya tiene un uso establecido?. El compilador C/C++ reconoce también un conjunto de constantes
tipo carácter denominadas secuencias de escape, fueron creadas para dar solución a este tipo de
problemas:
Secuencia
de escape Significado
Secuencia
de escape Significado
‘\n’ Nueva línea ‘\\’ Barra inclinada
‘\t’ Tabulación ‘\?’ Signo de interrogación
‘\v’ Tabulación Vertical ‘\’’ Comilla simple
‘\b’ Retroceso ‘\”’ Dobles comillas
‘\r’ Retorno ‘\0’ Carácter nulo
‘\f’ Avance de páginas ‘\a’ Timbre
g) Operadores
Los operadores permiten construir expresiones para consultar condiciones, actualizar información y
asignar nuevos valores. Los operadores permiten manipular variables y construir tales expresiones.
Operandos son las variables u otras expresiones que manipulan los operadores. Muchos operadores
tienen restricciones que se aplican a los tipos de datos.
C/C++ se caracteriza por ser un lenguaje rico en operadores, de hecho tiene quince categorías.
Algunas clasificaciones: aritméticos, relacionales, lógicos, manipulación de bits, coma, asignación,
condicional, sizeof, entre otros.
1. Operadores Aritméticos
Los operadores aritméticos soportan la manipulación de enteros y números de coma flotante
Operador C++ Significado Tipo de dato Ejemplo
- menos unitario numérico x=-1*(x+1)
+ Suma numérico b=35+c
- Resta numérico z=3.14-t
/ División numérico d=m/v
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 16
Operador C++ Significado Tipo de dato Ejemplo
* multiplicación numérico area=longitud*altura
% Módulo entero cuenta=w%15
Los operadores aritméticos son también legales con tipos de datos carácter. Supongamos que la
variable carácter c contiene un carácter ASCII entre ‘0’ y ‘9’.
char c=9;
int digito = ‘0’;
digito = c-‘0’;
Estas sentencias convierten el valor a un dígito decimal (c y el valor ‘0’ se transforman a enteros).
2. Operadores Relacionales
Un operador relacional, también llamados de comparación, es un símbolo que indica una relación
entre dos cantidades. Estas cantidades pueden ser variables, constantes o funciones. Todos los
operadores relacionales proporcionan un resultado de tipo bool (verdadero o falso).
Operador C++ Significado Ejemplo Verdadero Ejemplo Falso
> mayor que 5>4 3>5
>= mayor o igual que 10>=10 3>=5
< menor que 3<5 5<3
<= menor o igual que 3<=15 15<=3
= = igual a 5= =5 10= =5
!= distinto de 8!=4 24/2!=12
3. Operadores Lógicos
Los operadores lógicos toman valores lógicos (bool) y devuelven resultados también lógicos (Si
o No). Existen tres operadores lógicos: and (&&), or (||) y not (!).
Operador C++ Significado Ejemplo
&& AND (y) lógico k>1 && k<15
|| OR (o) lógico k<0 || k>25
! NOT (no) lógico ! (k>1)&&(k<10)
4. Operadores de Asignación
Los operadores de asignación sirven para realizar sentencias de asignación ya que forman parte de ellas. La sentencia de asignación evalúa el lado derecho de la asignación y lo convierte a un valor compatible con la variable del lado izquierdo. Este valor se asigna a la variable del lado izquierdo. int z=50; //asigna el valor 50 a la variable z int z=w+1; //asigna (w+1) a z
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 17
C++ permite asignaciones múltiples en una sentencia única, por ejemplo: a=b+(c=5); equivale a c=5; y a=b+c; La asignación simple (=) se evalúa de derecha a izquierda, permitiendo asignaciones en cascada, tales como: x=y=z=1; lo que hace que cada una de las variables tome el valor de 1.
Operador C++ Ejemplo Ejemplo en Formato Largo (equivalente)
+= suma+=x suma=suma+x
-= y-=x y=y-x
/= cuenta/=n cuenta=cuenta/n
*= sol*=factor sol=sol*factor
%= bin%=cuenta bin=bin%cuenta
Ejemplo: a*=a+b equivale a a=a*(a+b)
5. Operadores de Incremento y Decremento
C++ ofrece los operadores de incremento (++) y decremento (--) que permiten abreviar la sintaxis de sumar o restar 1, respectivamente, al valor de una variable. La sintaxis general del operador ++ es: formato1: preincremento ++variable formato2: postincremento variable++ La versión preincremento del operador ++ incrementa el valor de su operando antes de que la
variable proporcione su valor a la expresión en la que se encuentra. La versión postincremento
incrementa el valor de su operando después de que la variable proporcione su valor a la expresión
en la que se encuentra.
int cuenta =1;
int num;
num=cuenta++; // num almacena 1 y cuenta almacena 2
num=++cuenta; // num almacena 3 y cuenta almacena 3
La sintaxis general del operador -- es:
formato1: predecremento --variable
formato2: postdecremento variable—
La versión predecremento del operador -- decrementa el valor de su operando antes de que la
variable proporcione su valor a la expresión en la que se encuentra. La versión postdecremento
decrementa el valor de su operando después de que la variable proporcione su valor a la
expresión en la que se encuentra.
int cuenta =10; int num; num=cuenta--; // num almacena 10 y cuenta almacena 9 num=--cuenta; // num almacena 8 y cuenta 8
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 18
otros ejemplos: j=++i; // equivale a i=i+1; j=i; j=i++; // equivale a j=i; i=i+1; i=++i+i++ // dependiente del sistema
Los operadores incremento y decremento trabajan también con flotantes y doubles.
6. Operador Coma
El operador coma (,) es específico de C y C++. Este operador permite la evaluación de expresiones múltiples es una sentencia. El operador agrupa parejas de subexpresiones:
expresión1, expresión2, expresión3, . . ., expresión
ejemplo: int suma=0, j=1;
En el ejemplo anterior j es declarada como int y toma el valor 1.
otro ejemplo usando un ciclo for:
for (int i=0, j=MAX-1; i<j; i++, j--)
En este bucle for las variables i y j controlan las iteraciones del bucle. La sentencia de
inicialización utiliza el operador coma para iniciar ambas variables de control en la misma
sentencia. De modo similar, la parte incremento del bucle incrementa la variable i y decrementa
la variable j. El operador coma separa las dos expresiones en la parte incremento.
7. Operador Condicional
El operador ?: es un operador ternario.
Su formato es: expresión1 ? expresión2 : expresión3
Si expresión1 se evalúa verdadero, expresión2 se evalúa; en caso contrario, se evalúa
expresión3. int a=3, b=5, c;
c=(a>b)?a:b;
En este ejemplo, c toma el valor de b porque la expresión (a>b) resultó ser falsa.
8. Operador sizeof
El operador sizeof devuelve el número de bytes de su operando. Los formatos son: sizeof(tipo) y sizeof (expresión) Tipo es un tipo definido por el usuario o predefinido por el lenguaje, y ambos formatos se evalúan en tiempo de compilación. En el segundo formato, el compilador no evalúa la expresión; en su lugar, se determina el número de bytes del tipo de resultado de la expresión. char nombre_unidad; int tam=sizeof(char) int tam2=sizeof(nombre_unidad)
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 19
El valor de retorno de sizeof es dependiente de la máquina y del compilador. Veamos los siguientes ejemplos: char buf[80]; // array de 80 caracteres int i=15; // int double j=15; // double enum {max=100}; // enumerador cout<<sizeof(buf); // 80 bytes cout<<sizeof(i); // 4 bytes cout<<sizeof(j); // 8 bytes cout<<sizeof(max); // 4 bytes
Precedencia de Operadores
Los operadores en C/C++ tienen definida una precedencia de evaluación. El orden de evaluación indica
cómo el compilador establece la evaluación de una expresión con operadores que tienen la misma
precedencia. La siguiente tabla muestra en la columna de precedencia los números de menor a mayor.
Así, los operadores con un valor 2 en la columna de precedencia tiene igual prioridad y todos los que
tienen valor 3 comparten una precedencia más baja.
Ejemplo: double x=3.0;
double y=6.0; double z=10.0; double t; t=x+y*z; cout<<t ; // imprime 63
Categoría Nombre Símbolo Orden de Evaluación Precedencia
Unitario Postincremento ++ Izquierda a derecha 2
Postdecremento -- Izquierda a derecha 2
Dirección & Derecha a izquierda 2
NOT bit a bit ~ Derecha a izquierda 2
Lógico NOT Derecha a izquierda 2
Negación - Derecha a izquierda 2
Signo más + Derecha a izquierda 2
Preincremento ++ Derecha a izquierda 2
Predecremento -- Derecha a izquierda 2
Tamaño de dato sizeof Derecha a izquierda 2
Multiplicativo Módulo % Izquierda a derecha 3
Multiplicación * Izquierda a derecha 3
División / Izquierda a derecha 3
Aditivo Suma + Izquierda a derecha 4
Resta - Izquierda a derecha 4
Desplazamiento
(bit a bit) Desplazar
izquierda <<
Izquierda a derecha 5
Desplazar derecha >> Izquierda a derecha 5
Relacional Menor que < Izquierda a derecha 6
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 20
Categoría Nombre Símbolo Orden de Evaluación Precedencia
Menor o igual que <= Izquierda a derecha 6
Mayor que > Izquierda a derecha 6
Mayor o igual que >= Izquierda a derecha 6
Igual = = Izquierda a derecha 7
Diferente = Izquierda a derecha 7
Bit a bit AND & Izquierda a derecha 8
XOR ^ Izquierda a derecha 9
OR | Izquierda a derecha 10
Lógico AND && Izquierda a derecha 11
OR || Izquierda a derecha 12
Ternario Expresión
condicional :
Derecha a izquierda 13
Asignación Aritmético = Derecha a izquierda 14
+= Derecha a izquierda 14
-= Derecha a izquierda 14
*= Derecha a izquierda 14
/= Derecha a izquierda 14
%= Derecha a izquierda 14
Desplazar >>= Derecha a izquierda 14
<<= Derecha a izquierda 14
Bit a bit &= Derecha a izquierda 14
|= Derecha a izquierda 14
^= Derecha a izquierda 14
Coma , Izquierda a derecha 15
Adjunto a este tema una tabla de CODIGOS DE CARACTERES ASCII. Es muy útil para la creación de algunos programas que usan caracteres y cadenas de caracteres.
Tabla de Códigos ASCII de 8 bits
Valor
ASCII
Carácter Valor
ASCII
Carácter Valor
ASCII
Carácter
000 (nulo) 043 + 086 V
001 ☺ 044 , 087 W
002 ☻ 045 - 088 X
003 ♥ 046 . 089 Y
004 ♦ 047 / 090 Z
005 ♣ 048 0 091 [
006 ♠ 049 1 092 \
007 (bip) 050 2 093 ]
008 ◘ 051 3 094 ^
009 (tabulador) 052 4 095 _
010 (avance de línea) 053 5 096 `
011 (hogar) 054 6 097 a
012 (avance de formulario) 055 7 098 b
013 (retorno de carro) 056 8 099 c
014 ♫ 057 9 100 d
015 ☼ 058 : 101 e
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 21
Tabla de Códigos ASCII de 8 bits
Valor
ASCII
Carácter Valor
ASCII
Carácter Valor
ASCII
Carácter
016 ► 059 ; 102 f
017 ◄ 060 < 103 g
018 ↕ 061 = 104 h
019 ‼ 062 > 105 i
020 ¶ 063 ? 106 j
021 § 064 @ 107 k
022 ▬ 065 A 108 l
023 ↨ 066 B 109 m
024 ↑ 067 C 110 n
025 ↓ 068 D 111 o
026 → 069 E 112 p
027 ← 070 F 113 q
028 (cursor a la derecha) 071 G 114 r
029 (cursor a la izquierda) 072 H 115 s
030 (cursor arriba) 073 I 116 t
031 (cursor abajo) 074 J 117 u
032 (espacio) 075 K 118 v
033 ¡ 076 L 119 w
034 “ 077 M 120 x
035 # 078 N 121 y
036 $ 079 O 122 z
037 % 080 P 123 {
038 & 081 Q 124 |
039 ‘ 082 R 125 }
040 ( 083 S 126 ~
041 ) 084 T 127 ⌂
042 * 085 U 128 Ç
129 ü 172 ¼ 215 Î
130 é 173 ¡ 216 Ï
131 â 174 « 217 ┘
132 ä 175 » 218 ┌
133 à 176 ░ 219 █
134 å 177 ▒ 220 ▄
135 ç 178 ▓ 221 ¦
136 ê 179 │ 222 Ì
137 ë 180 ┤ 223 ▀
138 è 181 Á 224 Ó
139 ï 182 Â 225 ß
140 î 183 À 226 Ô
141 ì 184 © 227 Ò
142 Ä 185 ╣ 228 õ
143 Å 186 ║ 229 Õ
144 É 187 ╗ 230 µ
145 æ 188 ╝ 231 þ
146 Æ 189 ¢ 232 Þ
147 ô 190 ¥ 233 Ú
148 ö 191 ┐ 234 Û
149 ò 192 └ 235 Ù
150 û 193 ┴ 236 ý
151 ù 194 ┬ 237 Ý
152 ÿ 195 ├ 238 ¯
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 22
Tabla de Códigos ASCII de 8 bits
Valor
ASCII
Carácter Valor
ASCII
Carácter Valor
ASCII
Carácter
153 Ö 196 ─ 239 ´
154 Ü 197 ┼ 240
155 ø 198 ã 241 ±
156 £ 199 Ã 242 ‗
157 Ø 200 ╚ 243 ¾
158 × 201 ╔ 244 ¶
159 ƒ 202 ╩ 245 §
160 á 203 ╦ 246 ÷
161 í 204 ╠ 247 ¸
162 ó 205 ═ 248 °
163 ú 206 ╬ 249 ¨
164 ñ 207 ¤ 250 ·
165 Ñ 208 ð 251 ¹
166 ª 209 Ð 252 ³
167 º 210 Ê 253 ²
168 ¿ 211 Ë 254 ■
169 ® 212 È 255 (espacio en
170 ¬ 213 ı blanco)
171 ½ 214 Í
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 23
Estructura de un programa en C/C++.
Todo programa en C consta de una o más funciones, una de las cuales se llama main. El programa
siempre comenzara por la ejecución de la función main. Las definiciones de las funciones adicionales
pueden preceder o seguir a main.
Cada función debe tener:
1. Una cabecera de la función, que consta del nombre de la función, seguido de una lista opcional de
argumentos encerrados con paréntesis.
2. Una lista de declaraciones de argumentos, si se incluyen estos en la cabecera.
3. Una sentencia compuesta, que contiene el resto de la función.
Los argumentos son símbolos que representan información que se le pasa a la función desde otra parte
del programa. También se llaman parámetros a los argumentos.
Cada sentencia compuesta se encierra con un par de llaves “{sentencia}”. Las llaves pueden contener
combinación de sentencias elementales (denominadas sentencias de expresión) y otras sentencias
compuestas. Así las sentencias compuestas pueden estas anidadas, una dentro de otra. Cada sentencia
de expresión debe acabar en punto y coma (;).
Los comentarios pueden aparecer en cualquier parte del programa, mientras estén situados entre los
delimitadores /* y */ por ejemplo /* esto es un comentario */. Los comentarios son útiles para identificar
los elementos principales de un programa o para la explicación de la lógica subyacente de estos.
Ejemplo de un Programa en C.
#include <stdio.h>
/* Programa para calcular el área de un circulo. */
main()
{
float radio, area;
printf(“Radio = “);
scanf(“%f”, &radio);
area=3.14159*radio*radio;
printf(“Area = %f”, area);
}
Acceso a archivo de biblioteca.
Comentario.
Cabecera de función.
Abertura de llave.
Declaración de variables.
Sentencia de salida.
Sentencia de entrada.
Sentencia de asignación. Proceso
Sentencia de salida.
Cierre de llave. Fin función Main
Característica de un programa en C.
Basado en el ejemplo anterior tenemos:
1. El programa está escrito en minúscula sin acentuar (salvo los comentarios). Se pueden usar mayúsculas o minúsculas, aunque es costumbre escribir en minúsculas las instrucciones ordinarias. La mayoría de los comentarios también se escriben en minúsculas, aunque a
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 24
veces se hace en mayúsculas para poner especial énfasis, o distinguir ciertos comentarios de instrucciones (las letras mayúsculas o minúsculas no son equivalentes en c).
2. La primera línea contiene una referencia a un archivo especial (stdio.h) que contiene información que se debe incluir (include) en el programa cuando se compila. La inclusión requerida de esta información será manejada automáticamente por el compilador.
3. La segunda línea es un comentario que describe el propósito del programa. 4. La tercera línea es la cabecera de la función main. Los paréntesis vacíos que siguen al
nombre de la función indican que esta no incluye argumentos. 5. Las cinco líneas restantes del programa están adentradas con tabuladores a la izquierda y
encerrados entre un par de llaves. Estas cinco líneas integran la sentencia compuesta dentro del main.
6. La primera línea adentrada es una declaración de variable. Establece los nombres simbólicos radio y área como variables de coma flotante.
7. Las otras cuatro líneas adentradas son un tipo particular de sentencia de expresión. La segunda línea adentrada printf solicita información en este caso el valor del radio. El valor se introduce o almacena al ejecutar la tercera línea adentrada scanf.
8. La cuarta línea adentrada es un tipo particular de sentencia de expresión llamada sentencia de asignación. Esta sentencia hace el cálculo del área a partir del valor del radio dado.
9. La última línea adentrada printf presenta el valor calculado. El valor numérico esta precedido por un breve mensaje “Área =”
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 25
Tema 5: Edición, compilación y ejecución de programas en C/C++
Compilador del IDE CodeBlock
Compilando y ejecutando
Las opciones Build >> build y Build >> run, construyen y ejecutan el programa, respectivamente. Se
pueden atajar mediante las pulsaciones de teclas Ctrl+F9 y Ctrl+F10, o, incluso, si se desean realizar
ambas acciones en secuencia, pulsando F9.
En cuanto a la barra de herramientas, pulsando la rueda dentada se compila, y pulsando el triángulo de reproducción se ejecuta.
Cuando el proyecto consiste en una aplicación de consola, una ventana de consola se abre para recibir y mostrar texto, y cuando termina la ejecución espera a que se pulse una tecla.
Tipos de errores
Cuando el compilador traduce un programa puede encontrar errores de sintaxis tanto en el programa
fuente como en otros archivos de código que utilice (archivos de cabecera en C/C++). Durante la primera
fase de compilación, el programador tiene la posibilidad de corregir los errores detectados con sólo
escribir correctamente la sintaxis del lenguaje que usa.
C/C++ trabaja con diferentes archivos (internos, externos y escritos por el programador), esto facilita la
aparición de otro tipo de errores relacionados con el vínculo de unos archivos con otros. También no
dejan de existir los errores producidos durante la ejecución de un programa, producto de errores de
análisis y diseño de algoritmos, los cuales tienen solución haciendo una revisión del código fuente en
base a un nuevo análisis.
Errores Lógicos: Estos errores tienen su origen en el diseño de algoritmos (un algoritmo mal
diseñado produce resultados inesperados). Generalmente son errores que no generarán problemas
al momento de la compilación, pero es probable que los resultados esperados de un problema no
sean los más satisfactorios. Muchas veces estos errores provocan otro tipo de errores.
Errores de Sintaxis: Son aquellos que violan las reglas de escritura de un lenguaje de programación.
Todo lenguaje tiene definidas una sintaxis y una semántica que deben cumplirse al momento de
escribir el código fuente.
Errores de Enlace: Los errores de enlace se producen cuando en un programa se hace referencia
a otros archivos que no existen, tienen otro nombre o no están incluidos como parte del programa
mismo. Generalmente se presentan cuando se trabaja modularmente.
Errores de Ejecución: Se producen durante la ejecución de un programa. Regularmente son errores
provocados por acceso a memoria no permitida, conflicto en los tipos de datos, división por cero,
entre otros. Estos errores se presentan como consecuencia de errores lógicos.
El Preprocesador
El preprocesamiento ocurre antes de que se compile un programa. Algunas acciones posibles son:
inclusión de otros archivos en el archivo bajo compilación, definición de constantes simbólicas y macros,
compilación condicional de código de programa y ejecución condicional de directivas de preprocesador.
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 26
El preprocesador es algo característico de C/C++, que no se suele encontrar en otros lenguajes de
programación. El preprocesador actúa sobre el programa fuente, antes de que empiece la compilación
propiamente dicha, para realizar ciertas operaciones. En general se encarga de modificar el código
fuente, según una serie de directivas. Estas se reconocen puesto que empiezan por # y no tienen que
terminar en ;, a diferencia de la mayoría de las instrucciones de C/C++. Todas las directivas del
preprocesador empiezan con el signo #, y antes de una directiva de preprocesador en una línea sólo
pueden aparecer espacios en blanco.
La directiva del preprocesador #include
La directiva #include hace que en lugar de la directiva se incluya una copia del archivo especificado. Las
dos formas de la directiva son:
#include <NombredeArchivo>
#include “NombredeArchivo”
La diferencia entre estas dos formas radica en la localización donde el preprocesador buscará el archivo
a incluirse. Si el nombre del fichero está encerrado entre comillas, el preprocesador buscará el archivo a
incluirse en el mismo directorio que el archivo que se está compilando. Este método se utiliza
normalmente para incluir archivos de cabecera definidos por el programador. Si el nombre del fichero
está encerrado en corchetes angulares (< y >) – que se utilizan para los archivos de cabecera estándar
de biblioteca – la búsqueda se llevará a cabo de forma independiente en directorios predesignados del
compilador.
La directiva #include se utiliza por lo general para incluir archivos de cabecera de biblioteca estándar
como stdio.h y stdlib.h. La directriz #include también se utiliza con programas formados de varios archivos
fuente que deben ser compilados juntos.
La directiva del preprocesador #define: constantes simbólicas
La directiva #define crea constantes simbólicas – constantes representadas con símbolos – y macros, es
decir operaciones definidas como símbolos. El formato de la directiva #define es:
#define identificador texto_de_ reemplazo
Cuando en un archivo aparece esta línea, todas las subsecuentes apariciones de identificador serán de
forma automática reemplazadas por texto_de_reemplazo, antes de la compilación del programa.
Ejemplo: #define PI 3.14159
La directiva del preprocesador #define: macros
Una macro es una operación definida en una directiva de preprocesador #define. Como en el caso de
las constantes simbólicas, antes de compilarse el programa, el macro identificador se reemplaza en él
mismo por el texto_de_reemplazo. Las macros pueden ser definidas con o sin argumentos. Una macro
sin argumentos se procesa como que fuera una constante simbólica. En una macro con argumentos, los
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 27
argumentos se sustituyen en el texto de reemplazo, y a continuación la macro de expande, es decir, en
el programa el texto de reemplazo reemplaza al identificador y a la lista de argumentos.
Ejemplo: #define PI 3.14
#define AREA_CIRCULO(x) PI*(x)*(x)
Ahora podemos usar la macro como si fuera función normal:
void main()
{
int a;
a = AREA_CIRCULO(3);
}
Durante la compilación la macro se expande a:
a = 3.14 * (3) * (3)
y obtenemos el resultado esperado.
Las macros nos permiten insertar código en el programa directamente, evitando la sobrecarga de invocar o llamar a una función, pero conservando la legibilidad del programa. Por otra parte permite realizar cálculos durante la compilación, en lugar de realizarlos durante la ejecución. Así, en el ejemplo anterior, el compilador le da directamente el valor adecuado a la variable “a”, en lugar de insertar instrucciones para que se evalúe cada vez que se use. Es importante no olvidar los PARÉNTESIS alrededor de los parámetros en la definición de la macro, de
lo contrario la expansión de parámetros puede ser incorrecta, por ejemplo:
#define AREA_CIRCULO(x) PI*x*x
void main()
{
int a,b;
a = AREA_CIRCULO(c + 3);
}
expande a:
a = 3.14 * c + 3 * c + 3 que, atendiendo la precedencia de operadores, es equivalente a
a = (3.14 * c) + (3 * c) + 3
en lugar de expandir a:
a = 3.14 * (c + 3) * (c + 3)
que es lo que debería hacer.
¿Que son Archivos de Cabecera? Los archivos de cabecera en C/C++ (extensión .h) contienen definiciones, tales como los tipos y nombres de variables externas, definiciones de estructuras, constantes, macros y prototipos de funciones.
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 28
Inclusión de Archivos de Cabecera C++, al igual que C, permite escribir programas que utilizan diversas librerías mediante la directiva #include. C++ soporta dos formatos de directiva #include. El procesador permite incluir el contenido de un archivo en el código fuente con:
#include <stdio.h>
#include <iostream.h>
#include “trabajador.h”
Estas tres líneas son sustituidas lógicamente por el contenido de los archivos de cabecera stdio.h, iostream.h y trabajador.h. Se dice entonces que se han incluido estos tres archivos. Los caracteres < > y “ “ sirven para indicar dónde se buscan los archivos de cabecera: <...> El archivo de cabecera se busca sólo en el directorio por omisión. (donde está instalado el
compilador).
“...” El archivo de cabecera se busca sucesivamente en:
1. El directorio actual (donde se crea el proyecto o programa), y si no se encuentra
ahí,
2. En los directorios generales de include (una carpeta con librerías estándar en el
compilador).
Se pueden especificar nombres de camino (rutas de archivo) relativos, por ejemplo
#include<sys\stat.h>
Indica al compilador que busque stat.h en el directorio sys, que es un subdirectorio de uno
de los directorios por omisión.
Depuración
La depuración en CodeBlocks no se produce cuando el programa se ejecuta normalmente, mediante
Ctrl+F10 ó F9. Para depurar un programa es necesario seleccionar la opción Debug >> start, o bien
pulsar F8, que lanza la depuración del programa desde el principio. Si se desea empezar a depurar desde
un punto determinado, o durante la depuración, hacer que el programa corra normalmente hasta una
determinada línea, se sitúa el cursor sobre esa línea y se selecciona Debug >> run to cursor, o se pulsa
F4. A la hora de depurar una aplicación, se utilizan principalmente las opciones Debug >> Step into (Shift
+ F7) y Debug >> next line (F7).
Mientras que la segunda va avanzando de línea en línea, y ejecutando a las funciones que sean llamadas
en cada una de manera transparente, la primera permite saltar de función en función, conjuntamente con
el flujo del programa.
Breakpoints Los puntos de ruptura (breakpoints), se utilizan para parar la ejecución cuando se está
depurando, y se pulsa F8 para que la ejecución continúe normalmente. Se marcan con un círculo rojo a
la izquierda de la línea, pulsando con el ratón entre la línea y el número de línea, o bien situándose en
esa línea y pulsando F5
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 29
Tipos de Datos en C/C++
Los lenguajes pueden clasificarse según la forma de comportarse con respecto a la evaluación de los
tipos de datos que maneja, de tal manera que podemos decir que un lenguaje es fuertemente tipado o
débilmente tipado. C/C++ es un lenguaje fuertemente tipado desde el punto de vista estático, es decir,
en tiempo de compilación puede advertirnos de cualquier inconsistencia o error al respecto de tomar un
tipo por otro o utilizarlo de forma inadecuada. Sin embargo, en tiempo de ejecución se comporta a veces
de forma muy permisiva (en realidad el programador puede terminar haciendo casi lo que le venga en
gana). La razón de que se haya puesto especial énfasis en la comprobación estática de tipos (en tiempo
de compilación) en lugar de la comprobación dinámica (en tiempo de ejecución), se debe a que en C/C++
todas las características de diseño han estado encaminadas a favor de lograr la máxima velocidad de
ejecución.
En C/C++ existen distintos tipos de datos, cada uno de los cuales se representa de forma diferente en la
memoria de la computadora, según la naturaleza y el tamaño designado. La Tabla de Datos muestra los
tipos de datos en C/C++ y los requerimientos de memoria. Estos requerimientos pueden variar de una
máquina a otra (según el procesador y el compilador mismo). La cantidad de memoria que utilizan los
datos determina el rango de valores que pueden soportar.
Tipos de datos básicos
Los tipos de datos básicos o fundamentales de C/C++ se caracterizan porque son integrales, no pueden
ser modificados, tanto sus propiedades como las operaciones que se pueden realizar con ellos están
predefinidos en el lenguaje. La literatura especializada también se suele referir a ellos diciendo que están
preconstruidos o intrínsecamente definidos en el lenguaje.
Los tipos básicos se pueden clasificar en tres grupos: Numéricos, Fraccionarios y Sin valor.
Grupo Nombre Descripción Rango de Valores Requeri-
miento de
Memoria
Numéricos
(Enteros)
int Cantidades enteras -2,147,483,648 a 2,147,483,647 4 bytes
char Caracteres 0 a 255 (valores de la tabla ASCII) 1 byte
bool
(No existe en C)
Valores lógicos False, True 1 byte
enum Enumeraciones Dominio de los int
Fraccionarios
float
Número en coma flotante
(número que incluye punto
decimal y/o exponente)
-3.4x10-38 a 3.4x1038
4 bytes
double
Número en coma flotante de
doble precisión (más cifras
significativas y mayor valor
en el exponente)
-1.7x10-308 a 1.7x10308
8 bytes
Sin Valor void Sin valor
Tabla de Datos A
Tipo Entero (int)
El especificador de tipo int, junto con sus variantes short y long en sus versiones signed y unsigned,
identifican a los enteros.
Sintaxis: [signed|unsigned] [short|long] <int> <identificador> ;
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 30
El especificador int se utiliza para definir un dato tipo número entero. Junto con sus variantes short y long
en sus versiones signed y unsigned, dan lugar a las combinaciones autorizadas que se indican en la
tabla, los sinónimos se deben a los valores que se suponen por defecto.
Especificadores de enteros (sinónimos en la misma línea)
int signed int
unsigned unsigned int
short short int signed short int
unsigned short unsigned short int
long long int signed long int
unsigned long unsigned log int
signed y unsigned solo pueden usarse con int, short y long.
Las palabras clave signed y unsigned, usadas aisladamente, significan signed int y unsigned int.
Con int solo pueden usarse long o short.
Las palabras clave long y short usadas aisladamente significan long int y short int.
Por una larga tradición de C, el especificador int podía omitirse en la mayoría de los casos, ya que se
suponía por defecto, además si no se indicaba otra cosa, se suponía también signed int. Sin embargo,
en C++ es necesario especificarlo siempre, ya que es un lenguaje que se preocupa más de la integridad
de los tipos utilizados (lo que puede prevenir muchos problemas).
int x signed int x
unsigned x unsigned int x
short x short signed int x
unsigned short x unsigned short int x
long x long signed int x
unsigned long x unsigned long int x
Tipo Tamaño bytes Rango
int 4 -2,147,483,648 a 2,147,483,647
signed short 2 -32767 a 32767
unsigned short 2 0 a 65535
Tipo Caracter (char)
El especificador char se utiliza para definir un dato tipo caracter. Se almacenan en 1 byte, es decir,
siempre ocurre que sizeof(char) = 1. Esta es la definición ANSI de byte en C/C++: la memoria requerida
para almacenar un carácter.
Sintaxis: [signed|unsigned] <char> <identificador>
Un char puede ser con signo (signed), sin signo (unsigned) o no especificado; por defecto se suponen
con signo. Los objetos declarados de tipo caracter pueden contener cualquiera de los caracteres de la
tabla ASCII; son valores que pueden asimilarse fácilmente a los enteros; de hecho se pueden realizar
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 31
con ellos operaciones aritméticas, el compilador los trata entonces como valores numéricos (0..255). En
estos casos puede pensarse en char como un número muy pequeño, por lo que pueden ser usados
libremente en expresiones aritméticas, lo que proporciona considerable flexibilidad en cierto tipo de
transformaciones con caracteres.
Ejemplos:
char letra; declara una variable tipo caracter
letra = 'a' ; asigna la letra 'a' a la variable letra
letra = 6; asigna el valor correspondiente a 6 en la tabla ASCII
El valor de letra en este caso puede utilizarse en operaciones matemáticas.
char s[10]; declara un vector de 10 caracteres (cadena de 10 caracteres)
s[1]= '5' ; asigna a la posición 1 de la cadena s el carácter '5'
Tipo Booleano (bool)
El estándar ISO/ANSI C++ ha introducido este nuevo tipo de dato para manejar directamente datos
lógicos verdadero o falso de un modo directo, sin recurrir al modelo que tiene en cuenta el valor cero
(falso) o distinto de cero (verdadero). La palabra clave bool declara un tipo especial de variable
(denominada booleana) que sólo puede tener dos valores: true y false. Por esta razón a estas variables
también se las denomina variables lógicas.
Sintaxis: <bool> <identificador>;
Evidentemente el tipo bool está especialmente adaptado para realizar comprobaciones lógicas. Por su
parte, las palabras clave false y true son literales que tienen valores predefinidos (podemos considerar
que son objetos de tipo booleano de valor constante predefinido). false tiene el valor falso
(numéricamente es cero), true tiene el valor cierto (numéricamente es uno o distinto de cero).
bool val = false; declara val como booleana y la inicializa en 0
val = true; ahora se cambia su valor a 1
val = 0; ahora val recibe el valor 0, es decir false
Tipo Flotante (float y double)
También llamados de coma flotante: son float y double. Sólo se permite un modificador adicional (long),
dando lugar a los long double, de forma que son en realidad tres tipos: float, double y long double.
Sintaxis: <float> <identificador>;
[long] <double> <identificador>;
Ejemplos:
float x = 3.14;
double y = 6.2e+006;
Tanto el especificador float como el double son palabras clave que definen un identificador como de tipo
numérico de coma flotante (fraccionario). La razón principal de usar float es economizar espacio o tiempo
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 32
cuando se almacenan grandes números en máquinas donde el uso de double es muy costoso en
términos de tiempo de computación. En ciertos casos los tipos float pueden ser promovidos a double de
forma automática por el compilador. El almacenamiento interno y rango de los tipos fraccionarios es
dependiente de la implementación, es decir, cada compilador C++ es libre de definirlos a su manera. El
Estándar solo establece para ellos las siguientes condiciones:
* El tipo double permitirá al menos tanta precisión como el float.
* El tipo long double permitirá al menos tanta precisión como el double.
* El rango de valores de float será un subconjunto del rango de los double.
* El rango de valores de double será un subconjunto del rango de los long double.
Es recomendable, para evitar problemas en algunos compiladores, establecer en el valor de una variable
fraccionaria la parte decimal, incluso cuando sea cero. float x; x=4.0;
Tipo Sin Valor (void)
void es palabra reservada, indicador de un tipo especial: ausencia de valor.
Sintaxis: <void> <identificador>;
Es importante señalar que void es tratado por el compilador como un tipo, es sintácticamente un tipo
fundamental del mismo modo que pueden serlo int, char, double, etc., aunque de tipo un poco
especial. El hecho de que signifique ausencia de valor no es inconveniente para que sea un tipo con
todas sus características; podríamos suponer que representa en el conjunto de los tipos de datos lo
mismo que el cero en el conjunto de los números.
int entero; // Ok. entero es int
char caracter; // Ok. caracter es char
void novalor; // Error! uso no permitido. (no pueden declararse variables de tipo void)
En cambio sí están permitidas con él otras expresiones propias de los tipos:
void* puntero; // Ok. puntero es un puntero a void
void func(); // Ok. El tipo devuelto por la función es void
void se usa de varias formas:
* Para indicar que una función no devuelve ningún valor o no acepta ningún parámetro. * Para crear punteros genéricos. * Para modelado de tipos.
Identificadores y Palabras Claves.
Los identificadores son nombres que se les da a varios elementos de un programa, como variables,
funciones, y array. Un identificador está formado por letras y dígitos, en cualquier orden, excepto el primer
carácter, que deber ser una letra. Se pueden utilizar mayúsculas y minúsculas no acentuadas, aunque
es costumbre utilizar minúsculas para la mayoría de identificadores. Ejemplo:
X y12 suma_1 _temperatura
nombres area porcentaje TABLA
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 33
Los siguientes nombres no son validos
4num “x” orden-no indicador error
Hay ciertas palabras reservadas, denominadas palabras clave, que tienen en C un significado predefinido
estándar. Las palabras clave solo se pueden utilizar para su propio propósito ya establecido; no se
pueden utilizar como identificadores definidos por el programador. Las palabras claves son:
auto
break
case
char
const
continue
default
do
doublé
else
enum
extern
float
for
goto
if
int
long
register
return
short
signed
sizeof
static
struct
switch
typedef
union
unsigned
void
volatile
while
Declaración de Variables y constantes
Variables.
Una variable es un identificador que se utiliza para representar cierto tipo de información dentro de una
determinada parte del programa. En su forma más sencilla, una variable contendrá un dato simple, esto
es una cantidad numérico o una constante de carácter. En algún punto del programa se le asignara a la
variable un determinado valor. Este valor se puede recuperar después en el programa con simplemente
hacer referencia al nombre de la variable.
A una variable se le pueden asignar diferentes valores en distintas partes del programa, de esta forma la
información representada por la variable puede cambiar durante la ejecución del programa. Sin embargo
el tipo de dato asociado a la variable no puede cambiar.
Ejemplo: un programa en c contiene las siguientes líneas:
Int a, b, c; Char d; ... a=3; b=5; c=a+b; d=’a’; …
a=4; b =2 c=a-b; d=’W’’ …
Constantes.
C tiene cuatro tipos de básicos de constantes: constantes enteras, constantes de coma flotante, constantes de carácter y constantes de cadena de caracteres (hay también constantes enumeradas).
Las constantes enteras y de coma flotantes representan números. Se las denomina, en general constantes de tipo numérico. Las siguientes reglas se pueden aplicar a todas las constantes numéricas. 1. No se pueden incluir comas ni espacios en blanco en la constante. 2. Si se desea, la constante puede ir precedida de una signo menos (-). 3. El valor de una constante no puede exceder un límite máximo y un mínimo especifico. 4. Si la constante tiene dos o más dígitos el primero de ellos deber distinto de cero.
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 37
Ejemplos de constantes enteras.
0 1 743 5280 32767 9999 Las siguientes constantes están escritas incorrectamente. 12,245 carácter ilegal (,) 36.0 carácter ilegal (.) 10 20 30 carácter ilegal (espacio en blanco) 123-45-6789 carácter ilegal (-) 0900 el primer digito no puede ser cero
Constantes de Carácter: una constante de carácter consta de cualquier número de caracteres consecutivos o ninguno encerrados entre comillas (“”)Ejemplos
“verde” “$19.95” “ “ “Nicaragua” “Granada, Nicaragua” “” “Línea 1 \n línea 2”
Representación de Datos en memoria y tamaño de Variables
Existen en C/C++ distintos tipo de datos, cada uno de los cuales se puede encontrar representado de forma diferente en la memoria de la computadora.
Tipo de datos Descripción Requerimiento típico de memoria
int Cantidad entera. 2 byte o un palabra char Carácter. 1 byte float Numero con coma flotante(un número que
incluye punto decimal y/o exponente( 1 palabra – 4 byte
double Numero de coma flotante de doble precisión (mas cifras significativas y mayor valor posible del exponente)
2 palabras – 8 byte
Datos definidos por el programador
En un programa se pueden usar los distintos tipos de datos predefinidos por el lenguaje de programación en el que esté escrito. Además, algunos lenguajes de programación también permiten que el programador pueda definir sus propios tipos de datos
El programador tiene la posibilidad de definir ( declarar ) sus propios tipos de datos. Los tipos de datos simples que puede definir el programador son:
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 38
Operador typedef
La característica typedef permite a los usuarios definir nuevos tipos de datos que sean equivalentes
a los tipos de datos existentes. Una vez que el tipo de datos definido por el usuario ha sido
establecido, entonces las nuevas variables, arrays, estructuras, etc., pueden ser declaradas en
términos de este nuevo tipo de datos.
En términos generales, un nuevo tipo de datos se define como typedef tipo nuevo-tipo;
donde tipo refiere un tipo de datos existente (bien un tipo de datos estándar o bien un tipo de datos
previamente definido por el usuario) y nuevo-tipo el nuevo tipo de datos definido por el usuario.
Sin embargo, debe quedar claro que el nuevo tipo será nuevo solo en el nombre. En realidad, este
nuevo tipo de datos no será fundamentalmente diferente de los tipos de datos estándar
Aquí tenemos una declaración simple que involucra el uso de typedef.
typedef int edad;
En esta declaración edad es un tipo de datos definido por el usuario equivalente al tipo int. De aqui, la declaración de variable
edad varon, hembra; es equivalente a escribir int varon , hembra;
En otras palabras, varón y hembra se consideran variables de tipo edad, pero son realmente variables de tipo entero.
Arreglos
Un arreglos es una colección, o grupo de datos, donde cada dato tiene su posición (primero, segundo,
tercero…) y todos los datos del grupo son del mismo tipo , es decir, o todos son enteros, o todos son
reales, etc.
En otras palabras, es un conjunto de datos que se almacenan en memoria de manera seguida con el
mismo nombre. Es una colección de variables del mismo tipo, cada una de ellas se llama elemento y
posee una posición dentro del arreglo llamado índice.
Un arreglo tiene
Tamaño: el número de datos.
Tipo: cuál es el tipo de todos los datos del
arreglo.
Nombre: el único nombre bajo el cual
vamos a dirigirnos al mismo.
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 39
Operaciones con Arreglos
Para acceder al elemento de un arreglo es necesario tener presente el índice, este se escribe entre
paréntesis cuadrados ([ ]), por ejemplo para el arreglo A y la posición 5 se escribe A[5].
Al declarar una variable cualquiera siempre indicamos: tipo y nombre. Por ejemplo:
int a; Para declarar un arreglo, se debe indicar Tipo Nombre y Tamaño Un arreglo de 10 elementos enteros, se declara:
int ArregloEnteros[10];
y lo podemos visualizar: Cada elemento del grupo va a estar identificado por un valor numérico, llamado
índice En C el primer elemento de un arreglo tiene el índice 0.
Usamos el nombre del arreglo y el índice que identifica al elemento:
nombre_arreglo[indice]
Si se desea asignar el valor de 2 al primer elemento del arreglo:
arregloEntero[0] = 2;
arregloEntero[1] = 9;
arregloEntero[4] = 1;
Cada elemento es en efecto una variable del tipo declarado para el arreglo.
Leer o imprimir datos en el arreglo
Si tenemos 10 elementos en un arreglo, y queremos pedir que los ingresen por teclado, debemos repetir
el ingreso 10 veces, utilizando la sentencia For, la cual abordaremos más adelante:
Así mismo, para imprimir todos los elementos de un arreglo, deberíamos repetir el proceso de imprimir,
pero diez veces:
Un arreglo en C/C++ también se puede inicializar de las siguientes formas:
Crear un arreglo de 3 elementos Inicializando cada elemento: int A[]={11,2,8}; ó int A[3]={11,2,8};
Inicializando todos los elementos con el mismo valor: int A[3]={0};
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 40
Estructuras (struct)
Hemos visto anteriormente el tipo de dato compuesto Arreglos definido como una colección
de elementos del mismo tipo.
En algunos casos nos puede interesar trabajar con colecciones de elementos de distinto tipo:
Una estructura es una colección de uno o más elementos, cada uno de los cuales puede ser de un tipo
de dato diferente. Cada elemento de la estructura se denomina miembro.
Una estructura puede contener un número ilimitado de miembros. A las estructuras también se las llama
registros.
Sintaxis:
Ejemplo:
Podemos crear una estructura llamada disco que contiene 4 miembros: título del disco, número de
canciones, precio y fecha de compra.
Elementos de tipo cadena
Elementos de tipo entero
Estructura
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 41
Para definir el tipo de dato disco como una estructura con 4 miembros
Una vez definido el tipo de dato estructura, necesitamos declarar variables de ese tipo.
Existen dos formas diferentes:
1. En la definición del tipo de datos estructura
2. Como el resto de las variables. Indicando el tipo (en este caso el nombre de la estructura)
y el nombre de la variable.
Los miembros de cada variable se almacenan en posiciones consecutivas en memoria.
Inicializar una Estructura
Se especifican los valores de cada uno de los miembros entre llaves y separados por comas.
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 42
Acceso a los miembros de una variable de tipo estructura
Una vez que hemos declarado una variable de tipo estructura, podemos acceder a los miembros de dicha
variable:
Nos puede interesar modificar la información de alguno de los miembros, recuperar información para
imprimirla por pantalla, etc.
El acceso a los miembros de la estructura se realiza utilizando el operador punto (.)
variable.miembro
Ejemplo: cd.titulo , cd.precio , cd.num_canciones
Se puede asignar una estructura a otra de la siguiente manera:
Almacenar información en la variable cd mediante el teclado.
Recuperar y modificar información de la variable cd
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 43
Construcción de expresiones en el lenguaje: aritméticas y lógicas.
Expresiones y Sentencias en C/C++
Una expresión es una combinación de variables y/o constantes, y operadores. La expresión es
equivalente al resultado que proporciona al aplicar sus operadores a sus operandos. Por ejemplo, 1+5
es una expresión formada por dos operandos (1 y 5) y un operador (el +); esta expresión es equivalente
al valor 6, lo cual quiere decir que ahí donde esta la expresión aparece en el programa, en el momento
de la ejecución es evaluada y sustituida por su resultado. Una expresión puede estar formada por otras
expresiones más sencillas, y puede contener paréntesis de varios niveles agrupando distintos términos.
En C/C++ existen distintos tipos de expresiones.
Expresiones Aritméticas
Están formadas por variables y/o constantes, y distintos operadores aritméticos e incrementales (+, -, *,
/, %, ++, --). También se pueden emplear paréntesis de tantos niveles como se desee, y su interpretación
sigue las normas aritméticas convencionales. Por ejemplo, la solución de la ecuación de segundo grado:
se escribe, en C/C++ en la forma: x=(-b+sqrt((b*b)-(4*a*c)))/(2*a);
donde, estrictamente hablando, sólo lo que está a la derecha del operador de asignación (=) es una
expresión aritmética. El conjunto de variables que está a la izquierda del signo (=), el operador de
asignación, la expresión aritmética y el carácter (;) constituyen una sentencia. En la expresión anterior
aparece la llamada a la función de librería sqrt(), que tiene como valor de retorno la raíz cuadrada de
su único argumento. En las expresiones se pueden introducir espacios en blanco entre operandos y
operadores; por ejemplo, la expresión anterior se puede escribir también de la forma:
x = (-b + sqrt((b * b) - (4 * a * c)))/(2 * a);
Expresiones Lógicas
Los elementos con los que se forman estas expresiones son valores lógicos; verdadero (true,
o distintos de 0) y falso (false, o iguales a 0), y los operadores lógicos ||, && y !. También
se pueden emplear los operadores relacionales (<, >, <=, >=, ==, !=) para producir
estos valores lógicos a partir de valores numéricos. Estas expresiones equivalen siempre a un
valor 1 (true) o a un valor 0 (false). Por ejemplo:
a = ((b>c)&&(c>d))||((c==e)||(e==b));
donde de nuevo la expresión lógica es lo que está entre el operador de asignación (=) y el (;). La variable
a valdrá 1 si b es mayor que c y c mayor que d, ó si c es igual a e ó e es igual a b.
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 44
Expresiones Generales
Una de las características más importantes (y en ocasiones más difíciles de manejar) del C/C++ es su
flexibilidad para combinar expresiones y operadores de distintos tipos en una expresión que se podría
llamar general, aunque es una expresión absolutamente ordinaria de C/C++.
El resultado de una expresión lógica es siempre un valor numérico (un 1 ó un 0); esto permite que
cualquier expresión lógica pueda aparecer como sub-expresión en una expresión aritmética.
Recíprocamente, cualquier valor numérico puede ser considerado como un valor lógico: true si es distinto
de 0 y false si es igual a 0. Esto permite introducir cualquier expresión aritmética como sub-expresión de
una expresión lógica. Por ejemplo:
(a - b*2.0) && (c != d)
A su vez, el operador de asignación (=), además de introducir un nuevo valor en la variable que figura a
su izquierda, deja también este valor disponible para ser utilizado en una expresión más general. Por
ejemplo, supóngase el siguiente código que inicializa a 1 las tres variables a, b y c:
a = b = c = 1; que equivale a: a = (b = (c = 1));
Sentencias
Las expresiones de C/C++ son unidades o componentes elementales de unas entidades de rango
superior que son las sentencias. Las sentencias son unidades completas, ejecutables en sí mismas. Ya
se verá que muchos tipos de sentencias incorporan expresiones aritméticas, lógicas o generales como
componentes de dichas sentencias.
Sentencias Simples
Una sentencia simple es una expresión de algún tipo terminada con un carácter (;). Un caso típico son
las declaraciones o las sentencias aritméticas. Por ejemplo:
float real;
espacio = espacio_inicial + velocidad * tiempo;
Sentencia Vacía Ó Nula
En algunas ocasiones es necesario introducir en el programa una sentencia que ocupe un lugar, pero
que no realice ninguna tarea. A esta sentencia se le denomina sentencia vacía y consta de un simple
carácter (;).
Por ejemplo: ;
Sentencias Compuestas o Bloques
Muchas veces es necesario poner varias sentencias en un lugar del programa donde debería haber una
sola. Esto se realiza por medio de sentencias compuestas. Una sentencia compuesta es un conjunto
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 45
de declaraciones y de sentencias agrupadas dentro de llaves {...}. También se conocen con el nombre
de sentencias de bloque. Una sentencia compuesta puede incluir otras sentencias, simples y
compuestas. Un ejemplo de sentencia compuesta es el siguiente:
{
int i = 1, j = 3, k;
double masa;
masa = 3.0;
k = y + j;
}
Generalmente se usan para indicar que se ejecute un conjunto de sentencias como un solo bloque, es
decir cuando el compilador encuentra el símbolo de apertura { inicia a ejecutar todas las sentencias hasta
llegar al símbolo de cerradura }.
Ejemplo:
if (x>0) if (x>0)
x--; {
cout<<x<<endl; x--;
cout<<x<<endl;
}
La sentencia de bloque encierra varias sentencias entre llaves para expresar un conjunto lógico de
operaciones.
Control del Flujo de Ejecución
En principio, las sentencias de un programa en C/C++ se ejecutan secuencialmente, esto es, cada una
a continuación de la anterior empezando por la primera y acabando por la última. El lenguaje C/C++
dispone de varias sentencias para modificar este flujo secuencial de la ejecución. Las más utilizadas se
agrupan en tres familias: las bifurcaciones, que permiten elegir entre dos o más opciones según ciertas
condiciones, los bucles, que permiten ejecutar repetidamente un conjunto de instrucciones tantas veces
como se desee, cambiando o actualizando ciertos valores y los saltos, que proporcionan mecanismos
para interrumpir, alterar o modificar el orden de ejecución de los programas.
Estas instrucciones indican que si x es
mayor que cero, x se decrementa.
Luego se imprime.
Estas instrucciones indican que si x es
mayor que cero, x se decrementa y
se imprime.
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 46
Bifurcaciones
OPERADOR CONDICIONAL
El operador condicional es un operador con tres operandos (ternario) que tiene la siguiente forma
general:
expresion_1 ? expresion_2 : expresion_3;
Se evalúa expresion_1. Si el resultado de dicha evaluación es true (#0), se ejecuta expresion_2; si el
resultado es false (=0), se ejecuta expresion_3.
SENTENCIA IF
Esta sentencia de control permite ejecutar o no una sentencia simple o compuesta según se cumpla o no una determinada condición. Esta sentencia tiene la siguiente forma general:
if (expresion)
sentencia;
Se evalúa expresion. Si el resultado es true (#0), se ejecuta sentencia; si el resultado es false (=0), se
salta sentencia y se prosigue en la línea siguiente. Hay que recordar que sentencia puede ser una
sentencia simple o compuesta (bloque { ... }).
SENTENCIA IF ... ELSE
Esta sentencia permite realizar una bifurcación, ejecutando una parte u otra del programa según se
cumpla o no una cierta condición. La forma general es la siguiente:
if (expresion)
sentencia_1;
else
sentencia_2;
Se evalúa expresion. Si el resultado es true (#0), se ejecuta sentencia_1 y se prosigue en la línea
siguiente a sentencia_2; si el resultado es false (=0), se salta sentencia_1, se ejecuta sentencia_2 y
se prosigue en la línea siguiente. Hay que indicar aquí también que sentencia_1 y sentencia_2 pueden
ser sentencias simples o compuestas (bloques { ... }).
SENTENCIA IF ... ELSE MÚLTIPLE
Esta sentencia permite realizar una ramificación múltiple, ejecutando una entre varias partes del
programa según se cumpla una entre n condiciones. La forma general es la siguiente:
if(expresion_1)
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 47
sentencia_1;
else
if(expresion_2)
sentencia_2;
else
if(expresion_3)
sentencia_3;
else
if(...)
...
else
sentencia_n;
Se evalúa expresion_1. Si el resultado es true, se ejecuta sentencia_1. Si el resultado es false, se salta
sentencia_1 y se evalúa expresion_2. Si el resultado es true se ejecuta sentencia_2, mientras que si
es false se evalúa expresion_3 y así sucesivamente. Si ninguna de las expresiones o condiciones es
true se ejecuta expresion_n que es la opción por defecto (puede ser la sentencia vacía, y en ese caso
puede eliminarse junto con la palabra else). Todas las sentencias pueden ser simples o compuestas.
SENTENCIA SWITCH
La sentencia que se va a describir a continuación desarrolla una función similar a la de la sentencia if ...
else con múltiples ramificaciones, aunque como se puede ver presenta también importantes diferencias.
La forma general de la sentencia switch es la siguiente:
switch(expresion)
{
case expresion_cte_1: sentencia_1;
case expresion_cte_2: sentencia_2;
...
case expresion_cte_n: sentencia_n;
default : sentencia;
}
Se evalúa expresion y se considera el resultado de dicha evaluación. Si dicho resultado coincide con el
valor constante expresion_cte_1, se ejecuta sentencia_1 seguida de sentencia_2, sentencia_3, ...,
sentencia. Si el resultado coincide con el valor constante expresion_cte_2, se ejecuta sentencia_2
seguida de sentencia_3, ..., sentencia. En general, se ejecutan todas aquellas sentencias que están a
continuación de la expresion_cte cuyo valor coincide con el resultado calculado al principio
Si ninguna expresion_cte coincide se ejecuta la sentencia que está a continuación de default. Si se
desea ejecutar únicamente una sentencia_i (y no todo un conjunto de ellas), basta poner una sentencia
break a continuación (en algunos casos puede utilizarse la sentencia return o la función exit()). El efecto
de la sentencia break es dar por terminada la ejecución de la sentencia switch. Existe también la
posibilidad de ejecutar la misma sentencia_i para varios valores del resultado de expresion, poniendo
varios case expresion_cte seguidos.
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 48
El siguiente ejemplo muestra las posibilidades citadas:
switch(expresion)
{
case expresion_cte_1: sentencia_1;
break;
case expresion_cte_2:
case expresion_cte_3: sentencia_2;
break;
default : sentencia_3;
}
SENTENCIAS IF ANIDADAS
Una sentencia if puede incluir otros if dentro de la parte correspondiente a su sentencia, A estas
sentencias se les llama sentencias anidadas (una dentro de otra), por ejemplo,
if(a >= b)
if(b != 0.0)
c = a/b;
En ocasiones pueden aparecer dificultades de interpretación con sentencias if...else anidadas, como
en el caso siguiente:
if(a >= b)
if(b != 0.0)
c = a/b;
else
c = 0.0;
En principio se podría plantear la duda de a cuál de los dos if corresponde la parte else del programa.
Los espacios en blanco –las indentaciones de las líneas– parecen indicar que la sentencia que sigue a
else corresponde al segundo de los if, y así es en realidad, pues la regla es que el else pertenece al if
más cercano. Sin embargo, no se olvide que el compilador de C/C++ no considera los espacios en blanco
(aunque sea muy conveniente introducirlos para hacer más claro y legible el programa), y que si se
quisiera que el else perteneciera al primero de los if no bastaría cambiar los espacios en blanco, sino
que habría que utilizar llaves, en la forma:
if(a >= b)
{
if(b != 0.0)
c = a/b;
}
else
c = 0.0;
Todas las sentencias if e if...else, equivalen a una única sentencia por la posición que ocupan en el
programa.
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 49
Bucles
Además de bifurcaciones, en el lenguaje C/C++ existen también varias sentencias que permiten repetir
una serie de veces la ejecución de unas líneas de código. Esta repetición se realiza, bien un número
determinado de veces o bien hasta que se cumpla una determinada condición de tipo lógico o aritmético.
De modo genérico, a estas sentencias se les denomina bucles o ciclos. Las tres construcciones del
lenguaje C/C++ para realizar bucles son el while, el for y el do...while.
SENTENCIA WHILE
Esta sentencia permite ejecutar repetidamente, mientras se cumpla una determinada condición, una
sentencia o bloque de sentencias. La forma general es como sigue:
While( expresion_de_control)
sentencia;
Se evalúa expresion_de_control y si el resultado es false se salta sentencia y se prosigue la ejecución.
Si el resultado es true se ejecuta sentencia y se vuelve a evaluar expresion_de_control
(evidentemente alguna variable de las que intervienen en expresion_de_control habrá tenido que ser
modificada, pues si no el bucle continuaría indefinidamente). La ejecución de sentencia prosigue hasta
que expresion_de_control se hace false, en cuyo caso la ejecución continúa en la línea siguiente a
sentencia. En otras palabras, sentencia se ejecuta repetidamente mientras expresion_de_control sea
true, y se deja de ejecutar cuando expresion_de_control se hace false.
Obsérvese que en este caso el control para decidir si se sale o no del bucle está antes de sentencia,
por lo que es posible que sentencia no se llegue a ejecutar ni una sola vez.
Sintaxis: while (expresión) while (expresión)
sentencia; {
sentencia1;
sentencia2;
sentenciaN;
}
SENTENCIA FOR
For es quizás el tipo de bucle más versátil y utilizado del lenguaje C/C++. Su forma general es la
siguiente:
for(inicializacion; expresion_de_control; actualizacion)
sentencia;
Posiblemente la forma más sencilla de explicar la sentencia for sea utilizando la construcción while que
sería equivalente. Dicha construcción es la siguiente:
inicializacion;
while(expresion_de_control)
{
sentencia;
actualizacion; }
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 50
donde sentencia puede ser una única sentencia terminada con (;), otra sentencia de control ocupando
varias líneas (if, while, for, ...), o una sentencia compuesta o un bloque encerrado entre llaves {...}. Antes
de iniciarse el bucle se ejecuta inicializacion, que es una o más sentencias que asignan valores iniciales
a ciertas variables o contadores. A continuación se evalúa expresion_de_control y si es false se
prosigue en la sentencia siguiente a la construcción for; si es true se ejecutan sentencia y
actualizacion, y se vuelve a evaluar expresion_de_control. El proceso prosigue hasta que
expresion_de_control sea false. La parte de actualizacion sirve para actualizar variables o
incrementar contadores.
Sintaxis:
for (expresión1; expresión2; expresión3)
sentencia;
for (expresión1; expresión2; expresión3)
{
sentencia1;
sentencia2;
sentenciaN;
}
int n=5;
for(pe =0.0, i=1; i<=n; i++)
{
pe += i*2;
}
Primeramente se inicializa la variable pe a cero y la variable i a 1; el ciclo se repetirá mientras que i sea
menor o igual que n, y al final de cada ciclo el valor de i se incrementará en una unidad. En total, el bucle
se repetirá n veces. La ventaja de la construcción for sobre la construcción while equivalente está en
que en la cabecera de la construcción for se tiene toda la información sobre como se inicializan, controlan
y actualizan las variables del bucle. Obsérvese que la inicializacion consta de dos sentencias separadas
por el operador (,).
Biblioteca de funciones para C/C++.
Principales Librerías en C/C++
C/C++ es un lenguaje completo en sí mismo, las librerías ANSI que se incluyen con todos los compiladores están escritas en C o en ensamblador, y por lo tanto no son "imprescindibles" para escribir programas en C.
A continuación se detallan algunas de las principales librerías de C/C++ y sus funciones
principales, el fin de presentarlas en este documento no es memorizarlas, sino conocerlas y
utilizarlas de acuerdo a lo que necesitamos. No obstante recomiendo que las lean y señalen las
más importantes, les aseguro que muchas de estas funciones les pueden facilitar la vida al
momento de crear programas y en el desarrollo de sus proyectos.
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 53
<math.h>
Contiene la declaración de algunas funciones para realizar operaciones matemáticas comunes
sobre valores de tipo "double".
acos
double acos (double x);
Angulo cuyo coseno es "x", en el rango [0,p] radianes.
asin
double asin (double x);
Angulo cuyo seno es "x", en el rango [-p/2, +p/2] radianes.
atan
double atan (double x);
Angulo cuya tangente es "x", en el rango [-p/2, +p/2] radianes.
atan2
double atan2 (double y, double x);
Angulo cuya tangente es "y/x", en el rango [-p, +p] radianes.
ceil
double ceil (double x);
Valor entero más pequeño no menor que "x".
cos
double cos (double x);
Coseno de "x" (en radianes).
cosh
double cosh (double x);
Coseno hiperbólico de "x".
exp
double exp (double x);
Exponencial de "x", ex.
fabs
double fabs (double x);
Valor absoluto de "x", "|x|".
floor
double floor (double x);
Mayor valor entero menor que "x".
ldexp
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 54
double ldexp (double x, int exponente);
Devuelve "x*2exponente".
log
double log (double x);
Devuelve el logaritmo natural de "x".
log10
double log10 (double x);
Devuelve el logaritmo en base 10 de "x".
pow
double pow (double x, double y);
Devuelve "x" elevado a la potencia "y".
sin
double sin (double x);
Devuelve el seno de "x" (en radianes).
sinh
double sinh (double x);
Devuelve el seno hiperbólico de "x".
sqrt
double sqrt (double x);
Devuelve la raíz cuadrada de "x".
tan
double tan (double x);
Devuelve la tangente de "x" (en radianes).
tanh
double tanh (double x);
Devuelve la tangente hiperbólica de "x".
fmod
double fmod (double x, double y)
Devuelve el residuo en punto flotante de x dividido entre y.
<stdio.h>
Incluye macros y funciones para realizar operaciones de entrada y salida sobre ficheros y flujos
de datos.
EOF
#define EOF <expresión constante entera -1>
Valor de retorno utilizado para señalar el fin de fichero.
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 55
NULL
#define NULL <0, 0L, o (void *)>
Constante de puntero nulo que es utilizable como una expresión de direccionamiento constante.
getchar
int getchar (void);
Lee un carácter de la terminal
gets
char *gets (char *s);
Lee caracteres por el flujo estándar de entrada ("stdin") y los almacena en el "array" que comienza
en "s" hasta que se almacena un carácter "NULL" o se active el indicador de error o el de fin de
fichero. Si almacena algún elemento, termina almacenando un carácter nulo. Devuelve "s" si
almacena algún carácter. Sustituye el carácter NULL por ‘\0’.
printf
int printf (const char *formato, ...);
Escribe texto formateado por el flujo "stdout", según las especificaciones de "formato" y la lista
de expresiones. Devuelve el número de caracteres escritos o un valor negativo en caso de error.
putchar
int puchar (int c);
Escribe el carácter c en pantalla.
puts
int puts (const char *s);
Escribe los caracteres de la cadena "s" por el flujo "stdout". Escribe un carácter "NL" en lugar de
nulo de terminación. Devuelve un valor no negativo. En caso de error, devuelve EOF.
scanf
int scanf (const char *formato, ...);
Lee texto por el flujo "stdin" y lo almacena según las especificaciones de "formato". Devuelve el
número de valores asignados o "EOF" si se produce error o se alcanza fin de fichero sin
producirse lectura.
fopen
FILE *fopen(const char *nombre_fichero, const char *modo);
Abre el fichero de nombre “nombre_fichero”, lo asocia con un flujo de datos y devuelve un
puntero al mismo. Si falla la llamada, devuelve un puntero nulo. Algunos de los caracteres
iniciales de “modo” son:
“r, para abrir un fichero de texto existente para su lectura.
“w”, para crear un fichero de texto o abrir y truncar uno existente, para su escritura.
“a”, para crear un fichero de texto o abrir uno existente, para su escritura. El indicador de
posición se coloca al final del fichero antes de cada escritura.
“r+”, para abrir un fichero de texto existente para su lectura y escritura.
fclose
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 56
int fclose(FILE *flujo);
Cierra el fichero asociado con ``flujo''. Devuelve 0 en caso de éxito y EOF (end of file) en caso
contrario.
fwrite
size_t fwrite(const void *buffer, size_t n, size_t c, FILE *flujo);
La rutina fwrite permite escribir c elementos de longitud n bytes almacenados en el buffer
apuntado por “flujo”.
fread
size_t fread(const void *buffer, size_t n, size_t c, FILE *flujo);
La rutina fread permite leer c elementos de longitud n bytes del fichero apuntado por “flujo” y
los almacena en el buffer especificado.
fgetc
int fgetc(FILE *flujo);
Lee el siguiente carácter por “flujo”, avanza el indicador de posición y devuelve int. Devuelve
EOF si pone a 1 el indicador de fin de fichero o el de error.
fgets
char *fgets(char *s, int n, FILE *flujo);
Lee caracteres por “flujo” y los almacena en elementos sucesivos del “array” que comienza en
“s”, continuando hasta que almacene “n-1” caracteres, almacene un carácter de nueva línea o
ponga a 1 los indicadores de error o de fin de fichero. Si almacena un carácter, concluye
almacenando un carácter nulo en el siguiente elemento del “array”. Devuelve “s” si almacena
algún carácter y no ha puesto a 1 el indicador de error; en caso contrario devuelve un puntero
nulo.
fputc
int fputc(int c, FILE *flujo);
Escribe el carácter c por “flujo”, avanza el indicador de posición del fichero y devuelve int c . En
caso de error devuelve EOF.
fputs
int fputs(const char *s, FILE *flujo);
Escribe los caracteres de la cadena s por “flujo”. No escribe el carácter nulo de terminación. En
caso de éxito, devuelve un valor no negativo; en caso de error devuelve EOF.
fscanf
int fscanf(FILE *flujo, const char *formato, ...);
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 57
Lee texto y convierte a la representación interna según el formato especificado en formato.
Devuelve el número de entradas emparejadas y asignadas, o EOF si no se almacenan valores
antes de que se active el indicador de error o de fin de fichero.
fprintf
int fprintf(FILE *flujo, const char *formato, ...);
Genera texto formateado, bajo el control de formato “formato” y escribe los caracteres generados
por flujo. Devuelve el número de caracteres generados o un valor negativo en caso de error.
A modo de resumen estas son las especificaciones de formato más comunes para fprint y
fscanf:
Formato Descripción
%d Entero con signo
%u Entero sin signo
%c Caracter
%s Puntero a cadena de caracteres
fseek
int fseek( FILE *flujo, long desplazamiento, int origen);
La función fseek mueve el puntero de posición del fichero correspondiente al flujo de datos
apuntado por “flujo”. La nueva posición, medida en bytes, se obtiene añadiendo el número
indicado por desplazamiento a la posición especificada por origen. La variable origen puede
tomar tres valores:
SEEK_SET: El puntero de posición apuntará al inicio del fichero más el desplazamiento
SEEK_CUR: El puntero de posición apuntará a la posición actual del puntero de
posición del fichero más el desplazamiento.
SEEK_END: El puntero de posición apuntará al fin del fichero más el desplazamiento
(deberá ser menor o igual que cero).
rename
int rename(const char *viejo, const char *nuevo);
El nombre del fichero apuntado por la cadena viejo será conocido como el nombre apuntado por
la cadena nuevo. Cualquier intento posterior a abrir el fichero usando ese nombre fallará, al
menos que se cree de nuevo. Si el fichero nombrado por nuevo ya existe anteriormente a la
llamada de rename, el comportamiento de la función está definido según la implementación del
compilador.
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 58
La función retorna cero si la operación fue realizada con éxito. Si falla, entonces retorna un valor
cualquiera excepto cero; en este caso el fichero sigue siendo conocido con el nombre viejo.
clearerr
void clearerr(FILE *stream);
La función clearerr despeja los indicadores de final de fichero y de posición de fichero para el
stream apuntado por stream al comienzo del fichero.
feof
int feof(FILE *stream);
La función feof comprueba el indicador de final de fichero para el stream apuntado por stream.
La función feof retorna un valor distinto a cero si y sólo si el indicador de final de fichero está
activado para stream.
ferror
int ferror(FILE *stream);
La función ferror comprueba el indicador de errores para el stream apuntado por stream. La
función ferror retorna un valor distinto a cero si y sólo si el indicador de errores está activado
para stream.
fgetpos
int fgetpos(FILE *stream, fpos_t *posicion);
La función fgetpos guarda el valor actual del indicador de posición de ficheros para el stream
apuntado por stream en el objeto apuntado por posición. El valor guardado contiene información
no especificado servible a la función fsetpos para recolocar el stream a su posición cuando se
llamó a la función fgetpos.
fsetpos
int fsetpos(FILE *stream, const fpos_t *posicion);
La función fsetpos activa el indicador de posición de ficheros para el stream apuntado por
stream según el valor del objeto apuntado por posición, el cual será un valor obtenido de una
llamada previa a la función fgetpos del mismo stream.
remove
int remove(const char *nombre);
El nombre del fichero apuntado por la cadena nombre ya no es accesible por ese nombre.
Cualquier intento posterior a abrir el fichero usando ese nombre fallará, al menos que se cree de
nuevo. Si el fichero está abierto el comportamiento de la función está definido según la
implementación del compilador. Por esta razón se ha de cerrar antes de borrar.
La función retorna cero si la operación fue realizada con éxito. Si falla, entonces retorna un valor
cualquiera distinto a cero.
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 59
<stdlib.h>
Contiene las declaraciones de una colección de funciones de utilería generales y la definición de
tipos y macros para usarlas.
NULL
#define NULL <0, 0L, o (void *) >
Produce una constante de puntero nulo que es utilizable como una expresión de direccionamiento
constante.
RAND_MAX
#define RAND_MAX <expresión constante entera 32767>
Produce el máximo valor devuelto por "rand".
abort
void abort (void);
Llama a "raise(SIGABRT)" que produce la señal de abortar, lo que causa la terminación anormal
del programa informando al entorno operativo.
abs
int abs (int i);
Devuelve el valor absoluto de "i".
atof
double atof(const char *s);
Convierte los caracteres de la cadena s a la representación interna de tipo double y devuelve ese
valor.
atoi
int atoi (const char *s);
Convierte los caracteres de la cadena "s" a la representación interna de tipo "int" y devuelve ese
valor.
atol
long atol (const char *s);
Convierte los caracteres de la cadena "s" a la representación interna de tipo "long" y devuelve
ese valor.
rand
int rand(void);
Calcula un número pseudoaleatorio "x" basado en un valor inicial (semilla) almacenado en un
objeto de datos interno de duración estática, altera el valor almacenado y devuelve "x". El valor
devuelto está comprendido en el intervalo [0,RAND_MAX].
system
int system (const char *s);
Si "s" no es un puntero nulo, se pasa la cadena "s" para que sea ejecutada por el intérprete de
comandos del entorno operativo, y devuelve la información de estado proporcionada por el
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 60
intérprete. Si "s" es un puntero nulo, la función devuelve un valor distinto de cero. Si existe
intérprete de comandos en el entorno operativo, ejecuta el comando indicado. Esto incluye tanto
los comandos del sistema operativo, como cualquier programa que nosotros le indiquemos. Al
acabar la ejecución del comando, volverá a la línea de código situada a continuación de la
sentencia system.
En realidad system es una manera de implementar comandos del sistema desde el programa. Sintaxis: system(comando);
Por ejemplo: system("cls"); /* limpia la pantalla */
system("pause"); /* detiene la pantalla */
system("dir"); /* muestra el contenido del directorio especificado */
system("edit C:\archivo.txt"); /* abre el programa edit y muestra el contenido
de archivo.txt */
malloc
void *malloc(size_t longitud);
Asigna una dirección de memoria para un objeto de datos de tamaño longitud y devuelve esa
dirección.
calloc
void *calloc(size_t nelem, size_t longitud);
Asigna una localización en memoria a un objeto de datos array que contiene “nelem” elementos
de tamaño longitud, asignando ceros a todos los bytes del array y devuelve la dirección del primer
elemento en caso de éxito; en caso contrario, devuelve un puntero nulo.
realloc
void *realloc(void *p, size_t longitud);
Cambia el tamaño de la memoria apuntada por p al que se indica con longitud. Asigna una
dirección de memoria para un objeto de datos de tamaño longitud, copiando los valores
almacenados en p. Devuelve la nueva dirección de memoria asignada.
free
void free(void *p);
Si p no es un puntero nulo, la función libera la memoria asignada al objeto de datos cuya dirección
es p, en caso contrario, no hace nada. Se puede liberar la memoria asignada con calloc, malloc,
realloc.
exit
void exit(int status)
Termina la ejecución del programa y regresa status al entorno. Cuando el programa termina
normal el valor de status debe ser cero, se puede usar también los valores EXIT_SUCCESS y
EXIT_FAILURE.
<string.h>
Contiene la declaración de una colección de funciones útiles para manejar cadenas y otros arrays
de caracteres.
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 61
NULL
#define NULL <0, 0L, o (void *)>
Produce una constante de puntero nulo que es utilizable como una expresión de direccionamiento
constante.
strcat
char *strcat (char *s1, const char *s2);
Copia la cadena "s2", incluyendo el nulo de terminación, en elementos sucesivos del "array de
char" que almacena la cadena "s1", empezando en el elemento que almacena el nulo de
terminación de "s1". Devuelve "s1".
strchr
char *strchr (const char *s, int c);
Busca el primer elemento de la cadena "s" que sea igual a "(char)c". Considera el nulo de
terminación como parte de la cadena. En caso de éxito, devuelve la dirección del elemento
emparejado; en caso contrario, devuelve un puntero nulo.
strcmp
int strcmp (const char *s1, const char *s2);
Compara los elementos de dos cadenas "s1" y "s2" hasta que encuentra elementos diferentes. Si
todos son iguales, devuelve 0. Si el elemento diferente de "s1" es mayor que el de "s2", devuelve
un valor mayor que cero; en caso contrario, devuelve un valor menor que cero.
strcpy
char *strcpy (char *s1, const char *s2);
Copia la cadena "s2", incluyendo el nulo, en el "array de char" que comienza en "s1". Devuelve
"s1".
strcspn
size_t strcspn (const char *s1, const char *s2);
Busca el primer elemento "s1[i]" de la cadena "s1" que sea igual a cualquiera de los elementos
de la cadena "s2" y devuelve "i".
strlen
size_t strlen (const char *s);
Devuelve el número de caracteres de la cadena "s", sin incluir el nulo de terminación.
strncat
char *strncat (char *s1, const char *s2, size_t n);
Copia "n" elementos de la cadena "s2" en la cadena "s1" a partir de su nulo de terminación. Al
final pone el nulo de terminación y devuelve "s1".
strncmp
int strncmp (const char *s1, const char *s2, size_t n);
Compara los elementos de las cadenas "s1" y "s2" hasta que encuentra alguno diferente o hasta
que se han comparado "n" elementos. Si todos los elementos son iguales, devuelve 0. Si el
elemento diferente de "s1" es mayor que el de "s2" (tomados como "unsigned char"), devuelve
un número positivo. En caso contrario, devuelve un número negativo.
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 62
strncpy
char *strncpy (char *s1, const char *s2, size_t n);
Copia la cadena "s2", sin incluir el nulo, en la cadena "s1". Copia no más de "n" caracteres de
"s2". Entonces almacena, cero o más caracteres nulos si son necesarios para completar un total
de "n" caracteres. Devuelve "s1".
strpbrk
char *strpbrk (const char *s1, const char *s2);
Busca el primer elemento "s1[i]" en la cadena "s1" que sea igual a cualquiera de los elementos
de "s2". Si "s1[i]" no es el nulo de terminación, devuelve "&s1[i]"; en caso contrario, devuelve
un puntero nulo.
strrchr
char *strrchr (const char *s, int c);
Busca el último elemento de la cadena "s" que es igual a "(char)c". En caso de éxito, devuelve la
dirección de tal elemento; en caso contrario, devuelve un puntero nulo.
strspn
size_t strspn (const char *s1, const char *s2);
Busca el primer elemento "s1[i]" en la cadena "s1" que no sea igual a ninguno de los elementos
de "s2" y devuelve "i".
strstr
char *strstr (const char *s1, const char *s2);
Busca la primera secuencia de elementos en la cadena "s1" que se empareje con los elementos
de la cadena "s2", sin incluir su nulo. En caso de éxito, devuelve la dirección del primer elemento
emparejado; en caso contrario, devuelve un puntero nulo.
strdup
char *strdup(const char *s);
Devuelve un puntero a una nueva cadena de caracteres que es un duplicado de la cadena s. La
memoria para esta cadena de caracteres se obtiene con la función malloc y se libera con la función
free.
strndup
char *strndup(const char *s, size\_t n);
Devuelve un puntero a una nueva cadena de caracteres que es un duplicado de la cadena s, solo
copia los primeros n caracteres, incluyendo el nulo. La memoria para esta cadena de caracteres
se obtiene con la función malloc y se libera con la función free.
<Conio.h>
clrscr
void clrscr(void);
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 63
Limpia o borra la pantalla en modo texto y coloca el cursor en la esquina superior izquierda (en
la posición 1,1).
clreol
void clreol(void);
Borra desde la posición actual del cursor hasta el final de línea, sin mover el cursor.
delline
void delline(void);
Elimina todo el renglón actual de la posición del cursor, moviendo todo lo que esté abajo de él
un renglón hacia arriba. El cursor no se mueve.
insline
void insline(void);
Inserta una nueva línea en la posición actual del cursor, moviendo todo un renglón hacia abajo.
El cursor no se mueve. Se pierde la última línea.
gotoxy
void gotoxy(int x, int y);
Mueve el cursor a la posición dada por x,y (coordenada horizontal y vertical respectivamente).
Por default la pantalla es de 80 columnas por 25 renglones, donde la esquina superior izquierda
es la posición: (x=1,y=1), y la esquina inferior derecha la coordenada: (80,25).
wherex
wherey
int wherex(void);
int wherey(void);
Regresan la x-coordenada y la y-coordenada de la posición actual del cursor respectivamente.
Si la pantalla de texto tiene el tamaño por default de 80 columnas por 25 renglones, wherex()
regresa un número comprendido entre 1 y 80, y wherey() entre 1 y 25.
void textcolor(int nuevocolor);
Cambia el color del texto. Todos los caracteres que se muestren después de una llamada a esta
función aparecerán con dicho color en pantalla. El texto que fue mostrado antes llamar a esta
función conservará su color original. Los colores disponibles tanto para textcolor y
textbackground son los mismos que para su predecesores (de 0 a 15):
0 BLACK (negro)
1 BLUE (azul marino)
2 GREEN (verde perico)
3 CYAN (verde claro)
4 RED (rojo)
5 MAGENTA (morado o violeta)
6 BROWN (café)
7 LIGHTGRAY (gris claro)
8 DARKGRAY (gris oscuro)
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 64
9 LIGHTBLUE (azul marino claro)
10 LIGHTGREEN (verde claro)
11 LIGHTCYAN (azul claro)
12 LIGHTRED (rojo claro)
13 LIGHTMAGENTA (rosa mexicano)
14 YELLOW (amarillo)
15 WHITE (blanco)
textbackground
void textbackground(int nuevocolor);
Cambia el color de fondo del texto. Esta función cambia sólo el color de fondo de los caracteres.
Para cambiar el fondo a toda la pantalla hay que llamar a textbackground y luego a system(“cls”)
para borrar la pantalla y aparezca con el nuevo color. Para este propósito no usar clrscr() para
borrar la pantalla, pues no toma en cuenta el nuevo valor del color de fondo.
_setcursortype void _setcursortype(int tipo);
Cambia la apariencia del cursor de texto (no del mouse).
Coloca el tipo de cursor a uno de los siguientes:
_NORMALCURSOR (como caracter de subrayado)
_NOCURSOR (oculta el cursor)
_SOLIDCURSOR (cursor sólido)
<dos.h >
delay
void delay(int miliseg);
Pausa la ejecución del programa un determinado tiempo dado por su argumento en milisegundos.
(1 seg=1000 miliseg).
sleep
void sleep(int seg);
Pausa la ejecución del programa un determinado tiempo dado por su argumento en segundos.
<ctype.h>
tolower
int tolower(int ch);
Convierte un carácter a minúscula.
Valor de retorno: ch debe estar en el rango 0 a 255, y si está entre A y Z lo convierte a su
equivalente en el rango a - z, el resto de los valores no son modificados. El valor de retorno es el
valor convertido si ch era una mayúscula, o el valor original en caso contrario.
Nota: los caracteres en acentuados, o con diéresis, en mayúscula y la Ñ no sufren modificaciones.
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 65
toupper
int toupper(int ch);
Convierte un carácter, en un parámetro entero ch, a mayúscula.
Valor de retorno: ch debe estar en el rango 0 a 255, y si está entre a y z lo convierte a su
equivalente en el rango A - Z, el resto de los valores no son modificados. El valor de retorno es
el valor convertido si ch era una minúscula, o el valor original en caso contrario.
Nota: los caracteres en acentuados, o con diéresis, en minúscula y la ñ no sufren modificaciones.
isalnum
int isalnum(int c);
Comprueba sin un carácter es alfanumérico. Isalnum es una macro que verifica el entero c
pertenece al rango de letras (A - Z o a - z) o al de dígitos (0 - 9), por defecto.
Valor de retorno: El valor de retorno será no nulo si c es una letra o un número, y cero en caso
contrario.
isdigit
int isdigit(int c);
Comprueba sin un carácter es un dígito decimal. Isdigit es una macro que verifica si el entero c
pertenece al rango de cacteres de dígitos decimales, el rango es de ('0' - '9').
Valor de retorno: El valor de retorno será no nulo si c es un dígito decimal.
ispunct
int ispunct(int c);
Comprueba sin un carácter es correspondiente a un signo de puntuación. Ispunct es una macro
que verifica si el entero c pertenece al rango de caracteres de los signos de puntuación, que por
defecto son todos menos los alfanuméricos y el blanco ' '.
Valor de retorno: El valor de retorno será no nulo si c es un signo e puntuación.
isalpha
int isalpha(int c);
Comprueba sin un carácter es alfabético. Isalpha es una macro que verifica si el entero c pertenece
al rango de letras (A - Z o a - z), por defecto.
Valor de retorno: El valor de retorno será no nulo si c es una letra y cero en caso contrario.
islower
int islower(int c);
Comprueba sin un carácter es de tipo minúscula. Islower es una macro que verifica si el entero c
pertenece al rango de caracteres de letras minúsculas, que por defecto son los que están en el
rango a - z.
Valor de retorno: El valor de retorno será no nulo si c es un carácter en minúscula.
isupper
int isupper(int c);
Comprueba sin un carácter es de tipo mayúscula. Islower es una macro que verifica si el entero
c pertenece al rango de caracteres de letras mayúsculas, que por defecto son los que están en el
rango A - Z. Valor de retorno: El valor de retorno será no nulo si c es un carácter en mayúscula.
Análisis Numérico y Programación
Introducción al Lenguaje C/C++ 66
isspace
int isspace(int c);
Comprueba sin un carácter es de tipo espacio. Isspace es una macro que verifica si el entero c
pertenece al grupo de caracteres de espacio, ' ', tab, retorno de carro, nueva línea, tabulador
vertical o salto de página. Valor de retorno: El valor de retorno será no nulo si c es un carácter
de tipo espacio.
Referencias Bibliográficas Joyanes Aguilar L, & Zahonero Martínez I. (2001). Metodología de la Programación. En L.
Joyanes Aguilar & I. Zahonero Martínez, Programación en C. Metodología, algoritmos y estructura de datos (págs. 15-24). Madrid: McGrawHill.
Joyanes, L. (2003). Fundamentos de Programación. Madrid: McGrawHill.