Unidad 2.

Introducción al Lenguaje
de Programación Actual de Uso en
Ing. Civil

Objetivos: Desarrollará un programa de computación en un lenguaje de

programación.

Ing. Jesús Aldana Reséndiz

 2.1 Estructura de un Programa.

Un programa en C se compone de una o más funciones. Una de ellas debe ser

obligatoriamente main.

Una función en C es un grupo de instrucciones para realizar una o más acciones.

Así mismo, un programa contendrá una serie de directivas #include que
permitirán incluir en el mismo archivo de cabecera, que a su vez constara de
funciones y datos predefinidos en ellos.
2.1 Estructura de un Programa.
2.1 Estructura de un Programa.
De modo más explícito, un programa C puede incluir:

Directivas de un preprocesador;
Declaraciones globales;
La función main( ) ; int main( ).
Funciones definidas por el usuario;
Comentarios del programa.

EJEMPLO:

/ * Programa de saludo * /

#include <stdio.h>
/* Este programa imprime: Bienvenidos a la programación en C */
int main ( )
{
printf (“Bienvenido a la programación en C \n”);
return 0;
}
2.1 Estructura de un Programa.
La directiva #include de la primera línea es necesaria para que el
programa tenga salida. Se refiere a un archivo externo denominado
stdio.h en el que se proporciona la información relativa a la función
printf ( ). Obsérvese que los ángulos < y > no son parte del
nombre del archivo; se utilizan para indicar que el archivo es un
archivo de la biblioteca estándar C.

La segunda línea es un comentario, identificado por los caracteres /*

y */. Los comentarios se incluyen en programas que proporcionan
explicaciones a los lectores de los mismos. Son ignorados por el
compilador.

La tercera línea contiene la cabecera de la función main(), obligatoria

en cada programa C. Indica el comienzo del programa y requiere los
paréntesis ( ) a continuación de main ().

La cuarta y séptima línea contienen solo las llaves { y } que

encierran el cuerpo de la función main( ) y son necesarias en todos
los programas C.
2.1 Estructura de un Programa.
La quinta línea contiene la sentencia

Printf (“bienvenido a la programación en C \n”);

que indica al sistema que escriba el mensaje “Bienvenido a la

programación en C \n”.

printf () es la función más utilizada para dar salida de datos por el

dispositivo estándar, la pantalla. La salida será

Bienvenido a la programación en C

El símbolo ‘\n’ es el símbolo de nueva línea. Poniendo este símbolo al

final de la cadena entre comillas, indica al sistema que comience una
nueva línea después de imprimir los caracteres precedentes,
terminando, por consiguiente, la línea actual.
2.1 Estructura de un Programa.

La sentencia return 0 termina la ejecución del programa y devuelve

el control al sistema operativo de la computadora. El número 0 se
utiliza para señalar que el programa ha terminado correctamente
(con éxito).

El punto y coma (;) es requerido por C cada vez que una sentencia
termine, no es necesario que este al final de una línea. Se pueden
poner varias sentencias en la misma y se puede hacer que una
sentencia se extienda sobre varias líneas.
2.1 Estructura de un Programa.

Directivas del procesador

El preprocesador en un programa C se puede considerar como un editor
de texto inteligente que consta de directivas (instrucciones al compilador
antes de que se compile el programa principal). Las dos directivas más
usuales son #include y #define.

Todas las directivas del preprocesador comienzan con el signo de libro o

“almohadilla” (#), que indica al compilador que lea las directivas antes de
compilar la parte (función) principal del programa.

Las directivas son instrucciones al compilador. Las directivas no son

sentencias ya que no terminan en punto y coma, sino instrucciones que
se dan al compilador antes de que el programa se compile.

La directiva #include indica al compilador que lea el archivo fuente que

viene a continuación de ella y su contenido lo inserte en la posición donde
se encuentra dicha directiva. Estos archivos se denominan “archivos de
cabecera” o “archivos de inclusión”.
2.1 Estructura de un Programa.
Los archivos de cabecera (archivos con extensión .h que contienen
código fuente C) se sitúan en un programa C mediante la directiva del
preprocesador #include con una instrucción que tiene el siguiente
formato:

a) #include <nombrearch.h> o bien

b) #include “nombrearch.h”

El archivo de cabecera más frecuente es stdio.h. Este archivo

proporciona al compilador C la información necesaria sobre las
funciones de biblioteca que realizan operaciones de entrada y salida.

El formato a) el nombre del archivo esta entre ángulos, significa que

de manera predeterminada los archivos se encuentran en el directorio
include.

El formato b) significa que el archivo está en el directorio actual. Si

desea utilizar un archivo de cabecera que se creó y no está de manera
predeterminada en el directorio, se encierra el archivo de cabecera y la
ruta entre comillas:
2.1 Estructura de un Programa.
Los archivos de cabecera (archivos con extensión .h que contienen
código fuente C) se sitúan en un programa C mediante la directiva del
preprocesador #include con una instrucción que tiene el siguiente
formato:

a) #include <nombrearch.h> o bien

b) #include “nombrearch.h”

El archivo de cabecera más frecuente es stdio.h. Este archivo

proporciona al compilador C la información necesaria sobre las
funciones de biblioteca que realizan operaciones de entrada y salida.

El formato a) el nombre del archivo esta entre ángulos, significa que

de manera predeterminada los archivos se encuentran en el directorio
include.

El formato b) significa que el archivo está en el directorio actual. Si

desea utilizar un archivo de cabecera que se creó y no está de manera
predeterminada en el directorio, se encierra el archivo de cabecera y la
ruta entre comillas:
2.1 Estructura de un Programa.
#include “D:\MIPROG\CABEZA.H”

La directiva #define indica al procesador que defina un ítem de dato u

operación para el programa C. Por ejemplo, la directiva

#define TAM_LINEA 65

Sustituirá TAM_LINEA por el valor 65 cada vez que aparezca en el

programa.
2.1 Estructura de un Programa.

Declaraciones globales
Las declaraciones globales indican al compilador que las funciones
definidas por el usuario o variables así declaradas son comunes a todas
las funciones de su programa. Las declaraciones globales se sitúan antes
de la función main(). Si se declara global una variable Grado_clase del
tipo

int Grado_clase;

Cualquier función de su programa, incluyendo main(), puede acceder a la

variable Grado_clase.
La zona de declaraciones globales de un programa puede incluir
declaraciones de variables, además de declaraciones de función. Las
declaraciones de función de denominan prototipos.

int media (int a, int b);

El siguiente programa es una estructura modelo que incluye declaraciones

