Sei sulla pagina 1di 45

Autores:

PROGRAMACION
Curso de Programacin
LOPEZ LIRA ARTURO

MEDINA RUIZ JESUS JOVANI

EN C
MONDRAGON FLORES VICTOR HUGO

RESENDIZ AGUILA JOSE LUIS

GRUPO: 4CX01

PROFESOR: JUAN ANGEL RODRIGUEZ GOMEZ


ndice

Objetivo........................................................................................................................... 5
Justificacion...................................................................................................................... 5

Capitulo I

Introduccion..................................................................................................................... 6
Lenguaje de programacion............................................................................................... 6
Algoritmos........................................................................................................................ 7
Programa......................................................................................................................... 7

Capitulo II

Definicion del problema.......................................................................................9


Anlisis del problema..........................................................................................9
Diseo del Algoritmo...........................................................................................9
Codificacin.......................................................................................................9
Prueba y depuracin.........................................................................................10
Documentacin................................................................................................10
Mantenimiento.................................................................................................10
Datos y operaciones bsicas...............................................................................11
Tipos de datos..................................................................................................11
Tipo entero......................................................................................................11
Tipo Real.........................................................................................................12
Tipo Caracter...................................................................................................12
Tipo de Cadena de caracteres.............................................................................12

2
Variables.........................................................................................................13
Inicializacin de variables..................................................................................13
Constantes......................................................................................................13
Operadores Logicos...........................................................................................13
Palabras reservadas..........................................................................................14

Capitulo III

Estructuras de control.......................................................................................16
Tipos de estructuras de control...........................................................................17
Variable local...................................................................................................18
Variable Global.................................................................................................18
If Else.............................................................................................................19
While..............................................................................................................19
Do While.........................................................................................................20
For.................................................................................................................21

Capitulo IV

Arreglos..........................................................................................................23
Importancia de los arreglos................................................................................23
Arreglos Unidimensionales.................................................................................24
Arreglos en la memoria.....................................................................................24
Inicializacion de un arreglo unidimensional...........................................................26
Lectura e Impresin de un arreglo.......................................................................27
Modificacin de un arreglo.................................................................................28
Arreglo de caracteres........................................................................................28
Arreglos Bidimensionales (Matrices)....................................................................29
Inicializacin de matrices...................................................................................29
Lectura e impresin de matrices.........................................................................30
Modificacin de una matriz.................................................................................30

3
Capitulo V

Modularidad.....................................................................................................33
Programa principal y funciones...........................................................................33
Variables.........................................................................................................34
Recursividad....................................................................................................35
Funciones predefinidas en lenguaje C..................................................................36

Capitulo VI

Declaracion de un puntero.................................................................................38
Diferencia entre * y &..................................................................................38
Inicializacion de un puntero................................................................................39
Generacin de codigo........................................................................................39
Errores mas comunes........................................................................................40
Primer caso......................................................................................................40
Segundo caso...................................................................................................42
Tercer caso......................................................................................................44
Conclusiones....................................................................................................45

4
CAPITULO 1
Conceptos bsicos

INTRODUCCIN

5
Se pueden utilizar muchos lenguajes para programar una computadora. El ms
bsico es el lenguaje de mquina, una coleccin de instrucciones muy detallada
que controla la circuitera interna de la mquina. Este es el dialecto natural de la
mquina.

Muy pocos programas se escriben actualmente en lenguaje de maquina por dos


razones importantes: primero, porque el lenguaje de maquina es muy incmodo
para trabajar y segundo porque la mayora de las maquinas se pide programar en
diversos tipos de lenguajes, que son lenguajes de alto nivel, cuyas instrucciones
son ms compatibles con los lenguajes y la forma de pensar humanos como lo es
el lenguaje c que adems es de propsito general.

Debido a que los programas diseados en este lenguaje se pueden ejecutar en


cualquier mquina, casi sin modificaciones. Por tanto el uso del lenguaje de alto
nivel ofrece tres ventajas importantes, sencillez, uniformidad y portabilidad.

LENGUAJE DE PROGRAMACIN

Sistema de smbolos y reglas que permite la construccin de programas con los


que la computadora puede operar as como resolver problemas de manera eficaz.
Estos contienen un conjunto de instrucciones que nos permiten realizar
operaciones de entrada / salida, calculo, manipulacin de textos, lgica /
comparacin y almacenamiento / recuperacin.

Los lenguajes de programacin se clasifican en:

Lenguaje Mquina: Son aquellos cuyas instrucciones son directamente entendibles


por la computadora y no necesitan traduccin posterior para que la CPU pueda
comprender y ejecutar el programa. Las instrucciones en lenguaje maquina se
expresan en trminos de la unidad de memoria ms pequea el bit (dgito binario
0 1).

Lenguaje de Bajo Nivel (Ensamblador): En este lenguaje las instrucciones se


escriben en cdigos alfabticos conocidos como mnemotcnicos para las
operaciones y direcciones simblicas.

6
Lenguaje de Alto Nivel: Los lenguajes de programacin de alto nivel (BASIC,
pascal, cobol, fortran, etc.) son aquellos en los que las instrucciones o sentencias a
la computadora son escritas con palabras similares a los lenguajes humanos (en
general en ingls), lo que facilita la escritura y comprensin del programa.

ALGORITMO

La palabra algoritmo se deriva de la traduccin al latn de la palabra rabe


alkhowarizmi, nombre de un matemtico y astrnomo rabe que escribi un
tratado sobre manipulacin de nmeros y ecuaciones en el siglo IX.

La solucin a cualquier problema de cmputo involucra la ejecucin de una serie


de acciones en orden especfico. Un procedimiento para resolver un problema en
trminos de: a) Las acciones a ejecutarse y b) el orden en el cual estas acciones
deben ejecutarse se llama algoritmo. Un ejemplo de un algoritmo para llegar a la
escuela:

Salir de la cama
Quitarse la pijamas
Darse un bao
Vestirse
Desayunar

PROGRAMA

Secuencia de instrucciones mediante las cuales se ejecutan diferentes acciones de


