Sobre Lenguaje C 14 Páginas PDF

INTRODUCCIÓN AL LENGUAJE DE PROGRAMACIÓN C
El lenguaje C fue creado por Dennis Ritchie (1941 – 2011) entre 1969 y 1972 en los
Laboratorios Bell.
En 1978, los científicos de la computación Dennis Ritchie y Brian Kernighan (1942 - )
escribieron un libro que se volvió referencia obligada en el campo de la computación: El
lenguaje de programación C.
C se volvió rápidamente un lenguaje de propósito general, a pesar de haberse creado para

implementar el sistema operativo Unix. De ahí sus características de lenguaje de bajo
nivel, que no son comunes en los de alto nivel. Un lenguaje se denomina de bajo nivel
cuánto más cerca esté a la máquina (lenguaje binario) y de alto nivel cuanto más cerca
esté del ser humano (programador).
A continuación, se hará una introducción al lenguaje de programación C, inicialmente en
paralelo con el lenguaje algorítmico que se utiliza en el libro. Se explicará lo estrictamente
necesario para empezar a programar y adquirir la base necesaria para profundizar en este
lenguaje o para programar en otro.
Estructura de un programa en lenguaje C

Directivas al compilador
int main( )
{
Cuerpo del programa
}
Las directivas al compilador que interesan en la introducción al lenguaje C son:

- #include que sirve para incluir archivos de extensión h que contienen
especificaciones de rutinas que ya están definidas para poder usarlas en los programas.
La sintaxis es:
#include archivo entre < y > o entre comillas.
Apéndice: Lenguaje C. Aprendiendo a programar a partir de cero. Patricia Salazar Perdomo. ESCUELA COLOMBIANA DE INGENIERÍA.
Ejemplo.
#include <stdio.h>
#include <stdlib.h>
Estos archivos de extensión h están en la carpeta include del compilador. También se

pueden incluir archivos propios y en este caso el nombre se pone entre comillas.
- #define que sirve para definir constantes figurativas o simbólicas. La sintaxis es:
#define nombre_de_la_constante valor_constante
Ejemplo.
#define PI 3.1415 // PI es la constante que representa un valor aproximado de π
#define MCE 50 // MCE representa la máxima cantidad de empresas
#define CT ‘*’ // CT representa el carácter de terminación de un texto
#define INST “Escuela Colombiana de Ingeniería”
En el programa, se utilizarían estas constantes según el tipo:

Constante Tipo Formato de escritura
PI Real %f
MCE Entera %d
CT Caracter %c
INST Cadena de caracteres %s
Se estila nombrar las variables con minúsculas y las constantes con mayúsculas.
El cuerpo del programa empieza con la declaración de variables cuya sintaxis es:
Tipo_de_dato variable o lista de variables;
Con punto y coma terminan todas las declaraciones e instrucciones o invocación a rutinas.
Los encabezados de las estructuras de control condicionales no terminan con punto y
coma salvo que se haga a conciencia como se verá en un ejemplo, más adelante.
Comentarios
Los comentarios se indican con doble slash (//) al principio y de ahí hasta el final de la
línea es tomado como tal. O también con /* para empezar y */ para terminar. Esta última
forma permite hacer comentarios de varias líneas señalando sólo el principio y el final de
éste. En los ejemplos se verá su uso.
En la siguiente tabla se contrasta lo básico del lenguaje algorítmico con el lenguaje C.
LENGUAJE ALGORÍTMICO LENGUAJE C

Estructura de un algoritmo Estructura de un programa
#include <stdio.h>
“nombre del algoritmo” #include <stdlib.h>
empiece
** Cuerpo del algoritmo int main(void)
pare {
termine // Cuerpo del programa
system (“pause”); // No siempre es necesario
}
Tipos de variables
entero Int
real float (o double)
caracter char
cadena_de char
Operador de asignación
 =
Estructura condicional si simple
si (condición o condiciones) instrucción if (condición o condiciones) instrucción;
Conectores lógicos Conectores lógicos
y &&
ó ||
Operadores relacionales Operadores relacionales
>, ≥, <, ≤, =, ≠ >, >=, <, <=, ==, !=
Estructura condicional si de bloque
si (condición o condiciones) entonces if (condición o condiciones)
** cuerpo del si { ** Estos corchetes se necesitan sólo si hay más de una instrucción
fin_si ** cuerpo del if
}
si (condición o condiciones) entonces
** cuerpo del si if (condición o condiciones)
si_no { ** Estos corchetes se necesitan sólo si hay más de una instrucción
** cuerpo del si_no ** cuerpo del if
fin_si }
else
{ ** Estos corchetes se necesitan sólo si hay más de una instrucción
** cuerpo del else
}
Estructura condicional mq
mq (condición o condiciones) haga while (condición o condiciones)
** cuerpo del mq {
fin_mq ** Estos corchetes se necesitan sólo si hay más de una instrucción
** cuerpo del while
}
Instrucciones de entrada o salida
lea variable scanf(“formato”, dirección de la variable);
Ejemplo: lea sueldo
Ejemplo: scanf (“%d”, &sueldo); // %d: entero, %f: real, %c: caracter: %s: cadena
El operador de dirección & se pone sólo si la variable no es una
dirección. En este momento, sólo si se está pidiendo un entero, un real
o un caracter.
escriba “mensaje” printf(“mensaje”);
escriba variable printf(“mensaje y formatos correspondientes a las variables de la lista,
escriba variable, “mensaje”… asociados de izquierda a derecha y en el lugar que se quiere que
escriba “mensaje”, variable… aparezcan”, lista de variables);
Ejemplos: Ejemplos:
escriba “Colombia” printf (“Colombia”);
escriba “La suma de”,a,” y “,b,” es ”,suma,”.” printf (“La suma de %f y %f es %f.”,a, b, suma);
escriba a,” + “,b,” = ”,suma,”.” printf (“%f + %f = %f.”,a, b, suma);
Instrucciones de entrada y salida

Para empezar, se hará entrada y salida con formato.
- Instrucción de salida printf
La sintaxis es: printf (“formato”, lista_de_variables);
Puede tener una de las dos siguientes formas:
printf (“mensaje”);
Ejemplo. printf (“Colombia”);
printf(“mensaje y formatos correspondientes a las variables de la lista, asociados de
izquierda a derecha y en el lugar que se quiere que aparezcan”, lista de variables);
Ejemplos.
printf (“La suma de %f y %f es %f.”, a, b, suma);
// Formato  %d: entero, %f: real, %c: caracter: %s: cadena
Si a vale 5, b vale 11 y c vale 16, escribirá en la pantalla:
La suma de 5 y 11 es 16.
printf (“%f + %f = %f.”, a, b, suma);

Escribirá 5 + 11 = 16.
- Instrucción de entrada scanf
La sintaxis es: scanf(“formato”, dirección_de_la_variable);
Ejemplo.
scanf (“%d”, &sueldo); // Formato  %d: entero, %f: real, %c: caracter: %s: cadena
El operador de dirección & se pone sólo si la variable no es una dirección. En este

momento, sólo si se está pidiendo un entero, un real o un caracter. Más adelante,
cuando se aborde la programación modular en lenguaje C, se explicará el uso del
operador.
Se recomienda poner sólo el formato correspondiente al tipo de variable. Es decir, no

incluir, por ejemplo, cambios de línea (\n) o tabuladores (\t).
La estructura de control no repetitiva if
La sintaxis de esta estructura es:

if (condición)
{
Cuerpo del if
}
Si al cumplimiento de la condición se asocia sólo una instrucción (if simple):
if (condición) instrucción;
Los corchetes son obligatorios sólo si el cuerpo de la estructura está formado por más de
una instrucción.
Si la estructura tiene la opción else entonces ésta es la sintaxis:
if (condición)
{
Cuerpo del if
}
else
{
Cuerpo del else
}
Obsérvese que, si el cuerpo del else tiene más de una instrucción, se deben poner entre
corchetes, los cuales son independientes de los del cuerpo del if.
Ejemplo. Asignar a la variable mayor el mayor de dos números a y b. Si son iguales, se

asignará cualquiera de ellos.
if (a > b)
mayor = a;
else
mayor = b;
La estructura de control repetitiva while
La sintaxis de esta estructura es:
while (condición)
{
Cuerpo del while
}
Si el cuerpo está conformado por una sola instrucción, no se necesitan los corchetes.
Se ejecutan cero o más iteraciones según la cantidad de veces que se cumpla la

condición.
Ejemplo. Escribir los números de 1 a n.
num = 1;
while (num <= n)
{
printf ("%d “, num);
num++;
}
La estructura de control repetitiva for
Esta estructura es similar a la estructura repetitiva para del lenguaje algorítmico pero es
mucho más versátil.
La sintaxis es:
for (Inicialización; Condición; Modificación de variables)

{
Cuerpo del for
}
 Inicialización: es lo primero que se hace, independiente de que haya iteraciones. Se
pueden inicializar una o más variables; si es más de una, se separan con coma (,).
Recuérdese que una iteración es la ejecución del cuerpo de una estructura repetitiva.
 Condición: debe cumplirse para que haga una iteración. Si se tiene más de una
condición, se conecta con y (&&) o con o (||), según corresponda.
 Modificación de variables: se hacen los cambios necesarios a las variables antes de
la próxima iteración. Si se modifica más de una variable, se separan con coma (,)
En el encabezado siempre debe haber dos puntos y comas (;) que separan las tres partes
que lo componen.
Ejemplo. Escribir los números de 1 a n.
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int num, lim;
printf ("\n\nEscribo los números desde 1 hasta donde me indique.");
printf ("\n\n¿Hasta dónde quiere que los escriba (se espera un valor positivo)? ");
scanf ("%d", &lim);
printf ("\n\nLos números de 1 a %d son: ", lim);
for (num = 1; num <= lim; num++)
{
printf ("%d ", num);
}
printf ("\n\n\t\tTrabajo terminado.\n\n");

}
Supóngase que el usuario quiere los números de 1 a 3 (lim vale 3).
1. Se hace la asignación num = 1;

2. ¿num <= 3? Sí
Se escribe num
3. Se incrementa la variable num en 1. (num queda con valor 2)
4. Se vuelve al paso 2. Cuando deje de cumplirse la condición, sale de la estructura
for.
En el ejemplo, el for solamente tiene una instrucción. En ese caso sobran los corchetes
que agrupan el cuerpo de la estructura repetitiva.
Obsérvese que el paso 1 siempre se hace y sólo una vez. Si el usuario ingresara 0 o un
número negativo, inmediatamente después del for la variable num valdría 1.
La estructura de control repetitiva do - while
Esta estructura es similar a la estructura while salvo que siempre se ejecuta al menos una
iteración.
La sintaxis es.
do
{
Cuerpo del do - while
}
while (condición);
En la estructura se observa que, al empezar, el cuerpo se ejecuta antes de preguntar si la

condición se cumple. Por esta razón, mínimo se ejecuta una iteración. Las iteraciones de
ahí en adelantes sí están sujetas a que la condición se cumpla. Obsérvese que la estructura
termina con punto y coma (;).
Los corchetes se requieres si el cuerpo del do – while tiene más de una instrucción.
Esta estructura es muy útil para pedir un dato y validarlo o para trabajar con menús ya
que estos hay que mostrarlos al menos una vez.
Ejemplo. Pedir la cantidad de elementos de un conjunto y asegurarse de que ésta

pertenezca al intervalo [1, 100].
do
{
printf ("Cantidad de elementos del conjunto (entre 1 y 100) ");
scanf("%d", &num);
}
while (num < 1 || num > 100);
Vectores
Los vectores se usan igual que en el lenguaje algorítmico pero se usan paréntesis
cuadrados en lugar de paréntesis. Hay que dimensionarlos con una constante entera
positiva. Se recomienda definir la constante con la directiva #define porque en caso de
que ese valor cambie, bastará con hacerlo en la definición.
Las posiciones van desde 0 hasta la dimensión definida menos 1. Mientras no se inicialice,
el valor en cada una de sus posiciones es desconocido, no es cero.
Ejemplo. Llenar un vector y luego escribirlo.
#include <stdio.h>
#include <stdlib.h>
#define TM 20 // El tamaño máximo del vector es 20
int main(void)
{
int vector[TM], cn, pos; // El vector se dimensiona de 20 posiciones. TM representa ese valor.
printf ("\n\n¡Hola! Este programita pide números y los escribe.\n\n");
cn = -1;
while (cn < 1 || cn > TM)
{
printf ("Cantidad de números (entre 1 y %d) ", TM); // Se usa TM en la validación, es decir 20.
scanf("%d",&cn);
}
printf("\nIngreso de los números\n\n");
for (pos=0; pos < cn; pos++){
printf("\nNúmero #%d = ", pos+1);
scanf ("%d", &vector[pos]);
}
printf("\n\nNúmeros ingresados\n\n");
for (pos=0; pos < cn; pos++)
printf("%d ", vector[pos]);
printf("\n\nFin.\n\n");
system ("pause");
}
Programación modular
En lenguaje C, el “director de orquesta” es la rutina main. En lenguaje algorítmico es el

algoritmo llamado maestro. Es decir, desde el cual se da inicio a la ejecución del programa
ya que no lo conforma una sola rutina.
El siguiente programa suma dos números. Con base en éste, se explican las características
de un programa en lenguaje C.
Al lado derecho aparecen los entornos de memoria correspondientes a una prueba de
escritorio que se le hizo con el siguiente espacio de memoria, el cual se utiliza de izquierda
a derecha y de arriba hacia abajo, estrictamente. Cada dirección corresponde a un byte y
se supone que un entero ocupa 8 bytes, un apuntador 4 y que la memoria que se libera se
asigna en la primera oportunidad que se da. Un caracter ocupa un byte.
En la columna Clase se pone VL (variable local), PV (parámetro por valor) o PR
(parámetro por referencia) según corresponda.
FE84 FE85 FE86 FE87 FE88 FE89 FE8A FE8B FE8C FE8D
FE8E FE8F FE90 FE91 FE92 FE93 FE94 FE95 FE96 FE97
FE98 FE99 FE9A FE9B FE9C FE9D FE9E FE9F FEA0 FEA1
FEA2 FEA3 FEA4 FEA5 FEA6 FEA7 FEA8 FEA9 FEAA FEAB
FEAC FEAD FEAE FEAF FEB0 FEB1 FEB2 FEB3 FEB4 FEB5
FEB6 FEB7 FEB8 FEB9 FEBA FEBB FEBC FEBD FEBE FEBF
FEC0 FEC1 FEC2 FEC3 FEC4 FEC5 FEC6 FEC7 FEC8 FEC9
FECA FECB FECC FECD FECE FECF FED0 FED1 FED2 FED3
FED4 FED5 FED6 FED7 FED8 FED9 FEDA FEDB FEDC FEDD
FEDE FEDF FEE0 FEE1 FEE2 FEE3 FEE4 FEE5 FEE6 FEE7
FEE8 FEE9 FEEA FEEB FEEC FEED FEEE FEEF FEF0 FEF1
FEF2 FEF3 FEF4 FEF5 FEF6 FEF7 FEF8 FEF9 FEFA FEFB
FEFC FEFD FEFE FEFF FF00 FF01 FF02 FF03 FF04 FF05
FF06 FF07 FF08 FF09 FF0A FF0B FF0C FF0D FF0E FF0F
FE10 FE11 FE12 FE13 FE14 FE15 FE16 FE17 FE18 FE19
#include <stdio.h>
Entorno - lee
#include <stdlib.h> Variable Tipo Clase Dirección Contenido
x int * PR FE9C FE84
int main(void)
{ y int * Entorno
PR FEA0
– main FE8C
Variable Tipo Clase Dirección Contenido
int a,b,c; Entorno - suma
// Prototipos a int VL FE84 ? 14
void lee(int *, int *); b
x int
int VL
PV FE8C
FE9C ?14-35
void suma(int, int, int *); cy int
int VL
PV FE94
FEA4 ?-35
-21
void resul(int, int, int);
z int * PR FEAC FE94
void desp(void);
// Invocaciones o llamados
lee(&a, &b);
suma(a, b, &c);
resul(a, b, c);
desp( );
}
// Definiciones
void lee(int * x, int * y)

{
printf(“\nDé su primer sumando “);
scanf (“%d”, x);
printf(“\nDé su segundo sumando “);
scanf (“%d”, y);
}
void suma(int x, int y, int * z)

{
*z = x + y;
}
void resul(int x, int y, int z)

Entorno - resul
{
printf(“\n%d + %d = %d”,x, y, z);
} x int PV FE9C 14
y int PV FEA4 -35
void desp(void) z int PV FEAC -21
{
printf(“\nFin del ejemplito\n\n”);
}
Primero que todo, en lenguaje C se invoca o llama una rutina sólo con su nombre. No
necesita el llame_a (call) del lenguaje algorítmico.
Existen los prototipos que son declaraciones de las rutinas, y como tales, van en la zona
de declaraciones, esto es, al principio.
Ejemplos.
void suma(int, int, int *);
void resul(int, int, int);
void desp(void);
Los prototipos dan dos tipos de información de las rutinas:
- Si es procedimiento o función. Cuando la declaración de la rutina empieza con void
indica que es procedimiento. Más adelante se verá la diferencia con una función. Así
que, por ahora, todos los prototipos empezarán con la palabra void.
- Cómo son los argumentos (cuando se invocan las rutinas) y, por tanto, cómo son los
parámetros (cuando se reciben los argumentos en las rutinas). Esto ayuda a verificar
en la etapa de compilación que los argumentos correspondan con los parámetros en
cantidad y en tipo, asociados de izquierda a derecha.
Si se invoca una rutina con tres argumentos, los dos primeros de tipo entero y el
tercero real, entonces en la definición de ésta deberá haber tres parámetros, los dos
primeros de tipo entero y el tercero real. Importante tener presente que mientras los
argumentos pueden ser expresiones, los parámetros tienen que ser variables.
En la siguiente tabla se muestra cada prototipo del programa ejemplo y lo que indica:
Ejemplo de Encabezado de la
Prototipo Descripción
invocación rutina
void resul(int, int, int); La rutina resul es un resul(a, b, c); void resul(int x, int y, int z)
procedimiento que al ser llamado
debe enviar 3 argumentos, por
valor y todos de tipo entero. Los
parámetros serán 3 variables,
todas de tipo entero.
void desp(void); La rutina desp es un desp( ); void desp(void);
procedimiento sin argumentos y
por tanto sin parámetros.
void suma(int, int, int *); La rutina suma es un suma(a, b, &c); void suma(int x, int y, int * z)
procedimiento con dos
argumentos por valor, de tipo
entero, y uno por referencia.
void lee(int *, int *); La rutina lee es un procedimiento lee(&a, &b); void lee(int * x, int * y)
con dos argumentos por
referencia.
Argumentos por valor

Se pasa un valor o una copia del valor de una variable. En el segundo caso, desde esa
rutina no es posible modificar su contenido en la que la invocó.
Ejemplo. resul(a, b, c);
Los tres argumentos se pasan por valor. Si en suma se modificara el valor del parámetro
x, al argumento a, en main, no le afectaría esa modificación.
Argumentos por referencia

Se pasa la dirección de la variable. Desde esa rutina se puede modificar su contenido en
la que la invocó.
Ejemplo 1. lee(&a, &b);
Los dos argumentos se pasan por referencia. En lee se ingresarán los dos valores y éstos
serán los de a y b en main, que es la rutina que llamó a lee.
Ejemplo 2. suma(a, b, &c);

Los argumentos a y b son pasados por valor y c es pasado por referencia. En la rutina
suma se modifica el valor de c con la suma de a y b.
Nota. Los argumentos y los parámetros de una rutina tienen que coincidir en cantidad y
tipo pero no en nombre.
Apuntador
Un apuntador es una variable que puede contener la dirección de una variable. Cuando
no ha sido inicializada, su contenido es NULL.
Las variables, además de nombre, tipo y contenido, tienen una dirección de memoria. A
su dirección se accede con el operador de dirección &.
Cuando un argumento es entero, el parámetro tiene que ser una variable entera. Lo mismo
si es real o caracter. Cuando el argumento es por referencia, lo que se envía es la dirección
de la variable y por tanto el parámetro tiene que ser un apuntador.
A continuación, se presentan dos ejemplos de prototipo, invocación (o llamado) y

definición. Obsérvense los entornos correspondientes a una prueba de escritorio hecha al
programa ejemplo.
Ejemplo 1.
Prototipo: void lee(int *, int *);

Indica que al invocar el procedimiento lee, se enviarán las
direcciones de dos variables de tipo entero y que por tanto los
parámetros deben ser apuntadores a entero.
Invocación: lee(&a, &b);
Se envían las direcciones de las variables enteras a y b. Coincide
con lo que dice el prototipo.
Definición: void lee(int * x, int * y)

En el encabezado de la definición del procedimiento lee, los dos
parámetros x y y son apuntadores a enteros. La variable x tendrá la
dirección de a y la variable y la dirección de b. Coincide con el
prototipo y con la invocación.
A scanf siempre se le pasa como argumento la dirección cuyo

contenido se va a modificar. Es por esto que en la rutina lee aparece
scanf (“%d”, x) y no scanf (“%d”, &x). Obsérvese que la
modificación debe afectar el contenido de la variable a en main y
no del parámetro x en lee. Al pasar x, se está enviando la dirección
FE84 y por tanto el 14 quedará en a y no en x.
Entorno – main
a int VL FE84 ? 14
b int VL FE8C ? -35
c int VL FE94 ?
void lee(int * x, int * y)

{
printf(“\nDé su primer sumando “);
scanf (“%d”, x);
printf(“\nDé su segundo sumando “);
scanf (“%d”, y);
}
Si en lee se tuviera scanf (“%d”, &x), en la ejecución se

produciría un error porque se estaría intentando guardar un entero
en x, una variable que es un apuntador y cuyo contenido tiene que
ser una dirección.
Ejemplo 2.
Prototipo: void suma(int, int, int *);

Indica que al invocar el procedimiento suma, se enviarán dos
enteros y la dirección de un entero. Por tanto, los parámetros deben
ser dos variables de tipo entero y un apuntador a entero.
Invocación: suma(a, b, &c);

Se envían dos enteros, los que haya en las variables a y b, y la
dirección de la variable entera c. Coincide con lo que dice el
prototipo.
Definición: void suma(int x, int y, int * z)

En el encabezado de la definición del procedimiento suma, los
parámetros x y y son
enteros y el Entorno - lee
parámetro z es un x int * PR FE9C FE84
apuntador a entero. y int * PR FEA0 FE8C
La variable x tendrá
una copia de a, la variable y, una copia de b, y la variable z, la
dirección de c. Coincide con el prototipo y con la invocación.
La suma de a y b debe quedar en la variable c de main. En la rutina

suma se tiene su dirección, en el apuntador del mismo nombre.
Para acceder a su contenido, se utiliza el operador de contenido *.
Entorno – main
a int VL FE84 ? 14
b int VL FE8C ? -35
c int VL FE94 ? -21
void suma(int x, int y, int * z)

{
*z = x + y;
}
La variable z contiene la dirección FE94, así que la suma quedará

en el contenido de esa dirección. Es decir, en la variable entera c
de la rutina main.
La asignación que se tiende a hacer inicialmente es z = x + y. Se
estaría ordenando que la suma de los números quede en z cuando
debe ser en la variable c de main. Adicionalmente, z es un
apuntador y su contenido tiene que ser una dirección, no un entero.
Ejemplo. Escribir una secuencia de números de acuerdo con un número entero dado por
el usuario.
Caso 1. Si el usuario da 5, escribe 5 44 333 2222 11111
Caso 2. Si el usuario da 8, escribe 8 77 666 5555 44444 333333 2222222 11111111
#include <stdio.h>
#include <stdlib.h>
int main(void)
{ Entorno - suma
int n; Variable Tipo Clase Dirección Contenido
void entrada(int *); x int PV FE9C 14
void secuencia(int); y int PV FEA4 -35
z int * PR FEAC FE94
entrada(&n);
secuencia(n);
printf ("\nF I N.\n\n");
}
void entrada(int * n)
{
printf ("\nEscribo una secuencia de números de acuerdo con un número entero dado por el
usuario. \nCaso 1. Si el usuario da 5, escribe 5 44 333 2222 11111. \n Caso 2. Si el usuario da 8,
escribe 8 77 666 5555 44444 333333 2222222 11111111. Para qu%c n%cmero la quieres >> ", 130,
163);
scanf("%d", n);
}
void secuencia(int n)
{
int valor, veces;
void escr_numeros(int, int);
valor = n;
veces = 1;
while (valor >= 1)
{
escr_numeros(valor, veces);
valor--;
veces++;
}
}
void escr_numeros(int valor, int veces)

{
int cont = 1;
while (cont <= veces)
{
printf("%d ",valor);
cont++;
}
printf(" ");
}

Sobre Lenguaje C 14 Páginas PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Sobre Lenguaje C 14 Páginas PDF

Cargado por

Copyright:

Formatos disponibles

INTRODUCCIÓN AL LENGUAJE DE PROGRAMACIÓN C

C se volvió rápidamente un lenguaje de propósito general, a pesar de haberse creado para

Estructura de un programa en lenguaje C

Las directivas al compilador que interesan en la introducción al lenguaje C son:

Estos archivos de extensión h están en la carpeta include del compilador. También se

En el programa, se utilizarían estas constantes según el tipo:

LENGUAJE ALGORÍTMICO LENGUAJE C

Instrucciones de entrada y salida

La sintaxis es: printf (“formato”, lista_de_variables);

Puede tener una de las dos siguientes formas:

printf (“%f + %f = %f.”, a, b, suma);

- Instrucción de entrada scanf

La sintaxis es: scanf(“formato”, dirección_de_la_variable);

El operador de dirección & se pone sólo si la variable no es una dirección. En este

Se recomienda poner sólo el formato correspondiente al tipo de variable. Es decir, no

La estructura de control no repetitiva if

La sintaxis de esta estructura es:

Si al cumplimiento de la condición se asocia sólo una instrucción (if simple):

Si la estructura tiene la opción else entonces ésta es la sintaxis:

Ejemplo. Asignar a la variable mayor el mayor de dos números a y b. Si son iguales, se

La estructura de control repetitiva while

La sintaxis de esta estructura es:

Se ejecutan cero o más iteraciones según la cantidad de veces que se cumpla la

Ejemplo. Escribir los números de 1 a n.

for (Inicialización; Condición; Modificación de variables)

printf ("\n\n\t\tTrabajo terminado.\n\n");

Supóngase que el usuario quiere los números de 1 a 3 (lim vale 3).

1. Se hace la asignación num = 1;

La estructura de control repetitiva do - while

En la estructura se observa que, al empezar, el cuerpo se ejecuta antes de preguntar si la

Ejemplo. Pedir la cantidad de elementos de un conjunto y asegurarse de que ésta

En lenguaje C, el “director de orquesta” es la rutina main. En lenguaje algorítmico es el

void lee(int * x, int * y)

void suma(int x, int y, int * z)

void resul(int x, int y, int z)

Argumentos por valor

Ejemplo. resul(a, b, c);

Argumentos por referencia

Ejemplo 1. lee(&a, &b);

Ejemplo 2. suma(a, b, &c);

A continuación, se presentan dos ejemplos de prototipo, invocación (o llamado) y

Prototipo: void lee(int *, int *);

Definición: void lee(int * x, int * y)

A scanf siempre se le pasa como argumento la dirección cuyo

void lee(int * x, int * y)

Si en lee se tuviera scanf (“%d”, &x), en la ejecución se

Prototipo: void suma(int, int, int *);

Invocación: suma(a, b, &c);

Definición: void suma(int x, int y, int * z)

La suma de a y b debe quedar en la variable c de main. En la rutina

void suma(int x, int y, int * z)

La variable z contiene la dirección FE94, así que la suma quedará

Caso 2. Si el usuario da 8, escribe 8 77 666 5555 44444 333333 2222222 11111111

void escr_numeros(int valor, int veces)

También podría gustarte

Prototipo: void lee(int , int );