globales.
2.1 Estructura de un Programa.
/* Programa demo.C */
#include<stdio.h>

/*Definición de macros */
#define MICONST1 0.50
#define MICONST2 1.75

/* Declaraciones globales */
int Calificaciones;

main ()

...

}
2.1 Estructura de un Programa.

Función main ()
Cada programa C tiene una función main() que es el punto de entrada al
programa. Su estructura es:

main()
{
... bloque de sentencias
}
Las sentencias incluidas entre las llaves {…} se denominan bloque. Un
programa debe tener sólo una función main(). Si se intenta hacer dos
funciones main() se produce un error. Además de la función main(), un
programa C consta de una colección de funciones.
Las variables y constantes globales se declaran y definen fuera de la
definición de las funciones, generalmente en la cabecera del programa,
antes de main(), mientras que las variables y constantes locales se
declaran y definen en la cabecera del cuerpo o bloque de la función
principal, o en la cabecera de cualquier bloque.
 2.1 Estructura de un Programa.
Las sentencias situadas en el interior del cuerpo de la función main(), o
cualquier otra función, deben terminar en punto y coma.

Funciones definidas por el usuario

Las funciones definidas por el usuario se invocan por su nombre y los
parámetros opcionales que puedan tener. Después de que la función es
llamada, el código asociado con la función se ejecuta y a continuación, se
retorna a la función llamadora.

Todas las funciones tienen nombre y reciben una lista de valores. Se puede
asignar cualquier nombre a su función, pero normalmente se procura que
dicho nombre describa el propósito de la función.

En C, las funciones requieren una declaración o prototipo en el programa:

void trazarcurva();
 2.1 Estructura de un Programa.
Una declaración de función indica al compilador el nombre de la función
por el que ésta será invocada en el programa. Si la función no se define, el
compilador informa de un error. La palabra reservada void significa que la
función no devuelve un valor.

void contarvocales (char carácter);

C proporciona también funciones predefinidas que se denominan funciones

de biblioteca, las cuales son funciones listas para ejecutar que vienen con
el lenguaje C. Requieren la inclusión del archivo de cabecera estándar, tal
como stdio.h, math.h, etc.

Existen centenares de funciones definidas en diversos archivos de

cabecera.
 2.1 Estructura de un Programa.
/* ejemplo funciones definidas por el usuario */

#include <stdio.h>
void visualizar ();

int main()
{

visualizar();
return 0;

void visualizar()

printf(“ Primeros pasos en C\n”);

}
 2.1 Estructura de un Programa.
Los principales archivos de cabecera estándar son:

conio.h Funciones de manejo de pantalla

ctype.h Funciones de manejo de caracteres (ANSI C)

dir.h Funciones de manejo de directorio

io.h Rutinas de E/S de tipo UNIX

math.h Funciones matemática (ANSI C)

stdio.h Funciones de E/S estándar

stdlib.h Declaraciones variadas y funciones de propósito general

(ANSI C)

string.h Funciones para trabajar con cadenas de caracteres (ANSI C)

time.h Funciones para manipular la hora y fecha del sistema (ANSI C)

 2.1 Estructura de un Programa.

Comentarios
Un comentario es cualquier información que se añade a su archivo fuente para
proporcionar documentación de cualquier tipo. El compilador ignora los
comentarios, no se realiza ninguna tarea concreta.

El uso de comentarios es totalmente opcional, aunque dicho uso es muy

recomendable.

La información que se suele incluir es el nombre del archivo, el nombre del

programador, una breve descripción, la fecha en que se creó la versión y la
información de la revisión.

Todo el texto situado entre las dos secuencias es un comentario ignorado por el
compilador.

/* PRUEBA1.C – Primer programa C */

 2.1 Estructura de un Programa.

Si necesitas varias líneas de programa se puede hacer lo siguiente:

/*
Programa : PRUEBA1.C
Programador : Pepe Mortimer
Descripción : Primer programa C
Fecha de creación : Agosto 2014
Revisión : Ninguna
*/

También se pueden situar comentarios de la forma siguiente:

scanf(“%d”,&x); /*sentencia de entrada de un valor entero */

 2.2 Constantes, Variables y Tipos de
Datos.
2.2.1 CONSTANTES
En C existen cuatro tipos de constantes:

1. Constantes literales: Son las literales más usuales; toman valores

tales como 45.32564, 222 o bien “Introduzca sus datos” que se escriben
directamente en el texto del programa.

2. Constantes definidas: Son identificadores que se asocian con valores

literales constantes y que toman determinados nombres.

3. Constantes enumeradas: Son como variables, sus valores se

almacenan en memoria, pero no se pueden modificar.

4. Constantes declaradas: Permiten asociar un identificador, tal como

Color, con una secuencia de otros nombres, tales como Azul, Verde,
Rojo y Amarillo.
 2.2 Constantes, Variables y Tipos de
Datos.
2.2.1.1 CONSTANTES LITERALES.
Las constantes literales o constantes, en general, se clasifican también en 4
grupos:

1. Constantes enteras.

2. Constantes reales.

3. Constantes caracteres.

4. Constantes de cadena.
 2.2 Constantes, Variables y Tipos de
Datos.
Constantes enteras.
Las constantes enteras requieren seguir unas determinadas reglas:

1. No utilizar nunca comas ni otros signos de puntuación en números enteros o

completos. 123456 en lugar de 123,456.

2. Para forzar un valor al tipo long, determinar con una letra L o l. Por ejemplo
1024 es un tipo entero, 1024L es un tipo largo (long).

3. Para forzar un valor al tipo unsigned, terminarlo con una letra mayúscula U.
Por ejemplo, 4352U.

4. Para representar un entero en octal (base 8), se debe estar precedido de 0.

Formato decimal 123

Formato octal 0777 (esta precedido de la cifra 0)
 2.2 Constantes, Variables y Tipos de
Datos.
5. Para representar un entero en hexadecimal (base 16), este debe estar
procedido de 0x.

Formato hexadecimal 0xFF3A (están precedidas de “0x” o bien “0X”)

Se pueden combinar sufijo L (l), que significa long (largo), o bien U (u),
significa unsigned (sin signo).

3456UL
 2.2 Constantes, Variables y Tipos de
Datos.

Constantes reales
Una constante flotante representa un número real; siempre tiene signo y
representan aproximaciones en lugar de valores exactos.

82.347 .63 83. 47e-4 1.25E7 61.e+4

La notación científica se representa con un exponente positivo o negativo.

2.5E4 equivale a 25000

5.435E-3 equivale a 0.005435

Existen 3 tipos de constantes:

float 4 bytes
double 8 bytes
long double 10 bytes (se puede cambiar según el compilador)
 2.2 Constantes, Variables y Tipos de
Datos.

Constantes caracteres
Una constante de carácter (char) es un carácter del código ASCII encerrado en
apóstrofos.

‘A’ ‘b’ ‘c’

Además de los caracteres ASCII estándar, una constante de carácter admite

caracteres especiales que no se pueden representar utilizando su teclado, como
por ejemplo, los códigos ASCII altos y las secuencias de escape.

Así, por ejemplo, el carácter sigma (Σ), código ASCII 228, hexadecimal E4, se
representa mediante el prefijo \x y el número hexadecimal del código ASCII. Por
ejemplo:

char sigma = ‘\xE4’;

 2.2 Constantes, Variables y Tipos de
Datos.
Este método se utiliza para almacenar o imprimir cualquier carácter de la tabla
ASCII por su número hexadecimal. En el ejemplo anterior, la variable sigma no
tiene cuatro caracteres sino únicamente el símbolo sigma.

Un carácter que se lee utilizando una barra oblicua (\) se llama secuencia o
código de escape. La siguiente tabla muestra algunas secuencias de escape y
su significado.
2.2 Constantes, Variables y Tipos de
Datos.
2.2 Constantes, Variables y Tipos de
Datos.
/* Programa: Pruebas código de escape */

#include<stdio.h>

int main ()

char alarma=’\a’; /* alarma */

char bs= ‘\b’; /* retroceso de espacio */

printf(“%c %c”,alarma,bs);

return 0;

}
 2.2 Constantes, Variables y Tipos de
Datos.
Aritmética con caracteres C

Dada la correspondencia entre un carácter y su código ASCII, es posible realizar

operaciones aritméticas sobre datos de caracteres. Por ejemplo:

char c;
c = ‘T’ + 5 /* suma 5 al carácter ASCII */

Realmente lo que sucede es almacenar Y en c. El valor ASCII de la letra T es 84,

y al sumarle 5 produce 89, que es el código de la letra Y. A la inversa, se puede
almacenar constantes de carácter en variables enteras. Así:

int j = ‘p’

No pone una letra p en j, sino que asigna el valor 80 (código ASCII de p) a la

variable j.
 2.2 Constantes, Variables y Tipos de
Datos.
Constantes de cadena
Una constante de cadena (también llamada literal cadena o simplemente
cadena) es una secuencia de caracteres encerrados entre dobles comillas.
Algunos ejemplos de cadena son:
“123”
“12 de octubre 1942”
“esto es una cadena”

Se puede escribir una cadena en varias líneas, terminando cada línea con: “\”

“esto es una cadena\

que tiene dos líneas”

Se puede concatenar cadenas, escribiendo

“ABC” “DEF” “GHI” “JKL”
Esto equivale a:
“ABCDEFGHIJKL”
 2.2 Constantes, Variables y Tipos de
Datos.
En memoria, las cadenas se representan por una serie de caracteres ASCII más
un 0 o nulo. El carácter nulo marca el final de la cadena y se inserta
automáticamente por el compilador C al final de las constantes de cadenas.

Para representar valores nulos, C define el símbolo NULL como una constante
en diversos archivos de cabecera (normalmente stdef.h, stdio.h, stdlib.h y
string.h).

Para utilizar NULL en un programa, incluya uno o más archivos en lugar de

definirlo con una línea tal como:

#define NULL 0

Recuerde que una constante de caracteres se encierra entre comillas simples

(apóstrofes), y las constantes de cadena encierran caracteres entre dobles
comillas. Por ejemplo:

‘Z’ “Z”
 2.2 Constantes, Variables y Tipos de
Datos.
El primer ‘Z’ es una constante de carácter simple con una longitud de 1, y el
segundo “Z” es una constante de cadena de caracteres también con una
longitud de 1.

La diferencia es que la constante de cadena incluye un cero (nulo) al final de la

cadena, ya que C necesita conocer dónde termina la cadena y la constante de
carácter no incluye el nulo ya que se almacena como un entero.

Por consiguiente, no se puede mezclar constantes caracteres y cadenas de

caracteres en su programa.
 2.2 Constantes, Variables y Tipos de
Datos.
2.2.1.2 CONSTANTES DEFINIDAS (SIMBOLICAS)
Las constantes pueden recibir nombres simbólicos mediante la directiva #define.

#define NUEVALINEA \n
#define PI 3.141592
#define VALOR 54

C sustituye los valores \n, 3.141592 y 54 cuando se encuentran las constantes

simbólicas NUEVALINEA, PI y VALOR. Las líneas anteriores no son sentencias
y, por ello, no terminan en punto y coma.

printf(“El valor es %dNUEVALINEA”,VALOR);

Escribe en pantalla la constante VALOR. Realmente, lo que hace el compilador es

sustituir en el programa todas las ocurrencias de VALOR por 54, antes de analizar
sintácticamente el programa fuente.
 2.2 Constantes, Variables y Tipos de
Datos.
2.2.1.3 CONSTANTES ENUMERADAS
Las constantes enumeradas permiten crear listas de elementos afines. Un
ejemplo típico es una constante numerada de lista de colores, que se puede
declarar como:

enum Colores {Rojo, Naranja, Amarillo, Verde, Azul, Violeta};

Cuando se procesa esta sentencia, el compilador asigna un valor que comienza

en 0 a cada elemento enumerado; así. Rojo equivale a 0, Naranja es 1, etc.

El compilador enumero los identificadores por nosotros. Después de declarar un

tipo de dato enumerado, se pueden crear variables de este tipo, como con
cualquier otro tipo de datos.
 2.2 Constantes, Variables y Tipos de
Datos.
Es posible asignar valores distintos de los que les corresponde en su secuencia
natural:

enum LucesTrafico {Verde, Amarillo = 10, Rojo};

Al procesar esta sentencia, el compilador asigna el valor 0 al identificador Verde,

10 al identificador Amarillo y 11 al Rojo.
 2.2 Constantes, Variables y Tipos de
Datos.
2.2.1.4 CONSTANTES DECLARADAS (const y volatile).

El calificador const permite dar nombres simbólicos a constantes a modo de otros

lenguajes, como pascal. El formato general para crear una constante es:

const tipo nombre = valor;

Si se omite tipo, C utiliza int (entero en forma predeterminada)

const int Meses = 12; /* Meses es constante simbólica del valor 12 */

const char CARÁCTER = ‘@’;
const int OCTAL = 0233;
const char CADENA [ ] = “Curso de C”;

