TIPO DE DATOS

TIPO DESCRIPCIÓN MEMORIA

int Entero 2 bytes
char Carácter 1 byte
float Número de punto flotante (número que incluye 1 palabra (4 bytes)
punto decimal y/o exponente)
double Número de punto flotante de doble precisión (más 2 palabras (8 bytes)
cifras significativas y mayor valor posible del
exponente)

Algunos tipos básicos de datos se pueden ampliar usando los cualificadores de

tipos de datos short (corto), long (largo), signed (con signo), unsigned (sin signo)
Un unsigned int ocupa la misma memoria que un int con la diferencia que en un
int, el bit más a la izquierda se reserva para el signo. En un unsigned int, todos los
bits se utilizan para representar el valor numérico. Por ejemplo un int puede variar
de -32 768 a 32 767, en cambio un unsigned int varia de 0 a 65 535
Un dato tipo char puede tomar valores de 0 a 255 y signed char de -128 a 127
CONSTANTES ENTERAS
Una constante entera decimal puede ser cualquier combinación dígitos
tomados del conjunto de 0 a9. Si la constante tiene dos´o más dígitos, el
primero de ellos debe ser distinto de 0
Ejemplo:
0 1 743 5280 32767 9999
Los siguientes ejemplos son incorrectos:
12,245 carácter ilegal (,)
36.0 carácter ilegal (.)
10 230 carácter ilegal (espacio en blanco)
123-45-6789 carácter ilegal (-)
0900 El primer dígito no puede ser cero

Una constante entera octal puede estar formada por cualquier combinación de
dígitos tomados del conjunto de 0 a 7. el primer dígito deber ser
obligatoriamente 0, con el fin de identificar la constante como un número octal.
Ejemplo
0 01 0743 077777
Una constante entera hexadecimal debe comenzar por 0x ó 0X. Puede aparecer
después cualquier combinación de dígitos tomados del conjunto de 0 a 9 y de “a” a “f”
(tanto minúsculas como mayúsculas).
Ejemplo:
0x 0X1 0X7FFF 0Xabcd

Constantes de punto flotante

Es un número en base 10 que contiene un punto decimal o un exponente (o ambos)
Ejemplo:
0. 1. 0.2 827.602
5000. 0.000743 12.3 315.0066
2e-8 0.006e-3 1.6667E+8 .12121212e12

Constantes de carácter
Es un solo carácter encerrado con comillas simples
Ejemplo:
‘A’ ‘x’ ‘3’ ‘$’ ‘ ‘
Secuencias de escape
Una secuencia de escape siempre comienza con una barra \ y es seguida por uno o
más caracteres especiales.

Caracter Secuencia de escape Valor ASCII

sonido (bell) \a 007
backspace \b 008
tab horizontal \t 009
tab vertical \v 011
nueva línea \n 010
form feed \f 012
retorno de carro \r 013
comillas (“) \” 034
apóstrofo (‘) \’ 039
signo interrogación (?) \? 063
backslash (\) \\ 092
nulo \0 000
Constantes de cadena de caracteres
Una constante de cadena de caracteres consta de cualquier núLmero de caracteres
consecutivos (o ninguno) encerrados entre comillas (“)
Ejemplos:
“verde” “Washington, D. C. 200005” “270-32-3456”
“$19.95” “LA RESPUESTA CORRECTA ES:” “2*(I+3)/J”
“ “ “Linea 1\nLinea 2\nLinea 3” “”

VARIABLES Y ARRAYS
Una variable es un identificador que se utiliza para representar cierto tipo de
información dentro de una determinada parte del programa. En su forma más
sencilla, una variable contendrá un dato simple, esto es, una cantidad numérica o
una constante de carácter. En algún punto del programa se le asiginará a la variable
un determinado valor. Este valor se puede recuperar después en el programa con
simplemente hacer referencia al nombre de la variable.
A una variable se le pueden asignar diferentes valores en distintas partes del
programa, de esta forma la información representada por la variable puede cambiar
durante la ejecución del programa. Sin embargo, el tipo de datos asociado a la
variable no puede cambiar.
Ejemplo:
int a, b, c;
char d;
.
.
.
a = 3;
b = 5;
c = a + b;
d = ‘a’;
.
.
.
a = 4;
b = 2;
c = a - b;
d = ‘W’;
.
Conversiones explícita de tipos utilizando el operador de
conversión de tipos (cast)

Siempre que se quiera modificar, de forma temporal, el formato de una variable,

simplemente se coloca delante del identificador de la variable el tipo, entre
paréntesis, al que desea convertir el citado identificador.

int valor1, valor2;