acuerdo con los datos que se estn procesando. Es un algoritmo desarrollado para
ser utilizado por la computadora. Expresin de un algoritmo en un lenguaje preciso
que puede llegar a entender una mquina de cmputo.

7
CAPITULO 2
Los datos y
operaciones
bsicas

Fases para la creacin de un programa.

8
DEFINICIN DEL PROBLEMA

Esta fase est dada por el enunciado del problema, el cual requiere una definicin
clara y precisa. Es importante que se conozca lo que se desea que realice la
computadora; mientras esto no se conozca del todo no tiene mucho caso continuar
con la siguiente etapa.

ANLISIS DEL PROBLEMA

Una vez que se ha comprendido lo que se desea de la computadora, es necesario


definir:

Los datos de entrada. Cul es la informacin que se desea producir (salida) los
mtodos y frmulas que se necesitan para procesar los datos. Una recomendacin
muy prctica es el que nos pongamos en el lugar de la computadora y analicemos
que es lo que necesitamos que nos ordenen y en que secuencia para producir los
resultados esperados.

DISEO DEL ALGORITMO

Las caractersticas de un buen algoritmo son:

Debe tener un punto particular de inicio.


Debe ser definido, no debe permitir dobles interpretaciones.
Debe ser general, es decir, soportar la mayora de las variantes que se
puedan presentar en la definicin del problema.
Debe ser finito en tamao y tiempo de ejecucin.
CODIFICACIN

La codificacin es la operacin de escribir la solucin del problema (de acuerdo a la


lgica del diagrama de flujo o pseudocdigo), en una serie de instrucciones
detalladas, en un cdigo reconocible por la computadora, la serie de instrucciones
detalladas se le conoce como cdigo fuente, el cual se escribe en un lenguaje de
programacin o lenguaje de alto nivel.

9
PRUEBA Y DEPURACIN

Los errores humanos dentro de la programacin de computadoras son muchos y


aumentan considerablemente con la complejidad del problema. El proceso de
identificar y eliminar errores, para dar paso a una solucin sin errores se le llama
depuracin. La prueba consiste en la captura de datos hasta que el programa no
presente errores (los ms comunes son los sintcticos y lgicos).

DOCUMENTACIN

Es la gua o comunicacin escrita es sus variadas formas, ya sea en enunciados,


procedimientos, dibujos o diagramas. A menudo un programa escrito por una
persona, es usado por otra. Por ello la documentacin sirve para ayudar a
comprender o usar un programa o para facilitar futuras modificaciones
(mantenimiento). La documentacin se divide en tres partes:

Documentacin Interna: Son los comentarios o mensaje que se aaden al


cdigo fuente para hacer ms claro el entendimiento de un proceso.
Documentacin Externa: Se define en un documento escrito los siguientes
puntos: Descripcin del Problema, nombre del Autor, algoritmo (diagrama de
flujo o pseudocdigo), diccionario de Datos, cdigo Fuente (programa)
Manual del Usuario: Describe paso a paso la manera cmo funciona el
programa, con el fin de que el usuario obtenga el resultado deseado.
MANTENIMIENTO

Se lleva acabo despus de terminado el programa, cuando se detecta que es


necesario hacer algn cambio, ajuste o complementacin al programa para que
siga trabajando de manera correcta. Para poder realizar este trabajo se requiere
que el programa este correctamente documentado.

LOS DATOS Y OPERACIONES BSICAS.

10
IDENTIFICADOR. Un identificador es una serie de caracteres formados por
letras, dgitos y el carcter subrayado (_) que no inicie con dgito, as mismo es el
nombre que damos a todo lo que manipulamos dentro de un programa (variables,
constantes, funciones, etc.). Por ejemplo variables, constantes, funciones, tipos
definidos por el usuario etc.

TIPOS DE DATOS. Todos los datos tienen un tipo asociado con ellos. Un dato
puede ser un simple carcter, tal como b, un valor entero tal como 35. El tipo de
dato determina la naturaleza del conjunto de valores que puede tomar una
variable.

TIPO ENTERO: representa nmeros enteros con o sin signo, que estarn
compuestos por los dgitos del 0 al 9, pudiendo ser precedidos por los signos + o
-.

Algunos ejemplo de datos enteros son: 0, 23, -176, -1, etc.

Para definir variables en C se antepone la palabra reservada del tipo al


identificador de la variable. El tipo de datos entero se define en el lenguaje de
programacin C por la palabra reservada int.

Para definir un tipo de dato en C se escribe lo siguiente:

int nombre_variable = valor;

No es necesario que la variable tenga un valor predeterminado. Se puede definir


sin asignarle ningn valor. Si tenemos varios datos que son del mismo tipo, se
pueden definir todas en la misma lnea de cdigo escribiendo un nico int,
separando el nombre de las variables por ,. Una vez que se haya acabado de
definir variables, se cierra la lnea de cdigo con ;,

Por ejemplo: int edad = 24;

int edad;

int edad, num, contador;

11
TIPO REAL: Se emplean para representar nmeros reales (con decimales). Para
definir datos reales se antepone la palabra reservada float al identificador de la
variable.

float identificador = valor;

Por ejemplo: float numero1, numero2;

float numero3 = 123.43;

float numero3;

TIPO CARCTER: Este tipo de datos se emplea para representar un carcter


perteneciente a un determinado cdigo utilizado por el ordenador (normalmente el
cdigo ASCII). Para representar este tipo de dato se antepone la palabra
reservada char al identificador de la variable.

Char identificador = valor;

Una constante tipo char se representa como un solo carcter encerrado entre
comillas simples.

Por ejemplo: char letra, letra2;

char letra=a;

TIPO CADENA DE CARACTERES: una cadena de caracteres es un nmero de


caracteres consecutivos (incluso ninguno) encerrado entre unos delimitadores
determinados, que en el lenguaje C son las comillas dobles.

Para definir variables de tipo cadena, estas se definen como vectores de