C soporta el calificador de tipo variable const. Especifica que el valor de una

variable no se puede modificar durante un programa. Cualquier intento de
modificar el valor de la variable definida con const producirá un mensaje de error.
 2.2 Constantes, Variables y Tipos de
Datos.
La palabra reservada volatile actúa como const. Pero su valor puede ser
modificado, no solo por el propio programa, sino también por el hardware o por el
software del sistema. Las variables volátiles, sin embargo, no se pueden guardar
en registros, como es el caso de las variables normales.

 Diferencias entre const y #define

Las definiciones const especifican tipos de datos, terminan con punto y coma y se
inicializan como las variables.

La directiva #define no especifica tipos de datos, no utiliza el operador de

asignación (=) y no termina con punto y coma.

 Ventajas de const sobre #define

En C casi siempre, es recomendable el uso de const en lugar de #define.

Además de las ventajas ya enunciadas, se pueden considerar otras:
 2.2 Constantes, Variables y Tipos de
Datos.
 El compilador, normalmente, genera código más eficiente con const.

 Como las definiciones especifican tipos de datos, el compilador puede

comprobar inmediatamente si las constantes literales en las definiciones de
const están en forma correcta. Con #define el compilador no puede
realizar pruebas similares hasta que una sentencia utiliza el identificador
constante, por lo que se hace más difícil la detección de errores.

 Desventaja de const frente a #define.

Los valores de los símbolos de const ocupan espacio de datos en tiempo de

ejecución, mientras que #define solo existe en el texto del programa y su valor se
inserta directamente en el código compilado. Los valores const no se pueden
utilizar donde el compilador espera un valor constante, por ejemplo, en la
definición de un array.

Por esta razón, algunos programadores de C siguen utilizando #define en lugar

de const.
 2.2 Constantes, Variables y Tipos de
Datos.

2.2.2 Variables
En C una variable es una posición con nombre en memoria donde se almacena un
valor de un cierto tipo de dato. Las variables pueden almacenar todo tipo de
datos: cadenas, números y estructuras. Una constante, por el contrario, es una
variable cuyo valor no puede ser modificado.

Una variable típicamente tiene un nombre (un identificador) que describe su

propósito. Toda variable utilizada en un programa debe ser declarada
previamente. La definición en C debe situarse al principio del bloque, antes de
toda sentencia ejecutable. Una definición reserva un espacio de almacenamiento
en memoria. El procedimiento para definir (crear) una variable es escribir el tipo
de dato, el identificador o nombre de la variable y en ocasiones, el valor inicial que
tomara. Por ejemplo:

char Respuesta;
 2.2 Constantes, Variables y Tipos de
Datos.
significa que se reserva espacio en memoria para Respuesta; en este caso, un
carácter ocupa un solo byte.

El nombre de una variable ha de ser un identificador valido. Es frecuente, en la

actualidad, utilizar subrayados en los nombres, bien al principio o en su interior,
con objeto de obtener mayor legibilidad y una correspondencia mayor con el
elemento del mundo real que representa.

salario días_de_semana edad_alumno _fax

 2.2 Constantes, Variables y Tipos de
Datos.
Declaración de una Variable

Una declaración de una variable es una sentencia que proporciona información de

la variable al compilador C. Su sintaxis es:

Tipo variable

Tipo: Es el nombre de un tipo de dato conocido por C.

Variable: es un identificador (nombre) valido en C.

Ejemplos:
long dNumero
double HorasAcumuladas
float HorasPorSemana

Es preciso declarar las variables antes de utilizarlas. Se puede declarar una

variable al principio de un archivo o de un bloque de código, al principio de una
función
 2.2 Constantes, Variables y Tipos de
Datos.
Variable al principio del archivo:

#include <stdio.h>
Int MiNumero;

Int main()
{
printf(“¿Cuál es mi numero favorito?”);
scanf(“%d”,&MiNumero);
Return 0;
}

Variable al principio de una función. Al principio de la función main().

...
int main()
{
int i;
int j;
...
}
 2.2 Constantes, Variables y Tipos de
Datos.
Variable al principio de un bloque. Al principio de un bloque for

...
Int main()
{
int i;
...
for (i = 0; i < 9; i++)
{
Doublé suma;
...
}
}
 2.2 Constantes, Variables y Tipos de
Datos.
Inicialización de variables

En algunos programas anteriores, se ha proporcionado un valor denominado valor

inicial, a una variable cuando se declara. El formato general de una declaración de
inicialización es:

tipo nombre_variable = expresión

expresión: Es cualquier expresión valida cuyo valor es del mismo tipo que tipo.

Ejemplos:

char respuesta = ‘s’;

int contador = 1;
float peso = 156.45;
int anyo = 2014;
 2.2 Constantes, Variables y Tipos de
Datos.
Estas acciones crean las variables: respuesta, contador, peso u anyo, que
almacenan en memoria los valores respectivos situados a su derecha.

El Segundo método consiste en utilizar sentencias de asignación diferentes

después de definir la variable, como en el siguiente caso:

char barra ;
barra = ‘/ ‘ ;
 2.2 Constantes, Variables y Tipos de
Datos.
Declaración o definición
La diferencia entre declaración y definición es sutil.
Una declaración introduce un nombre a una variable y asocia un tipo con la
variable.

Una definición es una declaración que asigna simultáneamente a la memoria la

variable.

double x; declara el nombre de la variable x de tipo double.

char c_var; declara c_var de tipo char.

int i ; definido pero no inicializado.

int i = 0; definido e inicializado a cero
 2.2 Constantes, Variables y Tipos de
Datos.
Duración de la variable.
Dependiendo del lugar donde se definan las variables de C, estas se pueden
utilizar en su totalidad del programa, dentro de la función o pueden existir
temporalmente dentro de un bloque de una función.

La zona de un programa en la que una variable esta activa se denomina,

normalmente, ámbito o alcance (“scope”), los tipos básicos de variables en C
son:

 Variables locales.

 Variables globales.

 Variables dinámicas.
 2.2 Constantes, Variables y Tipos de
Datos.
Variables Locales.
Las variables locales son aquellas definidas en el interior de una función y son
visibles solo en esa función específica. Las reglas por las que se rigen las variables
locales son:

1. En el interior de una función, una variable local no puede ser modificada por
ninguna sentencia externa a la función.

2. Los nombres de las variables locales no han de ser únicos. Dos, tres o más
funciones pueden definir variables de nombre interruptor. Cada variable es
distinta y pertenece a la función en que está declarada.

3. Las variables locales de las funciones no existen en memoria hasta que se

