Programación Lenguaje C

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


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



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 (++).



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



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



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.



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.



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



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



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.



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

( ).



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



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



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“;



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



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



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



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)



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



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




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 ¯




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 Í



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



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 =”



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.



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



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.



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



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



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



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



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



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.



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:



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.



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;



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};



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



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.



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



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.



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



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.



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)



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_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.



El siguiente ejemplo muestra las posibilidades citadas:

switch(expresion)

{


break;

case expresion_cte_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.



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; }



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.



<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



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.



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



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, ...);



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.



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.

http://c.conclase.net/librerias/funcion.php?fun=fsetpos

http://c.conclase.net/librerias/funcion.php?fun=fgetpos



<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



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.



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.



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);



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)



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.



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.



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.

Programación Lenguaje C

Documents

Transcript of Programación Lenguaje C