float resultado;
valor1 = 7;
valor2 = 3;
resultado = valor1/valor2; // resultado = 2
resultado= (float) valor1/valor2 // resultado = 2.333333
OPERADORES
Incremento y decremento
Colocando el operador incremento (++) se aumenta en 1 al valor que tiene
almacenado la variable a la cual se aplica este operador.
En forma similar si se coloca el operadar decremento (--) se disminuye en 1 al valor de
la variable
Este operador se puede colocar antes o después de la variable. En una expresión
simmple no se nota la diferencia, pero en una expresión compleja, sí se nota.
Cuando este operador es colocado después de la variable, en la expresión, primero se
usa el valor de la variable y luego se incrementa en 1 a la variable; en cambio, cuando
es colocado a la izquierda de la variable, primero se incrementa el valor de la variable
en 1 y luego el nuevo valor se usa en la expresión.

Ejemplo:
int i=3, j k=0;

k= ++i; // i=4, k=4

k = i ++; // i=4, k=3
k= --i; // i=2, k=2
k= i--; // i=2, k=3
i=j=k-- // i=0, j=0, k=-1
OPERADORES ARITMÉTICOS
El lenguaje C, incorpora el conjunto, estándar de operadores aritméticos para la suma
(+), resta (-), multiplicación (*), división (/) y módulo (%)

Ejemplo 1.- Supongamos a = 10 y b = 3 entonces:

Expresión Valor

a+b 13
a–b 7
a*b 30
a/b 3
a%b 1

Ejemplo 2.- Supongamos v1 = 12.5 y v2 = 2.0 entonces

Expresión Valor
v1 + v2 14.5
v1 – v2 10.5
v1 * v2 25.0
v1 / v2 6.25
OPERADOR DE ASIGNACIÓN
La asignación se realiza mediante un operador de asignación (=). Se
puede utilizar una expresión con un operador de asignación en una
expresión más compleja, como puede ser:
valor1 = 8 * (valor2 = 5);
valor1 = valor2 = valor3 = 0;

OPERADORES DE ASIGNACIÓN COMPUESTA

Permiten expresar, de forma más concisa, ciertos cálculos.

a = a + 5 ----- a+= 5
b = b - c ----- b-= c
d = d*6 ---- d*=6
e = e/f ---- > e/= f
Operadores relacionales

Operador Significado
== Igualdad (No asignación)
!= Desigualdad
> Mayor que
< Menor que
<= Menor o igual que
>= Mayor o igual que
Ejemplo.- Supongamos i = 1, j = 2 y k = 3

Expresión Interpretación Valor

i<j cierto 1
(i + j) >= k cierto 1
(j + k) > (i + 5) falso 0
k != 3 falso 0
j == 2 cierto 1
 Operadores lógicos