ejecuta la función. Esta propiedad permite ahorra memoria, ya que permite que
varias funciones compartan la misma memoria para sus variables locales (pero
no a la vez).
 2.2 Constantes, Variables y Tipos de
Datos.
Por la razón dada en el punto 3, las variables locales se llaman también
automáticas o auto, ya que dichas variables se crean automáticamente en la
entrada a la función y se liberan también automáticamente cuando se termina la
ejecución de la función.
 2.2 Constantes, Variables y Tipos de
Datos.
Variables globales.
Las variables globales son variables que se declaran fuera de la función y son
visibles en forma predeterminada a cualquier función, incluyendo main().

#include <stdio.h>

int a, b, c; /*Declaración de variable global */

int main()
{

int valor; /* Declaración de variable local */

printf(“ Tres valores: “);
scanf(“%d %d %d”, &a, &b, &c); /* a, b, c variables globales */

Valor = a+b+c;
...

}
 2.2 Constantes, Variables y Tipos de
Datos.
La memoria asignada a una variable global permanece asignada a través de la
ejecución del programa, tomando espacio valido según se utilice.

Por esta razón, se debe evitar la utilización de muchas variables globales dentro
de un programa.

Otro problema que surge con las variables globales es que una función puede
asignar un valor específico a una variable global.

Posteriormente, en otra función y por olvido, se pueden hacer cambios en la

misma variable. Estos cambios dificultaran la localización de errores.
 2.2 Constantes, Variables y Tipos de
Datos.
Variables dinámicas.
Las variables dinámicas tienen características que en algunos casos son similares
tanto a variables locales como a globales. Al igual que una variable local, una
variable dinámica se crea y se libera durante la ejecución del programa.

La diferencia entre una variable local y una global es que la variable dinámica se
crea tras su petición y no automáticamente, como las variables locales, es decir a
su voluntad y se libera cuando ya no se necesita.
 2.2.3. Entradas y Salidas
Entrada
La entrada de datos a un programa puede tener diversas fuentes, teclado,
archivos en disco, etc. La entrada que consideramos ahora es por medio
del teclado, asociado al archivo estándar de entrada stdin.

La función más utilizada, por su versatilidad, para entrada formateada es

scanf().

El archivo de cabecera stdio.h de la biblioteca C proporciona la definición

(el prototipo) de scanf(), así como de otras funciones de entrada o de
salida.

La forma general que tiene la función scanf() es:

scanf(cadena_de_control, var1, var2, var3, . . .)

cadena_de_control contiene los tipos de los datos y si se desea su

anchura.
var1, var2, var3, . . . variables del tipo de los códigos de control.
 2.2.3. Entradas y Salidas

Se pueden añadir, como sufijo del código, ciertos modificadores como l o

L. El significado es “largo”: aplicado a float (%Lf) indica tipo double;
aplicado a int (%Ld), entero largo.

Las variables que se pasan a scanf() se transmiten por referencia para

poder ser modificados y transmitir los daos de entrada, para ello se hacen
preceder del operador de dirección, el prefijo &. Un error frecuente se
produce al escribir, por ejemplo:

scanf (“%Lf”, x) INCORRECTO

scanf (“%Lf”, &x) CORRECTO

La función scanf() termina cuando ha captado tantos datos como

códigos de control se han especificado, o cuando un dato no coincide
con el código de control especificado.
 2.2.3. Entradas y Salidas

Entrada de cadenas de caracteres.

La entrada de una cadena de caracteres se hace con la función más
general scanf() y el código %s.
Así, por ejemplo:

char nombre [51];

printf(“Nombre del atleta: “);
scanf(“%s”, nombre);
printf(“Nombre introducido: %s”, nombre);

la entrada del nombre podría ser:

Juan Pérez.

La salida es:
Nombre introducido: Juan
 2.2.3. Entradas y Salidas
La biblioteca de C tiene una función específica para captar una cadena
de caracteres, la función gets(). Capta del dispositivo estándar de entrada
una cadena de caracteres, termina la captación con un retorno de carro.

El siguiente ejemplo muestra como captar una línea de como máximo 80

caracteres.

char línea [81];

puts (“Nombre y dirección”);
gets (línea);

La función gets() tiene un solo argumento, una variable tipo cadena.

Capta la cadena de entrada y la devuelve en la variable pasada como

argumento.

gets (variable_cadena);
 2.2.3. Entradas y Salidas
Tanto con scanf() como con gets(), el programa inserta al final de la
cadena el carácter que indica el fin de cadena, el carácter nulo, \0.
Siempre hay que definir las cadenas con un espacio más del previsto
como máxima longitud para el carácter fin de cadena.
 2.2.3. Entradas y Salidas

Salida
La salida de datos de un programa se puede dirigir a diversos dispositivos:
pantalla, impresora, archivos. La salida que se trata a continuación va a
ser a pantalla y además será formateada. La función printf() visualiza en la
pantalla datos del programa, transforma los datos, que están en
representación binaria, a ASCII según los códigos transmitidos así, por
ejemplo:

suma = 0;
suma = suma + 10;
printf(“%s %d”, “suma = “, suma);

Visualiza
suma = 10
 2.2.3. Entradas y Salidas
El número de argumentos de printf() es indefinido, por lo que se pueden
transmitir cuantos datos se dese. Suponiendo que:

i=5 j = 12 c = ‘A’ n = 40.791512

La sentencia
Printf (“%d %d %c %f”, i, j, c, n);

Visualizará en pantalla

5 12 A 40.791512

La forma general que tiene la función printf() es:

printf (cadena_de_control, dato1, dato2, dato3, …)

cadena_de_control contiene los tipos de datos y forma de

mostrarlos.

dato1, dato2, . . . variables, constantes, datos de salida.

 2.2.3. Entradas y Salidas
printf() convierte, da forma de salida a los datos y los escribe en pantalla.

La cadena de control contiene códigos de formato que se asocian uno a

uno con los datos. Cada código comienza con el carácter %, a
continuación, puede especificarse el ancho mínimo del dato y termina
con el carácter de conversión. Así, suponiendo que:

I = 11 j = 12 c = ‘A’ n = 40.791512

Printf (“%x %3d %c %.3f”, i, j, c, n);

Visualizara en pantalla:

B 12 A 40.792

El primer dato es 11 en hexadecimal (%x), el segundo es el numero entero

12 en un ancho de 3, le sigue el carácter A y por último, el número real n
redondeado a 3 cifras decimales (%.3f).
 2.2.3. Entradas y Salidas
Un signo menos a continuación de % indica que el dato se ajuste en forma
predeterminada a la izquierda en vez del ajuste a la derecha.