caracteres, esto es, anteponiendo la palabra reservada char al identificador de la
variable, y despus entre corchetes la longitud mxima de cadena.

Char identificador[cantidad] = mensaje ;

Por ejemplo: char cadena[20];

char cadena[20] = Hola mundo;

char cadena[] = HOLA;

12
VARIABLES. Una variable es un identificador que puede tomar diferentes valores
dependiendo del tipo que esta se declare. Una variable es un identificador que
puede cambiar de valor durante la ejecucin de un programa. Una variable es una
posicin de memoria donde se puede almacenar un valor para uso de un
programa.

INICIALIZACIN DE VARIABLES

Inicializar una variable es el darle un valor despus que se ha declarado pero


antes de que se ejecuten las sentencias en las que se emplea.

Por ejemplo: char cadena [20];

char cadena[20] = Hola mundo;

char cadena[] = HOLA;

Aqu se inicializa la variable cadena con la palabra hola mundo

CONSTANTES. Constantes son los valores que no pueden ser modificados. En C+


+, pueden ser de cualquier tipo de datos. Adems de los ejemplificados
anteriormente, podemos crear constantes de caracteres con barra invertida. Estos
corresponden a los caracteres que son imposibles introducir desde el teclado.

4. OPERADORES

Un operador es un smbolo que indica al compilador que realice manipulaciones


lgicas o matemticas especficas. Los operadores del mismo nivel de precedencia
son evaluados por el compilador de izquierda a derecha. Por supuesto, se puede
utilizar parntesis para ordenar la evaluacin. Tambin, conviene utilizar
parntesis para hacer ms claro el orden en que se producen las evaluaciones,
tanto para la persona que lo elabora o para los que despus tengan que seguir el
programa.

OPERADORES LGICOS: Estos operadores se utilizan para establecer relaciones


entre valores lgicos. Estos valores pueden ser resultado de una expresin
relacional.

And ( en c++ &&)


Or ( en c++ ||)
Not Negacin (en c++ = )

13
Prioridad de los Operadores Lgicos

1. Not
2. And
3. Or

Operadores de Asignacin. Los operadores de asignacin se utilizan para formar


expresiones de asignacin, en las que se asigna el valor de una expresin a un
identificador. ***** Por definir el operador de asignacin**.Cada expresin toma
un valor que se determina tomando los valores de las variables y constantes
implicadas y la ejecucin de las operaciones indicadas. Una expresin consta de
operadores y operandos. Segn sea el tipo de datos que manipulan, se clasifican
las expresiones en:

Aritmticas
Relacinales
Lgicas

PALABRAS RESERVADAS

Son palabras que tienen un significado especial para el lenguaje y no se pueden


utilizar como identificadores. Por ejemplo: int, float, char, void, class, struct, etc.

14
CAPITULO 3
Programacin
Estructurada

ESTRUCTURAS DE CONTROL

15
En lenguajes de programacin, las estructuras de control permiten modificar el
flujo de ejecucin de las instrucciones de un programa.
Con las estructuras de control se puede:

De acuerdo a una condicin, ejecutar un grupo u otro de sentencias (If-


Then-Else)
De acuerdo al valor de una variable, ejecutar un grupo u otro de sentencias
(Select-Case)

Ejecutar un grupo de sentencias mientras se cumpla una condicin (Do-


While)

Ejecutar un grupo de sentencias hasta que se cumpla una condicin (Do-


Until)

Ejecutar un grupo de sentencias un nmero determinado de veces (For-


Next)

Todas las estructuras de control tienen un nico punto de entrada y un nico


punto de salida. Las estructuras de control se puede clasificar en : secuenciales,
iterativas y de control avanzadas. Esto es una de las cosas que permite que la
programacin se rija por los principios de la programacin estructurada.
Los lenguajes de programacin modernos tienen estructuras de control similares.
Bsicamente lo que vara entre las estructuras de control de los diferentes
lenguajes es su sintaxis, cada lenguaje tiene una sintaxis propia para expresar la
estructura.
Otros lenguajes ofrecen estructuras diferentes, como por ejemplo los comandos
guardados.

16
TIPOS DE ESTRUCTURA DE CONTROL

Ejecucin secuencial

Pero por lo general las instrucciones se ejecutan una despus de la otra, en el


orden en que estn escritas, es decir, en secuencia. Este proceso se conoce como
ejecucin secuencial.
De seleccin

Las estructuras de control de seleccin, ejecutan un bloque de instrucciones u


otro, o saltan a un subprograma o subrutina segn se cumpla o no una condicin.
Estructura de control
Las estructuras de control, denominadas tambin sentencias de control, permiten
tomar decisiones y realizar un proceso repetidas veces. Se trata de estructuras
muy importantes, ya que son las encargadas de controlar el flujo de un programa,
segn los requerimientos del mismo.

Seleccin if simple
Se trata de una estructura de control que permite redirigir un curso de accin
segn la evaluacin de una condicin simple, sea falsa o verdadera.
Si la condicin es verdadera, se ejecuta el bloque de sentencias 1, de lo contrario,
se ejecuta el bloque de sentencias 2.
switch-case
Esta sentencia permite ejecutar una de entre varias acciones en funcin del valor
de una expresin. Es una alternativa a if then else cuando se compara la misma
expresin con diferentes valores.

Se evala la expresin, dando como resultado un nmero.


Luego, se recorren los "Case" dentro de la estructura buscando que el
nmero coincida con uno de los valores.

Es necesario que coincidan todos sus valores.

17
Cuando se encuentra la primera coincidencia, se ejecuta el bloque de
sentencias correspondiente y se sale de la estructura Select-Case.

Si no se encuentra ninguna coincidencia con ningn valor, se ejecuta el


bloque de sentencias de la seccin "Case Else".

Estructura del switch-case

Select (Expresin)
Case Valor1
(Bloque de sentencias 1)
Case Valor2
(Bloque de sentencias 2)
Case Valor n
(Bloque de sentencias n)
Case Else
(Bloque de sentencias "Else")
End Select

Estructuras de control iterativas