Operador Significado
! NOT
&& AND
|| OR
Ejemplo.- i = 7, f = 5.5, c = ‘w’
Expresión Interpretación Valor
(i >= 6) && (c == ‘w’) cierto 1
(i >= 6) || (c == 119) cierto 1
(f < 11) && (i > 100) falso 0
(c != ‘p’) || ((i + f) <= 10) (cierto 1
! (i > (f + 1)) falso 0
int main( )
{
float foperando1, foperando2;

printf( “\nIntroduzca operando1 y operando2: “);

scanf(“%f%f”, &foperando1, &foperando2);

printf(“\n operando1 > operando2 es %d”, (foperando1>foperando2));

printf (“\n operando1 < operando2 es %d”, (foperando1<foperando2));
printf (“\n operando1 >= operando2 es %d”, (foperando1>=foperando2));
printf (“\n operando1 <= operando2 es %d”, (foperando1<=foperando2));
printf (“\n operando1 == operando2 es %d”, (foperando1==foperando2));
printf (“\n operando1 != operando2 es %d”, (foperando1!=foperando2));
printf (“\n operando1 && operando2 es %d”, (foperando1&&foperando2));
printf (“\n operando1 || operando2 es %d”, (foperando1||foperando2));
return(0);
}
Operador condicional
Syntaxis:
condición ? expresion_caso_verdadero : expresion_caso_falso

if (‘A’ <= c && c <= ‘Z’)

printf (“%c”, ‘a’ + c – ‘A’);
else
printf(“%c”, c);

printf(“%c”, (‘A’ <= c && c <= ‘Z’) ? (‘a’ + c – ‘A’) : c);

Operador coma
Evalúa dos expresiones donde la sintaxis permite sólo una, el valor del operador
coma es el valor de la expresión que aparece a la derecha del operador. El
formato de la expresión es:

expresión_izquierda , expresión_derecha

Normalmente, el operador coma se utiliza en los bucles for en que se itera más
de una variable. Por ejemplo:

for (min=0, max=longitud-1; min < max; min++, maxx--) {

.
.
.
}
 Entrada – Salida

#include "stdio.h“
int _tmain(int argc, _TCHAR* argv[])
{
char c = 'A',
ptam1[] = "Quien a buen árbol se arrima ",
ptam2[] = "buena sombra le cobija.";
int iln = 0,
ivalor = 1234;
double dpi = 3.14159265;

printf("\n[%2d] %c", ++iln, c); //imprime c

printf("\n[%2d] %d", ++iln, c); //imprime el codigo ASCII de c
printf("\n[%2d] %c", ++iln, c); //ancho minimo 1
printf("\n[%2d] %5c", ++iln, c); //ancho minimo 5, justificado a la derecha
printf("\n[%2d] %-5c", ++iln, c); //ancho minimo 5, justificado a la izquierda
printf("\n[%d] %s", ++iln,ptam1); //29 caracteres no nulos, automaticamente
printf("\n[%d] %s", ++iln,ptam2); //23 caracteres no nulos, automaticamente
printf("\n[%d] %5s", ++iln,ptam1); //ancho minimo 5, automaticamente, 29
printf("\n[%d] %34s", ++iln,ptam1); //ancho min. 34, justificado a la derecha
 printf("\n[%d] %-34s", ++iln,ptam1); //ancho min. 34, justificado a la izquierda
printf("\n[%d] %d", ++iln,ivalor); //ancho de ivalor por omision, 4
printf("\n[%d] %+d", ++iln,ivalor); //imprime ivalor con el signo +
printf("\n[%d] %3d", ++iln,ivalor); //ancho min. 3, automaticamente 4
printf("\n[%d] %10d", ++iln,ivalor); //ancho min. 10, justificado a la derecha
printf("\n[%d] %-10d", ++iln,ivalor); //ancho min. 10, justificado a la izquierda
printf("\n[%d] %010d", ++iln,ivalor); //justificado a la derecha, completado con ceros
printf("\n[%d] %f", ++iln,dpi); //utiliza el numero de digitos por omision
printf("\n[%d] %20f", ++iln,dpi); //ancho min. 20, justificado a la derecha
printf("\n[%d] %020f", ++iln,dpi); //justificado a la derecha, completado con ceros
printf("\n[%d] %-20f", ++iln,dpi); //ancho min. 20, justificado a la izquierda
printf("\n[%d] %.2s", ++iln,ptam1); //imprimer los 2 primeros caracteres
printf("\n[%d] %19.2s", ++iln,dpi); //imprime 2 caracteres, justificado a la deracha
printf("\n[%d] %-19.2s", ++iln,dpi); //imprime 2 caracteres, justificado a la izquierda
printf("\n[%d] %10.8f", ++iln,dpi); //ancho 10, con 8 decimales
printf("\n[%d] %20.2f", ++iln,dpi); //2 decimales y justificado a la derecha
printf("\n[%d] %-20.4f", ++iln,dpi); //4 decimales y justificado a la izquierda
printf("\n[%d] %20.2e", ++iln,dpi); //ancho 20 con notacion cientifica
return 0;
}
#include "stdafx.h"
#include "iostream.h"
inline long cuadrado(int iValor) {return iValor * iValor;}

int _tmain(int argc, _TCHAR* argv[])

{
int iValor = 5;
cout << cuadrado(iValor)
<< endl;
return 0;
}
 Funciones de Biblioteca

Biblioteca a
Nombre de
# Tipo  la cual Sintaxis Descripción Ejemplo
función
pertenece

Devuelve el valor
1 abs(i) int stdlib.h int abs(int i); x = abs(-7) // x es 7
absoluto de i
Devuelve el arco angulo = acos(0.5); // angulo
2 acos(d) double math.h double acos(double d);
coseno de d devuelto es phi/3
Devuelve el arco angulo = asin(0.707); //
3 asin(d) double math.h double asin(double d);
seno de d aproximadamente phi/4
Devuelve la arco
tangente de d.
Calcula el arco
double atan(double d);  tangente del angulo atan(1.0); // angulo es
4 atan(d) double math.h 
long double tanl(long double d); argumento x. phi/4
Requiere el llamado
de la biblioteca
complex.h
double atan(double d1, double Devuelve el arco
5 atan(d1, d2) double math.h angulo = atan(y, x)
d2); tangente de d1/d2
Convierte la cadena
s a una cantidad de double x; 
doble precisión. char *cad_dbl = "200.85"; ... 
6 atof(s) double stdlib.h double atof(const char *cadena)
Requiere el llamdo x=atof(cad_dbl); // convierte la
de la biblioteca cadena "200.85" a valor real
math.h
 Convierte la cadena s
int i; 
a un entero.  
char
La cadena debe tener
*cad_ent="123"; 
int atoi(const char el siguiente formato: 
7 atoi(s) int stdlib.h ... 
*cadena) [espacio en blanco]
i=atoi(cad_ent); 
[signo][ddd] (siendo
//convierte la cadena
obligatorio los digitos
"123" al entero 123
decimales).

Convierte la cadena s long int i; 

a un entero largo.  char
La cadena debe tener cad_ent="9876543"; 
long atol(const char el siguiente formato:  ... 
8 atol(s) long stdlib.h
*cadena); [espacio en blanco] i=atol(cad_ent); 
[signo][ddd] (siendo //convierte la cadena
obligatorio los digitos "9876543" al entero
decimales). largo

Reserva memoria
para una formación
de n elementos , cada
uno de s bytes.
malloc.h y stdlib.h  Devuelve un puntero long *buffer 
o bien  void *calloc(size_t n, al principio del buffer=(long *)
9 calloc(n, s) void(puntero)
alloc.h y  size_t s); espacio reservado.  calloc(40,
stdlib.h Si no existente sizeof(long));
bastante espacio para
el nuevo bloque o
bien n o s es 0, calloc
devuelve nulo.
 Devuelve un valor
double ceil(double redondeado por redondeo=ceil(5.1);
10 ceil(d) double math.h
d); exceso al siguiente //redondeo es 6
entero mayor

double cos(double
d);  Devuelve el coseno coseno_x=cos(1.65
11 cos(d) double math.h
complex de d 43)
cos(complex d);

double cos(double
d=1.00; 
d);  Devuelve el coseno
12 cosh(d) double math.h printf("d=
complex hiperbólico de d
%f.\n\n,d);
cos(complex d);

time_t inicio, fin; 

Devuelve la
clrscrl(); 
diferencia de
inicio=time(NULL)
tiempo 11(hora2) -
; 
double 12(hora1) , donde
delay(5000) 
difftime(time_t 11 y 12 representan
13 difftime(11, 12) double time.h fin=time(NULL) 
hora2, time_t el tiempo
print("Diferencia
hora1) transcurrido
en segundos:
despues de un
%f\n", 
tiempo base (ver
difftime(inicio,fin))
función time)
;
 Cierra todos los
archivos y buffers
y termina el
void exit(int programa. El valor
14 exit(u) void stdlib.h exit(0);
estado) de u es asignado
por la funcion para
indicar el estado de
terminación.

Eleve e a la
potencia d d=100.00; 
double exp(double
(e=2,7182818... es y=exp(d); 
d); 
15 exp(d) double math.h la base del sistema printf("El
complex
de logaritmos exponencial de x=
exp(complex d)
naturales %f.\n\n",y);
(neperianos))

double fabs(double Devuelve el valor y=fabs(-7.25); // y

16 fabs(d) double math.h
d); absoluto de d vale 7.25
 Inicio

Si Arcilla No
> 30
Si Arcilla No
> 20
Si limo
Si limo
> 50 Si Limo > 50
No > 50
No
arena No No
< 50
Si arena
≤ 50
Si Arena No No
≤ 50
arena No
Si ≤ 80
Si

1 2 3 4 5 6 7 8 9 10
Sentencia WHILE: 
La sentencia while (MIENTRAS,en español) es una sentencia usada en los
lenguajes de programación para repeticiones. Con esta sentencia se evalúa una
condición y se repite un determinado proceso hasta que la condición deje de  ser
 verdadera. 

Estructura: 

En lenguaje C++ la sentencia while se aplica se la siguiente manera: 

while(condición) 
{ 
// proceso 
} 

En la condición colocaremos la variable afectada por la condición. 

El proceso de realizara mientras que la condición sea verdadera. 
Ejemplo
#include<conio.h>
#include<stdio.h>

int nro;

main()
 {
   scanf("%d",&nro);
   while(nro<0)  //Se ejecuta el proceso mientras el número sea menor a
0.
   {
      printf("El número debe ser positivo");  //Corrige al usuario.
      scanf("%d",&nro);                           //Pide ingresar de nuevo el número.
   }
}
Sentencia DO WHILE: 
La sentencia Do While (HACER MIENTRAS, en español) funciona igual que el While
con una pequeña diferencia que radica en que el While común, el proceso, a menos
que se cumpla la condición puede nunca ejecutarse. En el Do While, en cambio,
siempre se ejecutará la primera vez y luego se seguirá repitiendo si se cumple la
condición. 

Estructura: 

En lenguaje C++ la sentencia do While se aplica de la siguiente manera: 

do 
{ 
// Proceso 
} 
while(condición); 

El proceso se realizara al menos una vez y luego se comprobara si la condición es

verdadera, de serlo se repetirá el proceso, de lo contrario seguirá la ejecución del 
programa . 
Ejemplo
#include<conio.h>
#include<stdio.h>
 
int nro;
 
main()
 {
    printf("Ingrese 0 para salir del programa");
    do
   {
        scanf("%d",&nro);
        printf("\nEl número ingresado es:%d",nro);
   }
    while(nro!=0);
 }
Sentencia FOR: 
La sentencia for es una sentencia usada en los lenguajes de programación para
repeticiones. Con esta sentencia se define una variable numérica y se repite un
determinado proceso la cantidad de veces que se le indica en la declaración de la
sentencia. 
Estructura: 

for(definición de la variable;numero de veces que se repetirá el proceso;suma numérica

del contador) 
{ 
// proceso que se repite 
} 

En la definición de variable se se coloca la variable que utilizaremos para la repetición. 

El el numero de veces que se repetirá el proceso se coloca la condición mediante la cual
se repetirá el proceso, esta debe de constar de la variable definida, un operador (>,<,=,
etc.) y la cantidad de veces que se repetirá. 
En la  suma  numérica colocaremos la variable definida seguida de un valor para
incrementar esta variable hasta que se cumpla el numero de veces que se repetirá,
generalmente se utiliza el operador ++ que incrementa en 1 la variable. 
Ejemplo

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

int nro,i;

main()
 {
  for(i=0;i<5;i++)
   {
     scanf("%d",&nro);
     printf("Numero %d: %d",i,nro);
   }
}
Sentencia IF: 
La sentencia if (SI,en español) es una sentencia muy usada en los lenguajes de
programación. Su funcionamiento es simple. Se evalúa una condición, si es
verdadera se ejecuta un proceso y si es falsa se ejecuta otro. 

Estructura: 

if(condición) 
{ 
// proceso 1 
} 
else 
{ 
// proceso 2 
} 

El proceso 1 es el que se realiza en caso de que la condición sea verdadera. El

proceso 2 no es obligatorio, es decir, puede o no estar, y se ejecuta si la condición
es falsa. 
Ejemplo
#include<conio.h>
#include<stdio.h>

int nro;

main()
 {
   scanf("%d",&nro);
   if(nro>0)
  {
      printf("El número es positivo");
  }
  else
   {
     printf("El número es negativo");
   }
 }
SUBPROGRAMAS O FUNCIONES
• FUNCIONES DE BIBLIOTECA STANDARD
• FUNCIONES DEFINIDAS POR EL USUARIO

Función.- Es un segmento de programa que realiza determinadas tareas bien

definidas.
Funciones definidas por el usuario.- Son subprogramas que el usuario define
para dividir un programa grande en un cieto número de componentes más pequeños,
cada no de los cuales con un propósito único e identificable. Por tanto, un programa en
“C” se puede realizar mediante el uso inteligente de las funciones

El uso de funciones es necesario cuando:

• Se requiere que se acceda repetidamente a un grupo determinado de instrucciones
desde varias partes distintas del programa.
• Se requiere transferir un diferente conjunto de datos al grupo de instrucciones que se
ejecuta varias veces.
• Se requiere identificar con claridad lógica la descomposición de un programa en varias
funciones concisas.
Definición de una función
La definición de una función tiene 3 componentes principales:
• La primera línea
• La declaración de parámetros
• El cuerpo de la función

Primer línea parámetros formales

tipo nombre(parámetro1, parámetro2, … parámetro n)

Nombre de la función
Tipo de dato que
devuelve la función
Declaración de parámetros.- Se tiene que declarar los tipos de los parámetros que
deben coincidir con los de los argumentos (los que se usan en la llamada a la
función). Los identificadores usados en los parámetros son “locales” porque no son
reconocidos fuera de la función.
Cuerpo de la función .- Es una sentencia compuesta que define las acciones que debe
realizar ésta.

// convierte_mayuscula_a_minuscula.cpp : Defines the entry point for the console application.

//

#include "stdafx.h"
#include "stdio.h“
#include “conio.h”

char minuscula(char c)
{
return(('A' <= c && c <= 'Z') ? ('a' + c - 'A') : c);
}

int _tmain(int argc, _TCHAR* argv[])

{
char carmin, carmay, d;
printf("Introducir un caracter en mayuscula. \n");
carmay = getchar( );
carmin = minuscula(carmay);
printf("%c\n",carmin);
d = getch( );

return 0;
}
Recursividad
La recursividad tiene lugar en un programa cuando una función se llama a sí misma.
Inicialmente, puede parecer un bucle infinito, pero no es así. Tanto C omo C++
admiten la recursividad. Los algoritmo recursivos permiten resolver problemas de
forma creativa, legible y concisa.

double dfactorial (double drespuesta)

{
if (drespuesta <= 1.0)
rerturn (1.0)
else
return(drespuesta*dfactorial(drespuesta-1.0));
}
main( )
{
double dfactorial (double drespuesta)
{
if (drespuesta <= 1.0)
rerturn (1.0)
else
return(drespuesta*dfactorial(drespuesta-1.0));
}
main( )
{
double dnumero, dresult;
printf(“Ingresar número:”); scanf(“%lf”, &dnumero);

dresult = dfactorial(dnumero);
printf(“El factorial de %15.0lf es: %15.0lf\n”, dnumero, dresult);
return (0);
}
ARRAYS
• Los elementos individuales de datos de un array se denominan elementos
• Todos los elementos deben ser del mismo tipo de dato.
• Todos los elementos se almacenan en posiciones contiguas de la memoria de
la computadora y el subíndice del primer elemento es cero
• El nombre de un array es un valor constante que representa la dirección del
primer elemento del array

DECLARACIÓN DE ARRAYS
int iarray[12]; //un array de 12 enteros
char carray[20]; // un array de 20 caracteres

No se puede usar nombre de variable dentro de los corchetes en la declaración

de un array. Es mejor usar constantes definidas para especificar el tamaño de
los arrays

#define iARRAY_MAX 20
#define fARRAY_MAX 15

Int iarray[iARRAY_MAX]
float farray[fARRAY_MAX]
Ejemplo.- Debajo se muestran varias definiciones de arrays que incluyen la
asignación de valores iniciales:

int digitos[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

float x[6] = {0, 0.25, 0, -0.50, 0, 0};
char color[3] = {‘R’, ‘E’, ‘D’};

El resultado de estas asignaciones iniciales es como sigue:

digitos[0] = 1 x[0] = 0 color[0] = ‘R’

digitos[1] = 2 x[1] = 0.25 color[1] = ‘E’
digitos[2] = 3 x[2] = 0 color[2] = ‘D’
digitos[3] = 4 x[3] = -0.50
digitos[4] = 5 x[4] = 0
digitos[5] = 6 x[5] = 0
digitos[6] = 7
digitos[7] = 8
digitos[8] = 9
digitos[9] = 10
Todos los elementos del array que no tienen asignados valores iniciales explícitos serán
puestos automáticamente a cero.

Ejemplo:
int digitos[10] = {3, 3, 3};
float x[6] = {-0.3, 0, 0.25};

Los resultados son:

digitos[0] = 3 x[0] = -0.3

digitos[1] = 3 x[1] = 0
digitos[2] = 3 x[2] = 0.25
digitos[3] = 0 x[3] = 0
digitos[4] = 0 x[4] = 0
digitos[5] = 0 x[5] = 0
digitos[6] = 0
digitos[7] = 0
digitos[8] = 0
digitos[9] = 0
El tamaño del array no necesita ser especificado explícitamente cuando se incluyen
los valores iniciales como una parte de la definición del array. Con un array numérico,
el tamaño del array será fijado automáticamente igual que el número de valores
incluidos dentro de la definición.

Ejemplo
int digitos[] = {1, 2, 3, 4, 5, 6};
float x[] = {0, 0.25, 0, -0.5};

digitos es un array de seis elementos y x un array de cuatro elementos en punto

flotante. Los elementos tendrán asignados los siguientes valores:

digitos[0] = 1 x[0] = 0
digitos[1] = 2 x[1] = 0.25
digitos[2] = 3 x[2] = 0
digitos[3] = 4 x[3] = -0.5
digitos[4] = 5
digitos[5] = 6
Procesamiento de un Array
Se rrealiza mediante bucles y en cada paso del bucle se procesa un elemento del
array
Ejemplo: Se desea obtener el promedio ponderado de un alumno

1
Inicio
Para i=1 hasta
Pedir ncursos
ncursos
SumNxC+=nota(i)*cred(i)
Para i=1 hasta SumaCred+=cred(i)
ncursos
Pedir curso(i) Prox. i
nota(i),
cred(I)
Pp=SumNxC/SumaCred
Prox. i
Mostrar
Pp
1
Fin
main()
{
char curso[20];
int ncursos, nota[10], cred[10], i, SumNxC, SumCred;
float Pp;
printf(“Ingresar numero de cursos: “); scanf(“%d”,&ncursos);
for(i = 0; i < ncursos; i++) {
printf(“Nombre curso: “); scanf(“%s”,curso);
printf(“Nota = “); scanf(“%d”, &nota[i]);
printf(“Crreditos = “); scanf(“%d”,&cred[i]);
}
for(i = 0; i < ncursos; i++) {
SumNxC += nota[i] * cred[i];
SumCred += cred[i];
}
Pp = (float) SumaNxC/SumCred;
printf(“El Prom. Ponderado es %4.2f”,Pp);
}
Donde ptvar es el nombre de la variable puntero y tipo-dato se
refiere al tipo de dato apuntado por el puntero. Recordar que un
asterisco debe preceder a ptvar.
PUNTEROS Y ARRAYS UNIDIMENSIONALES
El nombre de un array es realmente un puntero al primer elemento de ese array.
Sin embargo, si x es un array unidimensional, entonces la dirección al primer
elemento del array puede ser expresada tanto como &x[0] o simplemente como x.
Además, la dirección del segundo elemento del array se puede escribir tanto como
&x[1] o como (x + 1), y así sucesiivamente. En general, la dirección del elemento
(i+1) del array se puede expresar o bien como &x[i] o como (x + i)

#include <stdio.h>

main()
{
static int x[10] = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19};
int i;

for (i = 0, i <= 9; ++i)

printf(“\ni= %d x[i] = %d *(x+i) = %d &x[i]= %x x+i = %x”,
i, x[i], *(x+i), &x[i], x+i);
}
Ejecutando el programa resulta la siguiente salida:
 OPERACIONES CON PUNTEROS
En la diapositiva anterior se ha visto que se puede sumar un
valor entero a un nombre de array para acceder a un elmento
indivicual del array. El valor entero es interpretado como el
índice del array; representa la localización relativa del
elemento deseado con respecto al mprimero del array. Esto
funciona ya que todos los elementos de array son del mismo
tipo y por tanto cada elemento ocupa un mismo nnúmero de
celdas de memori (mismo número de bytes o palabras). El
número de celdas que separan a dos elemtnos del array
dependerá del tipo de datos del array, pero de esto se encarga
el compilador automáticamaaente y por tanto no concerne al
programador directamente.
Este concepto se puede extender a las variables
puntero. En particular, un valor entero puede ser
sumado o restado a una variable puntero, pero el
resultado de la operación debe ser interpretado con
cuidadol Supongamos, por ejemplo, que px es una
variable puntero que representa la dirección de una
variable x. Podemos escribir expresiones como ++px,
--px, (px+3), (px + i) y (px – i), donde i es una variable
entera. Cada expresión representará un dirección
localizada a ceierta distancia de la posición original
representada por px. La distancia exacta será el
producto de la cantidad entera por el número de bytes
o palabras que ocupa cada elemento al cual apunta px
Por ejemplo, si px apunta a un entero, como un entero
requiere 2 bytes de memoria, entonces la expresión (px
+ 3) resultará en una dirección 6 bytes más allá del
entero apuntado por px, como se ilustra en la Figura
que sigue. Sin embargo, debe quedar claro que esta
nueva dirección no tiene necesariamente que
representar la dirección de otro elemento,
particularmente si lo elementos almacenados entre las
dos posiciones son de tipos diferentes.
Las operaciones que se pueden realizar con punteros son:
1. A una variable puntero se le puede asignar la dirección de
una variable ordinaria (pv=&v).
2. A una variable puntero se le puede asignar el valor de otra
variable puntero (por ejemplo (pv=px), siemmpre que
ambos punteros apunten al mismo tipo de dato.
3. A una variable puntero se le puede asignar un valor nulo
(cero) (por ejemplo pv= NULL, donde NULL es una
constante simbólica que representa el valor 0).
4. Una cantidad entera puede ser sumada o restada a una
variable puntero (por ejemplo pv+3, ++pv).
5. Una variable puntero puede ser restada de otra con tal que
ambas apunten a elementos del mismo array.
6. Dos variables puntero pueden ser comparadas siempre
que ambas apunten a datos del mismo tipo.
PUNTEROS Y ARRAYS MULTIDIMENSIONALES
Como un array unidimensional puede ser representado en términos de
punteros (el nombre del array) y de un desplazamiento (el índice), es
razonable esperar que los array multidimensionales puedan ser representados
también con una notación equivalente de punteros. En efecto esta es el caso.
Por ejemplo, un array bidimensiona es en realidad un colección de arrays
unidimensional. Por tanto, podemos definir un array bidimensiona como un
puntero a un grupo contiguo de arrays unidimensionales. Una declaración de
un array bidimensional puede ser escrita como:

Tipo-dato (*ptvar)[expresion 2];

en vez de
Tipo-dato array[expresion1][expresion2];

Generalizando:
Tipo-dato (*ptvar)[expresion2][expresion3]…[expresion n];
En vez de:
Tipo-dato array[expresion1][expresion2]…[expresion n];
Suponer que x es un array bidimensional de enteros con 10 filas y 20
columnas. Podermos declarar x como
Int (*x)[20]; en vez de int x[10][20];
En la primera declaración x se define como un puntero a un grupo contiguo
de arrays unidimensionales de 20 elementos enteros. Así x apunta al
primero de los arrays de 20 elementos, que es en realidad la primera fila
(fila 0) del array bidimensional original. Similarmente (x+1) apunta al
segundo array de 20 elementos, que es la segunda fila del array
bidimensional original, y así sucesivamente, como se ilustra en la Fig.
x

Primer array unidimensional

(x+1)

Segundo array unidimensional

(x+9)

Décimo array unidimensional

Considerar ahora el array tridimensional de números en punto
flotante t. Este array puede definirse como

float (* t)[20][30]; en vez de float t[10][20][30];

En la primera declaración t se define como un puntero a un

grupo contiguo de arrays bidimensionales de punto flotante de
20x30. Aquí t apunta al primer array de 20x30, (t+1) al segundo,
y así sucesivamente.

Un elemento individual del array puede ser accedido mediante

el uso repetido del operador indirección. Sin embargo,
normalmente este método es más difícil que el convencional
para acceder a un elemento del array.
Supongamos que x es un array bidimensiona con 10 filas y 20 columnas, como se
declaró en el ejemplo anterior. El elemento en la fila 2, columna 5, puede ser
accedido escribiendo
X[2][5] ó *(*(x+2) + 5)
La segunda manera requiere explicación. Primero notar que (x+2) es un puntero a la
fila 2. Por tanto, el objeto de esta puntero, *(x+2), refiere toda la fila. Como l fila 2 es
un array unidimensional, *(x+2) es realmente un puntero al primer elemento de la fila
2. Sumamos 5 a este puntero. Por tanto, (*(x+2)+ 5) es un puntero al elemento 5 (el
sexto elemento) de la fila 2. El objeto de este puntero, *(*(x+2) + 5) se refiere al
elemento en la columna 5 de la fila 2, que es x[2][5]

Primer array unidimensional

(x + 1)

Segundo array unidimensional

*(x + 2) *(x + 2) + 5

(x + 2)

Tercer array unidimensional

*(*(x + 2) + 5)
Suma de Matrices con punteros

#include “stdio.h”
#define MAXCOL 30

main()
{
int nfilas, ncols;
// definición de punteros
int (*a)[MAXCOL], (*b)[MAXCOL], (*c)[maxcol];

// prototipo de funcion
void leerentrada(int (*a)[MAXCOL], int nfilas, int ncols);
void calcularsuma(int (*a)[MAXCOL], int (*b)[MAXCOL], int (*c)[MAXCOL],
int nfilas, int ncols);
void sacarsalida(int (*c)[MAXCOL], int nfilas, int ncols);

printf(“Cuantas filas: “);

scanf (“%d”, &nfilas);
printf(“Cuantas columnas: “);
scanf (“%d”, &ncols);
 // reserva inicial de memoria
*a =(int *) malloc(nfilas * ncols * sizeof(int));
*b =(int *) malloc(nfilas * ncols * sizeof(int));
*c =(int *) malloc(nfilas * ncols * sizeof(int));

printf(“\n\nPrimera Matriz: \n”);

leerentrada(b, nfilas, ncols);

calcularsuma(a, b, c, nfilas, ncols);

printf(“\nMatriz Suma: “\n\n”);

sacarsalida(c, nfilas, ncols);
}
void leerentrada(int (*a)[MAXCOL], int m, int n)
{
int fila, col;
for(fila = 0; fila < m; ++fila) {
printf(“\nIntroducir datos de la fila no. %2d\n”, fila + 1);
for(col = 0; col < n; ++col)
scanf(“%d”, (*(a + fila) + col));
}
return;
}
void calcularsuma(calcularsuma(int (*a)[MAXCOL], int (*b)[MAXCOL], int (*c)[MAXCOL],
int m, int n)
{
int fila, int col;
for(fila = 0; fila < m; ++fila)
for(col = 0; col < n; ++col)
*(*(c + fila) + col) = *(*(a + fila) + col) + *(*(b + fila) + col);
return;
}

void sacarsalida(int (*c)[MAXCOL], int m, int n)

{
for(fila = 0; fila < m; ++fila) {
for(col = 0; col < n; ++col)
printf(“%4d”, *(*(a + fila) + col));
printf(“\n”);
}
return;
}
ARRAY DE PUNTEROS
Un array multidimensional puede ser expresado como un array de punteros en vez de
cómo un puntero a un grupo contiguo de arrays. En estos casos el nuevo array será de
una dimensión menor que el array multidimensional. Cada puntero indicará el principio
de un array de dimensión (n – 1).

tipo-dato *array[expresion1]; en vez de tipo-dato array[expresion1][expresion2];

Similarmente, un array n dimensional puede ser definido como un array de punteros de

dimensión (n-1):

tipo-dato *array[expresion1][expresion2] . . . [expresion n-1];

en vez de

Tipo-dato array[expresion1][expresion2] . . . [expresion n];

x [0 ]
P r im e r a r r a y u n id im e n s io n a l

x [1 ]
S e g u n d o a r r a y u n id im e n s io n a l

(x [2 ] + 5 )

x [2 ]
T e r c e r a r r a y u n id im e n s io n a l

*(x [ 2 ] + 5 )