printf(“%15s”, “Hola Lucas”);

printf(“%-15s”, “Hola Lucas”);

Visualizara en pantalla

Hola Lucas
Hola Lucas
2.2.3. Entradas y Salidas

Los códigos de formato más utilizados y su significado:

%i El dato se convierte a entero.

%d El dato se convierte a entero decimal.
%o El dato entero se convierte a octal.
%x El dato entero se convierte a hexadecimal.
%u El dato se convierte a entero sin signo.
%c El dato se considera de tipo carácter.
%e El dato se considera de tipo float. Se convierte a notación
científica, de la forma { - }n. mmmmmmE{ +\ } dd.
%f El dato se considera de tipo float. Se convierte a notación
decimal, con parte entera y los dígitos de precisión.
%g El dato se considera de tipo float. Se convierte según el
código %e o %f dependiendo de cuál sea la
representación más corta.
%s El dato es una cadena de caracteres.
%Lf El dato se considera de tipo double.
 2.2.3. Entradas y Salidas

C utiliza secuencias de escape para visualizar caracteres que no están

representados por símbolos tradicionales, tales como \a, \b, etc.

Las secuencias de escape proporcionan flexibilidad en las aplicaciones

mediante efectos especiales.
 2.3 Sentencias y Expresiones.

Sentencias y Expresiones.
En C, una sentencia controla la secuencia de ejecución o evalúa una
expresión. Todas las sentencias finalizan con un punto y coma (;). Una
sentencia muy común podría ser:

x=a+b;

A diferencia del algebra, la sentencia no significa que x sea igual a a + b,

sino que a x se le asignara un resultado al sumar a y b. El operador de
asignación (=), asignara el valor resultante de la expresión de su lado
derecho en la variable ubicada en su lado izquierdo.

En una sentencia, los espacios en blanco son generalmente ignorados. En

tal caso,

x=a+b; y x= a + b;

son sentencias equivalentes.

 2.3 Sentencias y Expresiones.
Las sentencias pueden ser simples o compuestas.

Una sentencia compuesta, también es llamada de bloque, inicia con una

llave abierta ( { ) y termina con una llave cerrada ( } ). Cada sentencia
dentro del bloque debe finalizar con punto y coma, sin embargo, el
bloque como tal no lo necesita. Por ejemplo:

{
Temporal=a;
a= b;
b= temporal;
}

En C una expresión es cualquier sentencia que evalué a un valor. Se dice

que una expresión devuelve un valor. Por ejemplo, 3+2 devuelve el valor 5
y por lo tanto es una expresión. Todas las expresiones son sentencias.
 2.3 Sentencias y Expresiones.
Existe una infinidad de piezas de código que califican como expresiones.

Por ejemplo:

3.2 //Devuelve el valor 3.2

PI //Constante flotante que devuelve el valor 3,14
SegundosPorMinuto //Constante entera que devuelve 60

Asumiendo que PI es una constante definida como 3,14 y que

SegundosPorMinuto es otra constante definida como 60, todas las
anteriores sentencias son expresiones. La siguiente expresión:

x= a + b;

no solo suma a y b asignándolo a x, sino que adicionalmente devuelve el

valor de dicha asignación. Esta sentencia es también una expresión. Como
es una expresión, puede ir en el lado derecho de un operador de
asignación.
 2.4 Operadores.
Operadores
Los programas C constan de datos, sentencias de programas y
expresiones. Una expresión es, normalmente una ecuación matemática,
tal como 3 + 5. En esta expresión, el símbolo más ( + ) es el operador de
suma y los números 3 y 5 se llaman operados.

En síntesis, una expresión es una secuencia de operaciones y operados

que especifica un cálculo.

Cuando se utiliza el + entre números (o variables) se denomina operador

binario, debido a que el operador + suma dos números.

Otro tipo de operador de C es el operador unitario (“unario”), que actúa

sobre un único valor. Si la variable x contiene el valor 5, -x es el valor -5.

El signo menos ( - ) es el operador unitario menos.

2.4 Operadores.
Sintaxis

variable = expresión

variable Identificador válido C declarado como variable.

expresión una constante, otra variable a la que se ha asignado

previamente un valor o una fórmula que se ha evaluado
y cuyo tipo es el de una variable.
 2.4 Operadores.
2.4.1 Asignación.
El operador de asignación, =, asigna el valor de la expresión derecha a la
variable situada a la izquierda.

Código = 3467;
Fahrenheit = 123.456;
coordX = 525;
coordY = 725;
 2.4 Operadores.
Esta propiedad permite inicializar varias variables con una sola sentencia:

int a, b, c;
a=b=c=5 /* se asigna 5 a las variables a, b, y c */

Además del operador de asignación =, C proporciona cinco operadores

de asignación adicionales. En la siguiente tabla aparecen los cinco
operadores de asignación citados.
 2.4 Operadores.
Estos operadores de asignación actúan como una notación abreviada
para expresiones utilizadas con frecuencia. Así, por ejemplo, si se desea
multiplicar 10 por i, se puede escribir

i = i * 10;

C proporciona un operador abreviado de asignación (*=), que realiza una

asignación equivalente

i *= 10; equivale a i = i * 10

Estos operadores de asignación no siempre se utilizan, aunque algunos

programadores C se acostumbran a su empleo por el ahorro de escritura
que suponen.
 2.4 Operadores.
2.4.2 Aritméticos.
Los operadores aritméticos sirven para realizar operaciones aritméticas
básicas. Los operadores aritméticos C siguen las reglas algebraicas típicas
de jerarquía o prioridad. Estas reglas especifican la procedencia de las
operaciones aritméticas.

Considerando la siguiente expresión

3+5*2

De acuerdo con algunas reglas, la multiplicación se realizará antes que la

suma. Por consiguiente, la expresión anterior equivale a:

3+(5*2)

En C las expresiones dentro del paréntesis se evalúan primero; a

continuación, se realizan los operadores unitarios, seguidos por los
operadores de multiplicación, división, suma y resta.
2.4 Operadores.
 2.4 Operadores.
Obsérvese que los operadores + y -, cuando se utilizan delante de un
operando, actúan como operadores unitarios más y menos.

+75 /* significa que 75 es positivo */

-154 /* significa que 154 es negativo */

En la asociatividad se determina el orden en que se agrupan los

operadores de igual prioridad; es decir de izquierda a derecha o de
derecha a izquierda.

El uso de los paréntesis, nos ayudan para cambiar el orden habitual de

evaluación de una expresión determinada por su prioridad y asociatividad.