Las estructuras de control iterativas o de repeticin, inician o repiten un bloque de
instrucciones si se cumple una condicin o mientras se cumple una condicin.

Variables locales y globales.

Las reglas de mbito de un lenguaje son las reglas que controlan si un fragmento
de cdigo conoce o tiene acceso a otro fragmento de cdigo o de datos.

UNA VARIABLE LOCAL es aquella cuyo mbito se restringe a la funcin que la ha


declarado se dice entonces que la variable es local a esa funcin. Esto implica que
esa variable slo va a poder ser manipulada en dicha seccin, y no se podr hacer
referencia fuera de dicha seccin. Cualquier variable que se defina dentro de las
llaves del cuerpo de una funcin se interpreta como una variable local a esa
funcin.

18
UNA VARIABLE GLOBAL es aquella que se define fuera del cuerpo de cualquier
funcin, normalmente al principio del programa, despus de la definicin de los
archivos de biblioteca (#include), de la definicin de constantes simblicas y antes
de cualquier funcin.

LAS ESTRUCTURAS MS UTILIZADAS EN LA PROGRAMACION

LA TOMA DE DECISIONES IF-ELSE:


Quiz la estructura de control ms bsica y la ms utilizada sea if-else:

if (condicin) {

// Instrucciones que hay que ejecutar si la condicin es verdadera

} else {

// Instrucciones que hay que ejecutar si la condicin es falsa


}
En nuestro lenguaje sera algo as:

Si (Tal cosa es cierta) {

// Haz esto

} En caso contrario {

// Haz esto otro

BUCLES: WHILE

19
If else nos permita decidir si queramos ejecutar o no una instruccin en funcin
de una condicin, los bucles nos permiten utilizar una condicin para determinar
cuntas veces queremos ejecutar una instruccin.

While (condicin) {

// Instrucciones a ejecutar una y otra

//vez mientras la condicin sea cierta


}
BUCLES: DO WHILE

Los bucles do while, son muy parecidos a los bucles while, slo que comprobamos
si la condicin es cierta al final del bucle en lugar de al principio. As nuestras
instrucciones se ejecutan siempre al menos una vez, lo que no ocurre en las
condiciones while si la condicin es falsa.

$cantidad = 1;

Do {

echo ($cantidad);

} while ($cantidad<1);
En nuestro lenguaje seria

$cantidad = 1

Do (// ejecuta

Echo ($cantidad); escribe el valor de cantidad

20
while ($cantidad<1); mientras cantidad sea mayor que 1 -> la condicin es falsa
luego el programa sale del bucle, pero ha escrito una vez el valor de $cantidad. El
resultado en pantalla sera 1

BUCLES: FOR

Los bucles for funcionan exactamente igual que en C . Con una sola instruccin
controlamos todo el bucle, as que para los vaguetes est muy bien.

for (valor inicial; condicin; ejecutar en cada bucle) {


// Instrucciones a ejecutar mientras la condicin sea cierta
}
En nuestro lenguaje es igual a:

Cantidad es igual a 1, mientras cantidad sea menor que 10 escribe cantidad en


pantalla y despus smale 1 al valor de cantidad. Es decir, es exactamente el
mismo ejemplo que vimos en el bucle while pero de otra manera.

21
CAPITULO 4
Arreglos

22
ARREGLOS

DEFINICIN:

Un arreglo es un tipo de dato estructurado que almacena en una sola variable un


conjunto limitado de datos o elementos del mismo tipo. Asimismo, es un conjunto
de localidades de memoria contiguas donde la direccin ms baja corresponde al
primer elemento y la direccin ms alta al ltimo. Por s mismo, el nombre del
arreglo apunta a la direccin del primer elemento del arreglo. Los datos se llaman
elementos del arreglo y su posicin se numera consecutivamente: 1, 2, 3n. Un
arreglo en lenguaje C inicia en la posicin cero, por lo tanto el i-simo elemento
est en la posicin i-1, es decir si el arreglo llamado a tiene n elementos, sus
nombres son: a[0], a[1], ..., a[n-1].

El tipo de elementos almacenados en el arreglo puede ser cualquier tipo de dato.

Para acceder a un elemento especfico de un arreglo se usa un ndice o subndice.

Un arreglo se caracteriza por:

1. Ser una lista de un nmero finito de n elementos del mismo tipo.


2. Almacenar los elementos del arreglo en memoria contigua.
3. Tener un nico nombre de variable que representa a todos los elementos y
stos se diferencian por un ndice o subndice.
4. Acceder de manera directa o aleatoria a los elementos individuales del
arreglo, por el nombre del arreglo y el ndice o subndice.
5. Se clasifican en arreglos unidimensionales, bidimensionales, y
multidimensionales.

LA IMPORTANCIA DE DECLARAR ARREGLOS DE TAMAO ADECUADO

Al igual que cualquier variable, los arreglos ocupan espacio en memoria. El


programador especifica el tipo de dato y el total de elementos requerido por el

23
arreglo de tal forma que la computadora pueda reservar la cantidad apropiada de
memoria.

Se pueden declarar varios arreglos en una sola instruccin y de esta forma


reservar la memoria necesaria.

Para reservar 100 elementos para el arreglo a y 50 elementos para el arreglo x, ambos de
tipo entero, se puede utilizar la siguiente declaracin:

PSEUDOCODIGO LENGUAJE C

Entero a[100], x[50] Int a[100], x[50];

ARREGLOS UNIDIMENSIONALES (VECTORES O LISTAS)

Un arreglo unidimensional es un conjunto de n elementos del mismo tipo


almacenados en memoria continua en un vector o lista. Para acceder a cada
elemento del arreglo se requiere de un solo ndice o subndice, el cual representa
la posicin en la que se encuentra.

Declaracin de un arreglo unidimensional:

PSEUDOCODIGO LENGUAJE C

Tipo_dato_ident_arreglo[tam_ar Tipo_dato_ident_arreglo[tam_arr
reglo] eglo];

Dnde:

Tipo_dato: Se refiere al tipo de dato de cada elemento del arreglo; puede ser
entero, real, carcter, etctera.

ident_arreglo: Es el nombre que representa a todo el arreglo

tam_arreglo: Es la cantidad de elementos que contiene el arreglo.

ARREGLOS EN LA MEMORIA:

24
Si tomamos la declaracin del arreglo lista del ejemplo anterior, as se representara en
memoria entero lista [4]:

Posicin de 100 100 1002 1003 1004 1005 100 1007


memoria 0 1 6

Lista 0 1 2 3

Los enteros requieren de dos bytes para almacenarse en memoria; como se


muestra, por cada posicin se requiere de dos localidades de memoria, por
ejemplo el 0 ocupa la posicin 1000 y 1001.

La cantidad de arreglos que se pueden declarar depender de la memoria libre,


que comnmente es de 64 Kbytes; esta cantidad puede variar e incluso se puede
utilizar ms memoria disponible siempre y cuando la computadora cuente con ella.

Ejemplo de arreglo de nmeros reales con identificador x:

PSEUDOCODIGO LENGUAJE C

Real x[8] Float x[8];

Representacin del arreglo:


Posicion
x[0] x[1] x[2] x[3] x[4] es
x[5] x[6] x[7]
5 7.1 1 0.5 57.9 55.1 2 12

ELEMENT
OS

Este arreglo contiene ocho elementos almacenados entre la posicin (0-7). Para
referirnos a un elemento en particular dentro del arreglo, especificamos el nombre
del arreglo y el nmero de posicin donde se encuentra ubicado. La posicin del
arreglo va entre parntesis cuadrados o corchetes ([ ]) para el lenguaje C;
segn el lenguaje de programacin ser la sintaxis requerida.

El primer elemento en un arreglo es almacenado en la posicin cero para el


lenguaje C y en la posicin uno para el lenguaje Pascal. En este caso trabajaremos

25
el pseudocdigo en C. Por lo tanto el primer elemento de un arreglo x se
encuentra en la posicin cero y se conoce como x [0], el segundo como x [1], el
sptimo como x [6] y en general, el elemento de orden i del arreglo x ser x [i-1],
ya que se encuentra en la posicin i1, donde i es un subndice que sirve para
hacer referencia a la posicin en el arreglo.

Ejemplo para imprimir los valores contenidos en los primeros elementos del arreglo x:

PSEUDOCODIGO LENGUAJE C

a <- x[0] + x[1] + x[2] a = x[0] + x[1] + x[2]

Imprimir a printf(%f,a)

Donde la variable a es de tipo real, ya que los elementos del arreglo x son de ese
tipo.

INICIALIZACIN DE ARREGLOS UNIDIMENSIONALES

En el momento de declarar el arreglo, se especifican los valores.

Sintaxis:

PSEUDOCODIGO LENGUAJE C

Tipo_dato Tipo_dato identif[tam_arreglo]


identif[tam_arreglo]<- = {valores}
{valores}
Int lista [5] = {10, 17, 8, 4, 9}
Entero lista[5] <- [10, 17, 8, 4,
9]

26
La asignacin de los valores se realiza al declarar el arreglo mediante el operador
de asignacin (<-/=) y los valores contenidos dentro de las llaves { } a cada
posicin del arreglo; los valores dentro de las llaves se deben separar por una
coma (,) y no es necesario asignarle un valor a cada posicin ya que el compilador
del lenguaje C se encargar de hacerlo segn el lugar donde se haya declarado el
arreglo, comenzando por la posicin cero. Si el nmero de valores es menor al
tamao del arreglo a las posiciones faltantes les asigna cero.

LECTURA E IMPRESIN DE UN DE ARREGLO UNIDIMENSIONAL

Cuando la computadora ejecuta un ciclo y la instruccin leer (scanf) el programa


almacena los valores en la variable arreglo. Para utilizar ciclos repetitivos es
necesario el uso de variables de apoyo la forma de pedirle al usuario e imprimirlos
despus, utilizando ciclos repetitivos for.

27
MODIFICACIN DE UN ELEMENTO DEL ARREGLO UNIDIMENSIONAL

Podemos modificar los elementos de un vector en cualquier momento, slo es


necesario especificar el nombre del arreglo unidimensional, la posicin y el nuevo
valor. Enseguida se muestra la sintaxis a seguir:

PSEUDOCODIGO LENGUAJE C

Tipo_dato ident_arr[pos]<- Tipo_dato ident_arr[pos] = valor;


valor
Int b[3] = 18;
Entero b[3] <- 18

Donde valor es un dato, el resultado de una llamada a funcin o de alguna


operacin lgica o aritmtica, etc. En este ejemplo se le asigna el valor 18 al
cuarto elemento del arreglo que se encuentra en la posicin 3.

ARREGLOS DE CARACTERES

Los arreglos son necesarios para la implementacin de cadenas de caracteres. Una cadena
de texto es un conjunto de caracteres. Hay que recordar que en el lenguaje C no existe el
tipo de dato cadena (string) como en otros lenguajes de programacin, por lo que se
utiliza un arreglo de caracteres, para poder almacenar una cadena:

PSEUDOCODIGO LENGUAJE C

caracter cad[ ]<-Lenguaje Char cad[ ]=Lenguaje;

Una cadena de caracteres es un arreglo de caracteres que contiene al final el


carcter nulo (\0), El compilador inserta automticamente un carcter nulo al final
de la cadena.

ARREGLOS BIDIMENSIONALES (TABLAS O MATRICES)

28
Un arreglo bidimensional es un conjunto de n elementos del mismo tipo almacenados en
memoria contigua en una matriz o tabla. A diferencia de los arreglos unidimensionales que
slo requieren de un subndice, los arreglos bidimensionales para acceder a cada
elemento del arreglo requieren de dos ndices o subndices declarados en dos pares de
corchetes, donde el primer corchete se refiere al tamao de filas y el segundo al tamao
de columnas.

PSEUDOCODIGO LENGUAJE C

Tipo_dato ident_arr[tam_fila] Tipo_dato ident_arr [tam_fila]


[tam_col] [tam_col];

Entero b[3] [4] Int b [3][4];

Dnde:

tipo_dato es el tipo de dato de todo el arreglo.


ident_arr es el nombre del arreglo.
tam_fila es el total de filas.
tam_col es el total de columnas.

B Col 0 Col 1 Col 2 Col 3

Fila 0 b[0][0] b[0][1] b[0][2] b[0][3]

Fila 1 b[1][0] b[1][1] b[1][2] b[1][3]

Fila 2 b[2][0] b[2][1] b[2][2] b[2][3]

INICIALIZACIN DE ARREGLOS BIDIMENSIONALES

En el momento de declarar el arreglo, se especifican los valores.

Sintaxis:

PSEUDOCODIGO LENGUAJE C

29
t_dato identif[fil] [col] <- T_dato identif[fil] [col={valores};
{valores}
Int a [3][3] = {1, 2, 3, 4, 5, 6, 7, 8,
Entero a[3][3]<-[1, 2, 3, 4, 5, 6, 9};
7, 8, 9}

LECTURA E IMPRESIN DE UNOS ARREGLOS BIDIMENSIONALES

Para la lectura la computadora requiere de dos ciclos anidados (para ubicar la fila y la
columna), y la instruccin leer (scanf) o leercad (gets), almacenando con ello los valores
en cada celda de la tabla o matriz.
El siguiente segmento de programa muestra cmo se pueden almacenar datos en una
matriz mat de 3 filas y 4 columnas, se utiliza la instruccin leer (scanf) para guardar o leer
los datos:

PSEUDOCODIGO LENGUAJE C

Desde( i<-0, i<3, <-i+1) for( i<-0, i<3, <-i+1)

Desde( j<-0, j<4, <-j+1) for( j<-0, j<4, <-j+1)

Leer mat[i][j] scanf(%d, &mat[i][j]);

Cuando existen dos ciclos anidados primero se inicializa el ciclo de fuera,


posteriormente realiza el que se encuentra dentro y hasta que termine con el
regresa al ciclo de fuera; en este caso, primero inicializa el ciclo i y hasta que
termina con todas las columnas (j) de la primera fila (0) y continua con la segunda
fila (1), iniciando otra vez con la columna (j = 0).

MODIFICACIN DE UN ELEMENTO DE UNA MATRIZ

Los elementos de una matriz se pueden modificar en cualquier momento, slo es


necesario especificar el nombre del arreglo bidimensional, la posicin tanto de la
fila como de la columna y el nuevo valor. En seguida se muestra la sintaxis a
seguir:

30
PSEUDOCODIGO LENGUAJE C

tipo_dato ident_arr[fil] [col] <- tipo_dato ident_arr[fil]


valores [col=valores;

Entero b[3][5]<- 18 Int a [3][5] = 18;

Donde valor es un dato o el resultado de una llamada a funcin o de alguna


operacin lgica o aritmtica, etc. En este ejemplo se le asigna directamente el
valor 18 a la matriz b en la cuarta fila y sexta columna.

Ejemplo:

Programa que guardar los nombres de los alumnos de un saln de clases en un


arreglo y posteriormente imprimirlos.

Note que el arreglo x slo tiene un ndice i, esto quiere decir que se est
almacenando en uno de los 50 posibles lugares y en los 20 posibles sitios que
tiene para cada carcter.

El segundo desde (for) sirve para imprimir en pantalla la lista de nombres.

31
CAPITULO 5
MODULARIDAD

32
MODULARIDAD

La programacin modular es una tcnica que consiste en dividir un programa en


tareas y dar origen a la creacin de pequeos programas llamados mdulos,
subprogramas o subrutinas con la finalidad de simplificar la elaboracin y
mantenimiento del mismo (vase figura 5.1), donde cada mdulo se codifica y se
procesa de manera independiente, sin importar los detalles de otros mdulos. Esto
facilita la localizacin de un error cuando se produce. Este tipo de programacin es
uno de los mtodos de diseo ms flexibles y potentes para mejorar la
productividad de un programa.

PROGRAMA PRINCIPAL Y FUNCIONES

La base de la programacin en C es la funcin, ya que constituye una parte


fundamental de la codificacin en el proceso de solucin de problemas. Un
programa contiene una o ms funciones en uno o ms archivos.

Una de las funciones es main (), donde se inicia la ejecucin del programa. El
resto de las funciones se llaman desde main () y desde el interior de otras
funciones.

El papel ms importante del programa principal (main ()) es coordinar a las otras
funciones mediante llamadas o invocaciones.

Funcin

Es un subprograma que realiza una tarea especfica que puede o no recibir valores
(parmetros). En C podemos devolver cualquier tipo de datos escalares (puntero,
tipo numrico y el tipo carcter o en su caso regresar un valor nulo que
llamaremos nada o ninguno). Asimismo, no se pueden devolver arreglos ni
estructuras.
El uso de funciones es una prctica comn y recomendable ya que permite dividir
el cdigo, simplificando as el desarrollo y la depuracin del mismo. Para utilizar
funciones en un programa es necesario declararlas previamente.
Las funciones pueden ir antes o despus del programa principal, pero si se ubican
despus es necesario escribir el prototipo de la funcin (el encabezado) antes del
programa principal. Una funcin puede que regrese o no regrese nada (void). En el
primer caso se comporta como una variable, ya que la podemos imprimir, asignar
a otra variable, comparar, utilizar como parmetro, etc. En el segundo caso, el
resultado lo tenemos que imprimir dentro de la funcin (slo las variables globales
se imprimirn fuera).

33
Funciones sin paso de parmetros

Son aquellas que no reciben parmetros o valores, ya que stos se solicitan dentro
de la funcin, luego se realizan las instrucciones (clculos u operaciones) y
normalmente se imprime el resultado.
A continuacin aparece la sintaxis correspondiente:

void Identif_funcion ( )
{
Declaracin de variables;
Cuerpo de la funcin;
}

Funciones con paso de parmetros

Estas funciones son las ms utilizadas en la programacin ya que pueden recibir


uno o ms valores llamados parmetros y regresan un solo valor de tipo entero,
real o carcter. Si deseas regresar un arreglo de carcter es necesario hacerlo
desde los parmetros. Los parmetros o valores son enviados del programa
principal o de otra funcin. Dentro de la funcin se realizan solamente las
instrucciones (clculos u operaciones). Es importante revisar que el tipo de dato
que regresar la funcin sea del mismo tipo que el valor declarado en el
encabezado de la misma.

float divide (int x, int y)


{
int a, b;
printf (Dame dos nmeros enteros: );
scanf (%d%d,&a,&b);

VARIABLES

Variable local. Variable declarada en una determina funcin, slo se encuentra


disponible durante el funcionamiento de la misma, es decir est en memoria
cuando dicha funcin est activa.
Variable global. 3 Variable declarada fuera de cualquier funcin y que puede ser
utilizada por las funciones que se encuentran despus de dicha declaracin; por lo
tanto si la declaramos junto a las libreras, la podr utilizar todo el programa. Esta
caracterstica es propia del lenguaje C.

34
Prototipo de una funcin

Un prototipo es el encabezado de una funcin, es decir la primera lnea de la


funcin. La ventaja de utilizar prototipos es que las funciones pueden estar en
cualquier lugar y en cualquier orden y pueden ser llamadas desde cualquier punto
del programa principal o de otra funcin.

La desventaja de las funciones sin prototipos, es que en el momento de llamarlas


o invocarlas tienen que estar declaradas antes; por ejemplo, en la sintaxis de las
funciones sin paso de parmetros y sin prototipos la funcion_b ( ) y principal ( )
(main) llaman a la funcion_a ( ) que est declarada antes; sin embargo la
funcion_a ( ) no puede llamar a la funcion_b ( ). La funcin main() puede llamar a
cualquier funcin, pero ninguna otra funcin puede llamar a main().
Un prototipo sin paso de parmetros es el encabezado de la funcin; en lenguaje
C, como veremos en seguida, a diferencia de la declaracin de una funcin, lleva
punto y coma. La ventaja es que le avisa al compilador que existe una funcin que
regresa un determinado tipo de dato y puede ser utilizada en cualquier momento,
por lo que la declaracin de las funciones no tiene que ser antes de la llamada sino
despus de la funcin principal o main.

RECURSIVIDAD

Cuando una funcin se llama a s misma le llamamos recursividad. Para finalizar


sta debe existir una condicin previamente definida.

#include <conio.h>
#include <stdio.h>

float factorial(int n)
{

float f;
if (n==0) f=1;
else f=n*factorial(n-1);
return f;
}

main()
{

float fact;
int n;

35
printf("\nDame un numero: ");
scanf("%d",&n);
fact=factorial(n);
printf("\nEl factorial=%f\n",fact);
getch();
return 0;

FUNCIONES PREDEFINIDAS DE LENGUAJE C

36
CAPITULO 6
APUNTADORES

37
DECLARACIN DE UN PUNTERO

Un puntero, en C, se declara como sigue:

TIPO * nombre_puntero ;
Donde TIPO es cualquier tipo definido. Asi, un puntero a caracter se declararia de
la siguiente forma:

char *pchar;

DIFERENCIA ENTRE "*" Y "&"

En C, al contrario que en otros lenguajes de programacion, se puede obtener


directamente la direccion de memoria de cualquier variable. Esto es posible
hacerlo con el operador unario "&"; asi:

char a; /* Variable 'a' de tipo char */

printf("la direccion de memoria de 'a' es: %p \n", &a);


y para obtener lo apuntado por un puntero se utiliza el operador unario "*" de esta
forma:

char a; /* Variable 'a' de tipo char */


char *pchar; /* Puntero a char 'pchar' */

pchar = &a; /* 'pchar' <- @ de 'a' */

printf("la direccion de memoria de 'a' es: %p \n", &a);


printf("y su contenido es : %c \n", *pchar);
Uno de los casos mas comunes donde se ve la relacion entre estos dos operadores
es la declaracion y utilizacion de funciones:

void Funcion ( int *int_pointer )


/* Paso de una variable de tipo entero por REFERENCIA */
/* equivalente en Modula 2: PROCEDURE Funcion ( VAR a:INTEGER ) */
.
.
.
int a;
a=6;
Funcion ( &a ); /* ya que la declaracion de la funcion pide la
direccion de una variable de tipo entero */

38
INICIALIZACIN DE UN PUNTERO

Hay varias maneras de inicializar un puntero. Una ya ha sido vista en los ejemplos
del punto anterior ( pchar = &a; ); y al igual que el resto, consiste bsicamente en
lo mismo; asignar una direccion de memoria al puntero. Para hacer un paralelismo
Modula-2 - C, en C existe el equivalente al procedimiento NEW; la funcin malloc:

#include <stdio.h>
#include <malloc.h>

void *malloc( size_t size );


Donde 'size' es el nmero de bytes que queremos reservar de tipo 'void', es decir,
de cualquier tipo.

char *pchar;
int *pint;

pchar = malloc (6); /* pchar apunta al primer byte de los que se han
reservado */
pint = malloc (sizeof(int)*2);
/* pint apunta al primero de los dos enteros
que se han reservado */
Otra forma es inicializarlo con el valor de otro puntero.

.
.
.
int *pint2;

pint2 = pint;

GENERACIN DE CDIGO

Para comprender mejor algunos de los errores que se describen en la siguiente


seccin, es necesario tener algunas nociones sobre generacin de cdigo y
tratamiento de la memoria que realizan los compiladores.

Empecemos por los distintos espacios de memoria existentes: la pila y el heap.

39
La pila es el espacio de memoria donde se reservan todas las variables locales y
globales; esto significa que cada vez que se llama a una funcin, sus variables se
crean en tiempo de ejecucin en la pila, y se destruyen en cuanto el flujo de
ejecucin retorna al punto en que se llam a la funcin.

El heap (o montn) es el espacio de memoria destinado a las peticiones explicitas


de memoria (malloc en el caso del C) y solo se pierde cuando se libera la memoria
pedida.

El desconocimiento de estos espacios de memoria lleva a la generacion de errores


totalmente 'mgicos' ("...yo he reservado el espacio y ya no est..." y similares).
Algunos de estos errores pasamos a describirlos ms adelante.

ERRORES MS COMUNES

AVISO: Si careces de conocimientos sobre la generacion de cdigo, lee la seccin.

PRIMER CASO

En el siguiente ejemplo se ilustra la inicializacin de un puntero a travs de una


funcin.

void inicializa( char *buffer );


main()
{
char *buff;
.
.
.
buff = NULL;
inicializa( buff );
/* en este punto sigue valiendo NULL */
.
.
.
}
void inicializa( char *buffer )
{
buffer = malloc (1); /* reservamos memoria */
*buffer = 'a'; /* y la inicializamos */
}

40
.
.
.
Por que es incorrecta la inicializacin? Analicemos la pila al realizar la llamada:
| |
SP --->+---------------+
| copia de buff | <------- Parmetro pasado a inicializa()
+---------------+
| @ de retorno |
+---------------+ <------- Hasta aqu llega la pila antes de
| buff = NULL | llamar a inicializa()
+---------------+
| resto de vars |
| locales al |
| main |
+---------------+
Tras la llamada tenemos lo siguiente en la pila
| |
+---------------+
| @ de 'a' |
+---------------+
| @ de retorno |
SP --->+---------------+
| buff = NULL |
+---------------+
| resto de vars |
| locales al |
| main |
+---------------+
y 'buff' sigue valiendo NULL, ya que en la Funcion 'inicializa' lo nico que se ha
modificado es la copia de 'buff' que se ha pasado como parmetro en la pila.
La forma correcta de hacerlo es declarando la Funcion as:

void inicializa ( char **buffer);


main()
{
char *buff;
.
.
.
buff = NULL;
/* y pasando buff por referencia */
inicializa ( &buff );
/* ahora *buff = 'a' */

41
.
.
.
}
void inicializa ( char **buffer)
{
*buffer = malloc (1);
*buffer = 'a';
}
.
.
.
ya que la pila ahora queda de la siguiente forma tras la llamada:
| |
+---------------+
| @ de buff |
+---------------+
| @ de retorno |
SP --->+---------------+
| *buff = 'a' |
+---------------+
| resto de vars |
| locales al |
| main |
+---------------+

SEGUNDO CASO

Ahora volvemos a hacer lo mismo de otra manera que parece correcta

char *inicializa();
void otra_funcion();
main()
{
char *buff;
.
.
.
buff = NULL;
buff = inicializa();
/* hasta aqui todo parece correcto */
otra_funcion();
/* aqui ya no se puede asegurar buff = "hola"*/

42
.
.
.
}
char *inicializa()
{
char buffer[5];
sprintf(buffer,"hola");
return(buffer);
}
.
.
.
Volvamos a analizar la pila:
| |
SP --->+---------------+
| 5 bytes para | <------- Espacio reservado para la variable
| buffer | local buffer
+---------------+
| @ de retorno |
+---------------+
| buff = NULL |
+---------------+
| resto de vars |
| locales al |
| main |
+---------------+
Cuando la funcion retorna tenemos la siguiente situacin:
| |
+---------------+
| "hola\0" | @ base de 'buffer'
+---------------+
| @ de retorno |
SP --->+---------------+
| buff= @buffer |
+---------------+
| resto de vars |
| locales al |
| main |
+---------------+
En cuanto se llama a otra funcin, el espacio destinado a 'buffer' es destinado a
parmetros de la llamada o a las variables locales de la funcin invocada, con lo
que "hola\0" ser machacado por otros valores. Solo funcionaria si el resto de
funciones invocadas no tuvieran ni parmetros ni variables locales.

43
La forma correcta de hacerlo sera:

char *inicializa();
main()
{
char *buff;
.
.
.
buff=inicializa();
.
.
.
}
char *inicializa()
{
char *buffer;
buffer = malloc (5);
sprintf(buffer,"hola");
return (buffer);
}
.
.
.
ya que tendramos la siguiente disposicin en memoria:
PILA HEAP
| | | |
+---------------+ | |
| @ de "hola\0" | --------------+ | |
+---------------+ | | |
| @ de retorno | | | |
SP --->+---------------+ | | |
| buff | --------------+ | |
+---------------+ | +-----------------+
| resto de vars | +----->| "hola\0" |
| locales al | +-----------------+
| main | | |
+---------------+ | |

TERCER CASO

El caso ms trivial de todos: no reservar espacio creyendo que la declaracin del


puntero ya lo hace por s misma.

44
La cuestin es que este error algunas veces pasa por alto, sobre todo en mquinas
gobernadas por un SO sin proteccin de memoria, caso de los PC's con MS-DOS.
En una maquina Unix tambin puede ocurrir si el valor del puntero cae dentro de
nuestro espacio de memoria, con lo que el problema llega a ser muy grave y
prcticamente indetectable sin la utilizacin del debugger.

Ejemplo:

main()
{
char *pchar;
int *pint;
*pchar='a';
printf("Direccion de 'a': %p",pchar);
pint=malloc(sizeof(int));
*pint=0;
/* Ahora lo apuntado por pchar puede haber cambiado de valor */
}

CONCLUSIONES

En el proyecto realizado, se logr recabar informacin para saber cules son las
deficiencias en cuanto a programacin que tienen algunos alumnos de ESIME
Culhuacn con el fin de poder con nuestro proyecto hacer que los alumnos cuenten
con ms conocimiento acerca de programacin con el fin de cuenten con una
programacin bsica de manera que les sea de ayuda para poder lograr entender
otros sistemas de programacin logrando nuestro objetivo principal el cual es que
los alumnos no tengan deficiencias en cuanto conocimiento.

45

Potrebbero piacerti anche