Las subexpresiones entre paréntesis se evalúan en primer lugar según el

modo estándar y los resultados se combinan para evaluar la expresión
completa. Si los paréntesis están “anidados”, es decir, un conjunto de
paréntesis contenido en otro, se ejecutan en primer lugar los paréntesis
más internos.
 2.4 Operadores.
2.4.3 Relacionales.
C no tiene tipos de datos lógicos o booleanos para representar los valores
verdaderos (true) y falso (false). En su lugar se utiliza en tipo int para este
propósito, con el valor entero 0 que representa a falso y distinto de cero a
verdadero.

Operadores tales como >= y == que comprueban una relación entre dos
operandos se llaman operadores relacionales y se utilizan en expresiones
de la forma:

expresión1 operador_relacional expresión2

expresión1 y expresión2 expresiones compatibles C

operador_relacional un operador de la tabla de operadores
relacionales

Los operadores relacionales se usan normalmente en sentencias de

selección (if) o de iteración (while, for), que sirven para comprobar una
condición.
 2.4 Operadores.
Utilizando operadores relacionales se realizan operaciones de igualdad,
desigualdad, y diferencias relativas. Los operadores relacionales de la
siguiente tabla se pueden aplicar a operandos de cualquier tipo de dato
estándar: char, int, float, double,
 2.4 Operadores.
Cuando se utilizan los operadores en una expresión, el operador relacional
produce un 0, o un 1, dependiendo del resultado de la condición. 0 se
devuelve para una condición falsa, y 1 se devuelve para una condición
verdadera, por ejemplo:

c = 3 < 7;

la variable c se pone a 1, dado que 3 es menor a 7, entonces la operación

z devuelve un valor de 1 que se asigna a c.
Los caracteres se comparan utilizando los códigos numéricos (código
ASCII).

‘A’ < ‘C’ es 1, verdadera (true), ya que A es el código 65 y C es 67 por lo

tanto A es menor a C.

‘a’ < ‘c’ es 1, verdadera (true): a (código 97) y b (código 99).

‘b’ < ‘B’ es 0, falsa (false) ya que b (código 98) no es menor que B (código
66).
 2.4 Operadores.
Las cadenas de caracteres no pueden compararse directamente, por
ejemplo:

char nombre [26];

gets(nombre)
if(nombre < “Marisa”)

El resultado de la comparación es inesperado, no se están comparando

alfabéticamente, lo que se compara realmente son las direcciones en
memoria de ambas cadenas (punteros).

Para una comparación alfabética entre cadenas se utiliza la función

strcmp() de la biblioteca de C (string.h). Así,

if (strcmp (nombre, “Marisa”) < 0) /* alfabéticamente nombre es

menor */
 2.4 Operadores.
2.4.4 Lógicos.
Además de los operadores matemáticos, C tiene también operadores
lógicos. Estos operadores se utilizan con expresiones para devolver un valor
verdadero (cualquier entero distinto de cero) o un valor falso (0).

Los operadores lógicos se denominan también operadores booleanos, en

honor de George Boole, creador del algebra de Boole.

Los operadores lógicos de C son:

! (not)
&& (and)
| | (or)

El operador lógico ! (not, no) produce falso (cero) si su operador es

verdadero (distinto de cero) y viceversa.
 2.4 Operadores.
El operador lógico && (and, y) produce verdadero solo si ambos
operandos son verdadero (no cero); si cualquiera de los operandos es
falso produce falso.

El operador lógico | | (or, o) produce verdadero si cualquiera de los

operandos es verdadero (distinto de cero) y produce falso solo si ambos
operandos son falsos. La siguiente tabla muestra los operadores lógicos de
C.
 2.4 Operadores.
Al igual que los operadores matemáticos, el valor de una expresión
formada con operadores lógicos depende de:

a) el operador
b) sus argumentos.

Con operadores lógicos existen solo dos valores posibles para expresiones:
verdadero y falso.

La forma más usual de mostrar los resultados de operaciones lógicas

mediante las denominadas tablas de verdad, que muestran cómo
funcionan cada uno de los operadores lógicos. Ejemplo:

!(x+7 == 5)
(anum > 5) && (respuesta == ‘S’)
(bnum > 3) || (respuesta == ‘N’)
2.4 Operadores.
2.4 Operadores.
 2.4 Operadores.
Los operadores lógicos se utilizan en expresiones condicionales y mediante
sentencias if, while o for. Así, por ejemplo, la sentencia if (si la condición es
verdadera/falsa…) se utiliza para evaluar operadores lógicos.

if ((a < b) && (c > d))

{
puts (“Los resultados no son válidos”);
}

Si la variable a es menor que b y, al mismo tiempo, c es mayor que d,

entonces visualizar el mensaje: Los resultados no son válidos.

if (( ventas > 50000) || (horas < 100))

{
prima = 100000;
}
 2.4 Operadores.
Si la variable ventas es mayor 50000 o bien la variable horas es menor que
100, entonces asignar a la variable prima el valor 100000.

if ( !(ventas < 2500))

{
prima = 12500;
}

En este ejemplo, si ventas es mayor que o igual a 2500, se inicializara prima

al valor 12500.

La precedencia de los operadores es:

Los operadores matemáticos tienen precedencia sobre los operadores

relacionales y los operadores relacionales tienen precedencia sobre los
operadores lógicos.
 2.4 Operadores.
La siguiente sentencia:

if ((ventas < sal_min * 3 && años > 10 * iva)…

equivale a:

if ((ventas < (sal_min * 3)) && (años > (10 * iva))) …

 2.4 Operadores.

Evaluación en cortocircuito
En C los operadores a la izquierda de && y || se evalúan siempre en
primer lugar; si el valor del operador de la izquierda determina de forma
inequívoca el valor de la expresión, el operador derecho no se evalúa.

Esto significa que si el operando de la izquierda de && es falso o el de ||

es verdadero, el operando de la derecha no se evalúa.

Esta propiedad se denomina evaluación en cortocircuito y se debe a que,

si p es falso, la condición p && q es falsa con independencia del valor de q;
de este modo C no evalúa q.

De modo similar si p es verdadera, la condición p || q es verdadera con

independencia del valor de q y C no evalúa q.
 2.4 Operadores.
2.4.5 Condicional.
El operador condicional, ?: es un operador ternario que devuelve un
resultado cuyo valor depende de la condición comprobada. Tiene
asociatividad a derechas (derecha a izquierda).

Al ser un operador ternario requiere tres operandos.

El operador condicional se utiliza para reemplazar a la sentencia if-else

lógica en algunas situaciones.

El formato del operador condicional es:

expresión_c ? expresión_v : expresión_f;

Se evalúa expresión_c y su valor (cero=falso, distinto de cero = verdadero)

determina cual es la expresión a ejecutar; si la condición es verdadera, se
ejecuta expresión_v, y si es falsa, se ejecuta expresión_f.
 2.4 Operadores.
El siguiente ejercicio muestra el funcionamiento del operador condicional.

( ventas > 150000 ) ? comisión = 100 : comisión = 0 ;

si ventas es mayor si ventas no es

que 150 000 se mayor que 150 000 se
ejecuta: ejecuta:
comision = 100 comision = 0

Otros ejemplos del uso del operador ? : son:

n >= 0 ? 1 : -1 /* 1 si n es positivo, -1 si es negativo */

m >= n ? m : n /* devuelve el mayor valor de m y n */

 2.4 Operadores.
Si el tipo del arreglo es char, a sus elementos se les asigna el
valor ‘\u0000′.

Si el tipo del arreglo es bool, a sus elementos se les asigna el valor false.

Si el tipo del arreglo es una clase, a sus elementos se les asigna el

valor null.
 2.7 Arreglos unidimensionales y
bidimensionales.
Un arreglo (lista o tabla, array) es una secuencia de datos del mismo tipo.
Los datos se llaman elementos del arreglo y se numeran consecutivamente
0, 1, 2, 3, etc. Normalmente el arreglo se utiliza para almacenar tipos tales
como char, int o float.

Un arreglo puede contener, la edad de los alumnos de una clase, las

temperaturas de cada día de un mes en una ciudad o el número de
personas que residen en una comunidad indígena, etc.

Los elementos de un arreglo se numeran, como ya se ha comentado,

consecutivamente 0, 1, 2, 3,…

Estos números se denominan valores índice o subíndice del arreglo. El

termino subíndice se utiliza igual que en matemáticas, como una
secuencia tal como a0, a1, a2, a3,… Estos números localizan la posición
del elemento dentro dl arreglo, proporcionando acceso directo al arreglo.
Si el nombre del arreglo es a, entonces a [0] es el nombre del elemento
que está en la posición 0, a [1] es el nombre del elemento que está en la
posición 1, etc.

En general, el elemento i-ésimo está en posición i-1. De modo que, si el

arreglo tiene n elementos, sus nombres son a [0], a [1],…, a [n-1].
Arreglo unidimensional
Un arreglo unidimensional es un tipo de datos estructurado que está
formado de una colección finita y ordenada de datos del mismo tipo. Es
la estructura natural para modelar listas de elementos iguales. El tipo de
acceso a los arreglos unidimensionales es el acceso directo, es decir,
podemos acceder a cualquier elemento del arreglo sin tener que
consultar a elementos anteriores o posteriores, esto mediante el uso de
un índice para cada elemento del arreglo que nos da su posición
relativa. Para implementar arreglos unidimensionales se debe reservar
espacio en memoria, y se debe proporcionar la dirección base del
arreglo, la cota superior y la inferior.

En C++ los arreglos se declaran de la siguiente forma:

Tipodedato nombredelarreglo[tamañodelarreglo];
Como podemos ver, es similar a declarar una variable convencional,
solo que se coloca entre corchetes el número de posiciones del arreglo,
por lo que todas las posiciones serán del mismo tipo.

Al trabajar cada noche arreglos hacemos referencia a cada posición

del arreglo a través de su número de índice, el cual comienza a partir
del cero, de tal forma que para almacenar el número 10 en la posición
6 de un arreglo escribiríamos:

x[5]=10;

Parra llenar todos los elementos del arreglo es común emplear un ciclo
que nos permita recorrer el arreglo desde la primera hasta la última
posición, tal y como podemos ver en el siguiente ejemplo:
En este ejemplo hemos declarado un arreglo de tipo entero de 10
posiciones llamado x, observe que en el ciclo que empleamos para
llenar el arreglo el contador “i” va del 0 al 9, esto es porque las
posiciones de los arreglos en C++ se comienzan a numerar a partir del
cero.

Después, podemos observar dos líneas en donde presentamos de forma

directa el primer elemento del arreglo y el último elemento del arreglo.

Finalmente hay un ciclo for en el que usamos printf para presentar todos
los elementos del arreglo, como se puede observar cualquier operación
sobre el arreglo completo o sobre una sección de este, deberá hacerse
a través de un ciclo for.
Arreglos bidimensionales
Son estructuras de datos que agrupan muchos datos del mismo tipo, en
donde cada elemento se puede trabajar individualmente y se puede
hacer referencia con un mismo nombre. Se usan para representar datos
que pueden verse como una tabla con filas y columnas.

Ejemplo:
#include <stdio.h>
int main()
{
int fila, columna;
int matriz[2][2];
for(fila=0; fila<2; fila++)
for(columna=0; columna<2; columna++)
printf(“%d”, matriz[fila][columna]);
return 0;
}
Es un arreglo de dos dimensiones. Son estructuras de datos que agrupan
muchos datos del mismo tipo, en donde cada elemento se puede
trabajar individualmente y se puede referenciar con un mismo
nombre. Se usan para representar datos que pueden verse como una
tabla con filas y columnas.

Para referenciar un elemento de la matriz, debe darse un nombre de la

matriz y el índice de la fila y de la columna que el elemento ocupa en
dicha matriz. Es importante que los índices de las matrices tanto de las
filas como de las columnas empiezan en 0 y terminan en tamaño fila-1 y
tamaño columna-1 respectivamente.

A las matrices se le asignan automáticamente valores iniciales

predeterminados a cada uno de sus elementos, de acuerdo a los
siguientes criterios:

Si el tipo del arreglo es numérico, a sus elementos se les asigna el

valor cero.
BIBLIOGRAFIA:

Cairó Battistutti, Osvaldo. (2006). Fundamentos de Programación. Piensa en C. México Pearson-

Educación.

Olivares Flores, Linda I. (2008). Manual de Programación en Lenguaje C++. México DGSCA-
UNAM.

Ceballos, Francisco Javier. (2009). C/C++. Curso de programación. (2ª ed.). México: Alfaomega-
Ra ma.

Joyanes Aguilar, Luis (2010). Programación C/C++, Java y UML, (1ª ed.). México: Mc Graw Hill.

Mathews, John H. y Fink Kurtis D. (2008). Métodos numéricos con Matlab. (3ª ed.). Madrid:
Prentice Hall/Pearson.

Peñalosa, Ernesto. (2003). Fundamentos de programación C/C++. (4ª ed.). México: Alfa Omega-
UNAM.