Comparacion de los lenguajes de Programacion C

y C++ como Herramienta Docente

Vicente Benjumea Manuel Roldan

Resumen
Este documento presenta una comparacion entre las primitivas proporcionadas
por los lenguajes C y C++, utilizadas como soporte para la docencia de los con-
ceptos fundamentales de la programacion. Nuestra intencion no es hacer una
comparativa general entre ambos lenguajes, sino unicamente repasar aquellos el-
ementos comunes que pueden ser utilizados en un curso basico de programacion.
Como resultado del estudio, pensamos que, en general, cuando el objetivo de un
curso no es el estudio del lenguaje C, es mas adecuado plantear un primer curso
de programacion sobre la base de C++ que sobre C.
El estudio de arrays siempre es parte importante de cualquier primer curso
inicial de programacion. Tradicionalmente este aspecto ha sido tratado (tanto en
C como en C++) mediante arrays predefinidos. Sin embargo, desde el estandard
C++11 (previamente en TR1 ), C++ dispone de un tipo array que pensamos
que aporta numerosas ventajas docentes sobre el uso tradicional de arrays pre-
definidos. Discutimos las caractersticas de cada uno y analizamos ventajas e
inconvenientes de cada enfoque.
Nota: en todo el texto, salvo que se especifique lo contrario, se hace referen-
cia a ANSI-C (C89).

Contenido
1. Definicion de Constantes 2

2. Definicion de Variables 3

3. Control de Ejecucion 4

4. Conversiones de Tipos (castings) 5

5. Entrada y Salida de Datos 6

6. Definicion de Tipos 11

7. Subprogramas: Paso de Parametros 19

8. El Tipo Puntero y la Gestion de Memoria Dinamica 27

9. Conclusion 35

A. Problemas del uso de printf y scanf: un ejemplo 35

cc Esta obra se encuentra bajo una licencia Reconocimiento-NoComercial-
CompartirIgual 4.0 Internacional (CC BY-NC-SA 4.0) de Creative Commons. Vease
http://creativecommons.org/licenses/by-nc-sa/4.0/deed.es ES

1
1. Definicion de Constantes
En el ambito de la enzenanza de la programacion, es conveniente transmitir
la importancia del uso de constantes simbolicas en los programas, evitando en la
medida de los posible el uso de constantes literales. A continuacion analizamos
las posibilidades que ofrecen C y C++ para ello.

1.1. Definicion de constantes en C utilizando el preproce-

sador
En C se pueden definir constantes mediante directivas para el preprocesador.
Como consecuencia, puede ocurrir que el valor asociado al smbolo a expandir
dependa del contexto en el que expande. Por ejemplo, consideremos las siguientes
constantes:
#define PI 3.1415
#define CONSTANTE1 10
#define CONSTANTE2 20
#define CONSTANTE3 CONSTANTE1 + CONSTANTE2

En este caso la interpretacion del smbolo CONSTANTE3 no es unica y depende

del contexto en que se expanda dentro del programa. Por ejemplo, supongamos
que en la siguiente sentencia queremos almacenar en la variable v la mitad del
valor asociado al smbolo CONSTANTE3:
int v = CONSTANTE3 / 2 ;

Aunque aparentemente la expresion utilizada para ello es correcta, en realidad

es erronea, ya que una vez que el procesador expande el smbolo, la precedencia
de los operadores hace que el resultado no sea el previsto y en realidad la vari-
able v almacena el valor 20, resultante de evaluar la expresion 10 + 20 / 2.
El mecanismo utilizado para definir las constantes nos ha inducido a un error
difcil de detectar, ya que nos encontramos con una expresion final que en rea-
lidad esta formada por diferentes partes especificadas en puntos diferentes del
programa. Obviamente, este problema se puede solucionar incluyendo parentesis
en la definicion de la constante.
#define CONSTANTE3 (CONSTANTE1 + CONSTANTE2)

Sin embargo, debemos ser conscientes de que la utilizacion del preprocesador

para definir constantes simbolicas conlleva la posibilidad de introducir errores
inesperados y difciles de detectar, especialmente en un contexto de aprendizaje
de la programacion.

1.2. Definicion de constantes en C utilizando enumera-

ciones
Tambien es posible definir constantes de tipo entero (int) utilizando enu-
meraciones:
enum {
CONSTANTE1 = 10,
CONSTANTE2 = 20,
CONSTANTE3 = CONSTANTE1 + CONSTANTE2
} ;

2
y utilizar dichas constantes con los valores adecuados.
int v = CONSTANTE3 / 2 ;

Sin embargo, este mecanismo solo es adecuado para definir constantes de tipo
entero (int), no pudiendo ser utilizada para definir constantes de otros tipos,
especialmente de coma flotante.

1.3. Definicion de constantes en C utilizando const

Finalmente, es posible definir variables inmutables utilizando la palabra
reservada const.
const int CONSTANTE1 = 10 ;
const int CONSTANTE2 = 20 ;
const int CONSTANTE3 = CONSTANTE1 + CONSTANTE2 ;

int v = CONSTANTE3 / 2 ;

Aunque son constantes en el sentido de que no es posible alterar su valor

durante la ejecucion del programa, no son constantes desde el punto de vista del
compilador y por lo tanto no pueden ser utilizadas para aquellas circunstancias
donde sea necesaria una constante simbolica definida en tiempo de compilacion
(por ejemplo no son validas para definir tamanos de arrays). Lo siguiente sera
incorrecto:
const int TAM = 10 ;
int v[TAM] ;

1.4. Definicion de constantes en C++

En C++ es posible definir constantes simbolicas de diversos tipos utilizan-
do la palabra reservada const. Los valores de estas constantes simbolicas son
conocidos por el compilador en Tiempo de Compilacion y pueden ser utilizadas
en cualquier ambito en el que sean necesarias.
const double PI = 3.1415 ;

const int CONSTANTE1 = 10 ;

const int CONSTANTE2 = 20 ;
const int CONSTANTE3 = CONSTANTE1 + CONSTANTE2 ;

int v = CONSTANTE3 / 2 ;

2. Definicion de Variables
2.1. Definicion de variables en C
En C, las variables se deben definir en una zona al comienzo de cada bloque,
y no pueden mezclarse con las sentencias ejecutables.1 As mismo, tambien es
posible inicializar las variables en el lugar en que son definidas.
int main()
{
int x, y ;
int z = 5 ;

scanf(" %d", &y) ;

x = y * z ;
}
1 Sinembargo, en C99 si es posible entremezclar definicion de variables y sentencias eje-
cutables.

3
2.2. Definicion de variables en C++
En C++, las variables se pueden definir en cualquier parte del bloque, pu-
diendo mezclarse con las sentencias ejecutables, de hecho, se consideran tambien
sentencias ejecutables (invocacion al constructor). Esto aumenta la localidad del
codigo, permite declarar las variables en el punto mas cercano al lugar de su uti-
lizacion, y permite declarar e inicializar las variables con los valores adecuados,
en vez de realizar una declaracion de la variable sin inicializar.
int main()
{
int z = 5 ;
int y ;
cin >> y ;
int x = y * z ;
}

3. Control de Ejecucion
3.1. Estructuras de control en C y C++
Aunque ambos lenguajes disponen de otras estructuras de control de la eje-
cucion, en el contexto del aprendizaje de programacion en un ambito academi-
co, basado en un enfoque de diseno descendente, abstraccion procedimental y
programacion estructurada, solo consideraremos las siguientes estructuras de
control:
Secuencia: Un bloque determina un secuencia de sentencias ejecutables.
Las sentencias se ejecutan secuencialmente.
int main()
{
int x, y = 4 ;
int z = 5 ;

x = y * z ;
z = z + x ;
}

Seleccion: Seleccionan la ejecucion de determinados bloques de senten-

cias, dependiendo del estado de la computacion en un momento determi-
nado.

if : switch:
int main() int main()
{ {
int x = 3, y = 5 ; int x = 4 ;
if (x > y * 2) { switch (x * 3) {
x = y + 2 ; case 0:
y = 0 ; x += 2 ;
} else if (x > y) { ++x ;
x = 0 ; break ;
} else { case 18:
y = 0 ; case 21:
++x ; --x ;
} break ;
} default:
x *= 5 ;
break ;
}
}

4
 Iteracion: Repite la ejecucion de un bloque de sentencias, dependiendo
del estado de la computacion en un momento determinado.

for: while: do-while:

int main() int main() int main()
{ { {
int s = 0 ; int s = 0 ; int s = 0 ;
int i ; int i = 0 ; int i = 0 ;
for (i = 0 ; i < 10 ; ++i) { while (i < 10) { do {
s += i ; s += i ; s += i ;
} ++i ; ++i ;
} } } while (i < 10) ;
} }

3.2. Caractersticas propias de C++

La unica diferencia significativa que introduce C++ respecto a C en este
aspecto es que permite definir la variable de control del bucle for dentro de
la propia definicion del bucle (en cuyo caso su ambito de vida se restringe al
propio bucle donde esta definida), aumentando as la localidad y simplificando
la estructura (este mecanismo tambien ha sido incorporado a C99 ).
int main()
{
int s = 0 ;
for (int i = 0 ; i < 10 ; ++i) {
s += i ;
}
}

4. Conversiones de Tipos (castings)

4.1. Conversiones de tipos en C
En C, la conversion de tipos se realiza mediante el operador prefijo de casting,
donde se especifica entre parentesis el tipo destino al que se quiere convertir
una determinada expresion, seguida por la expresion cuyo resultado quiere ser
convertida. Por ejemplo:
int main()
{
int x = (int)3.1415 ;
}

Hay que tener presente que la precedencia del operador de casting es la segunda
mas alta (por debajo del operador punto e indexacion), por lo que resulta facil
introducir errores inesperados. Por ejemplo:
int main()
{
double pi = 3.1415 ;
int x = (int)pi+0.5 ;
}

en lugar de:
int main()
{
double pi = 3.1415 ;
int x = (int)(pi+0.5) ;
}

5
4.2. Conversiones de tipos en C++
En C++, la conversion de tipos se realiza mediante el operador prefijo de
casting, donde se especifica el tipo destino al que se quiere convertir una de-
terminada expresion, seguida por la expresion entre parentesis cuyo resultado
quiere ser convertida. De esta forma, se evitan los posibles problemas derivados
de la precedencia de los operadores. Por ejemplo:
int main()
{
int x = int(3.1415) ;

double pi = 3.1415 ;
int z = int(pi+0.5) ;
}

En caso de tipos con nombres compuestos (unsigned short, unsigned long,

long double, long long, unsigned long long), se debe utilizar un alias (definido
con typedef):
typedef unsigned long ulong ;
int main()
{
ulong x = ulong(3.1415) ;

double pi = 3.1415 ;
ulong z = ulong(pi+0.5) ;
}

o utilizar la conversion al estilo de C:

int main()
{
unsigned long x = (unsigned long)3.1415 ;

double pi = 3.1415 ;
unsigned long z = (unsigned long)(pi+0.5) ;
}

5. Entrada y Salida de Datos

5.1. Entrada y salida de datos en C
En C, la entrada y salida de datos basica se realiza a traves de las funciones
scanf y printf, especificando una cadena de caracteres que define el formato
y tipos de los datos involucrados, como en el siguiente ejemplo:
#include <stdio.h>
int main()
{
char c = a ;
short s = 1 ;
int x = 2 ;
unsigned u = 3 ;
long l = 4 ;
float f = 5.0 ;
double d = 6.0 ;
long double dd = 7.0 ;
char nombre[30] = "pepe" ;

printf("%c %hd %d %u %ld %g %g %Lg %s\n",

c, s, x, u, l, f, d, dd, nombre) ;

scanf("%c %hd %d %u %ld %g %lg %Lg %29s\n",

&c, &s, &x, &u, &l, &f, &d, &dd, nombre) ;
}

6
5.2. Entrada y salida de datos en C++
En C++, la entrada y salida de datos basica se realiza a traves de los flujos
de entrada (cin) y de salida (cout) mediante operadores adecuados para ello:
#include <iostream>
#include <iomanip>
#include <string>
using namespace std;
int main()
{
char c = a ;
short s = 1 ;
int x = 2 ;
unsigned u = 3 ;
long l = 4 ;
float f = 5.0 ;
double d = 6.0 ;
long double dd = 7.0 ;
string nombre_1 = "juan" ;
char nombre_2[30] = "pepe" ;

cout << c << << s << << x << << u << << l <<
<< f << << d << << dd << << nombre_1 <<
<< nombre_2 << endl ;

cin >> c >> s >> x >> u >> l

>> f >> d >> dd >> nombre_1 >> setw(30) >> nombre_2 ;
}

5.3. Salida formateada de datos en C

En C, la salida de datos formateada esta orientada al dato. A continuacion
se muestra un ejemplo de salida formateda de datos en C, donde el smbolo #
representa el espacio en blanco:
#include <stdio.h>
int main()
{
char c = a ;
int x = 12 ;
double d = 3.141592 ;
char s[30] = "hola" ;

printf("%4d", x) ; // SALIDA: ##12

printf("%04d", x) ; // SALIDA: 0012 (Decimal)

printf("%04x", x) ; // SALIDA: 000c (Hexadecimal)
printf("%04o", x) ; // SALIDA: 0014 (Octal)

printf("%12.4g", d) ; // SALIDA: #######3.142 (4 dgitos)

printf("%12.4f", d) ; // SALIDA: ######3.1416 (4 decimales)

printf("%12.4e", d) ; // SALIDA: ##3.1416e+00 (4 decimales)

printf("%-6s", s) ; // SALIDA: hola## (Just. Izquierda)

printf("%6c", c) ; // SALIDA: #####a (Just. Derecha)

printf("%#04x", x) ; // SALIDA: 0x0c (Hexadecimal + Base)

printf("\n");

printf("%*.*g", 12, 4, d) ; // SALIDA: #######3.142 (Alternativa)

printf("%4.3d", x) ; // SALIDA: #012 (Mnimo)
printf("%6.2s", s) ; // SALIDA: ####ho (Maximo)
printf("\n");
}

7
5.4. Salida formateada de datos en C++
En C++, la salida de datos formateada esta orientada al modo de operacion.
A continuacion se muestra un ejemplo de salida formateda de datos en C++,
donde el smbolo # representa el espacio en blanco:
#include <iostream>
#include <iomanip>
int main()
{
char c = a ;
int x = 12 ;
double d = 3.141592 ;
char s[30] = "hola" ;

cout << setw(4) << x ; // SALIDA: ##12

cout << setfill(0) ; // Modo Relleno Cero

cout << dec << setw(4) << x ; // SALIDA: 0012 (Decimal)
cout << hex << setw(4) << x ; // SALIDA: 000c (Hexadecimal)
cout << oct << setw(4) << x ; // SALIDA: 0014 (Octal)
cout << setfill( ) << dec ; // Restaura Modo (Esp + Dec)

cout << setprecision(4); // Establece Precision 4

cout << setw(12) << d ; // SALIDA: #######3.142 (4 dgitos)

cout.setf(ios::fixed, ios::floatfield); // Modo Fijo (F)

cout << setw(12) << d ; // SALIDA: ######3.1416 (4 decimales)

cout.setf(ios::scientific, ios::floatfield);// Modo Cientfico (E)

cout << setw(12) << d ; // SALIDA: ##3.1416e+00 (4 decimales)

cout.unsetf(ios::floatfield); // Restaura Modo por Defecto (G)

cout.setf(ios::left, ios::adjustfield); // Modo Just. Izquierda

cout << setw(6) << s ; // SALIDA: hola## (Just. Izquierda)
cout.setf(ios::right, ios::adjustfield); // Modo Just. Derecha
cout << setw(6) << c ; // SALIDA: #####a (Just. Derecha)

cout.setf(ios::internal, ios::adjustfield); // Modo Just. Interno

cout.setf(ios::showbase); // Modo Mostrar-Base
cout << setfill(0) << hex // Modo Relleno Cero + Hex
<< setw(4) << x // SALIDA: 0x0c (Hexadecimal + Base)
<< dec << setfill( ) ; // Restaura Modo (Esp + Dec)
cout.unsetf(ios::showbase); // Restaura Modo por Defecto
cout.unsetf(ios::adjustfield); // Restaura Modo por Defecto

cout.precision(4); // Alternativa para establecer la precision

cout.fill(0); // Alternativa para establecer el caracter de relleno

cout << endl;

}

5.5. Comparativa entre ambos mecanismos

Consideramos que el uso de los flujos cin y cout para efectuar la Entra-
da/Salida basica en C++ es mas simple y permite hacer programas mas exten-
sibles y robustos que mediante printf y scanf en C, por lo siguientes motivos:
Es mas simple, porque proporciona un mecanismo uniforme en el que
no hay que considerar las peculiaridades asociadas al tipo de cada valor
a leer o a escribir. Desde este punto de vista es mas adecuado para el
aprendizaje, ya que se puede comenzar a practicar sin tener que considerar
pequenos detalles como, por ejemplo, el especificador concreto de la cadena
de formato a utilizar en funcion del tipo de dato a leer y a escribir (notese
la diferencia de especificador entre printf y scanf para el tipo de datos
double). Vease ejemplos en las secciones (5.1 y 5.2).

8
Es mas simple, porque el uso de scanf requiere que los parametros usados
sean punteros (direcciones de memoria) a las variables que almacenaran
los valores ledos. Ello requiere el conocimiento de un concepto complejo
en una fase inicial de aprendizaje donde aun no se esta preparado para
ello. Alternativamente, se podra utilizar la direccion de memoria de una
variable sin conocer su semantica. En este caso se podra plantear el es-
quema indicando que para leer un dato hay que escribir & precediendo a
la variable a leer con scanf. A priori esta segunda opcion no resulta muy
adecuada, y se ve dificultada por el hecho de que dicho operador & no
se utiliza uniformemente para todos los tipos (se debe usar en variables
de tipos simples y no usar en variables de tipo array de char). Ademas,
es frecuente que en un contexto de aprendizaje de la programacion, se
olvide de poner dicho & (o al contrario, se incluya innecesariamente en
el caso de variables de tipo array), en cuyo caso se genera un error que
en las primeras sesiones practicas aparece frecuentemente y complica el
aprendizaje innecesariamente.
int main()
{
int x ;
char nombre[30] ;

scanf("%d %s\n", &x, nombre) ;

cin >> x >> nombre ;

}

Otro problema importante con scanf es la necesidad de evitar el des-

bordamiento de memoria (buffer overflow ) controlando el numero de ca-
racteres ledos. Ello obliga a que dicho numero este escrito en la cadena
de formato, y no pueda depender del valor de una constante, que podra
tomar otro valor. Por ejemplo:
#include <stdio.h>
#define MAX 20
int main()
{
char nombre[MAX] ;
scanf(" %19s", nombre) ;
printf(" nombre: %s\n", nombre) ;
}

El posterior cambio de la constante MAX a otro nuevo valor (por ejemplo

10) es una fuente de errores, ya que, en general, se considera que el cambio
del valor de una constante no debe afectar a la correccion del programa.
Como consecuencia ello obliga a revisar todo el codigo, y cambiar todos
los numeros relacionados, en todas las partes del programa.
En C++ este problema no existe en el caso del tipo string, y en el caso
del array de char, quedara as de forma adecuada:
#include <iostream>
#include <iomanip>
const int MAX = 20 ;
int main()
{
char nombre[MAX] ;
cin >> setw(MAX) >> nombre ;
cout << "nombre: " << nombre << endl ;
}

9
 Favorece la creacion de programas mas extensibles, ya que no es necesario
tener que mantener la correspondencia del tipo de una variable con la
cadena de formato de una sentencia de E/S. Ello facilita la introduccion
de futuras modificaciones y disminuye la posibilidad de introducir nuevos
errores. Por ejemplo, si queremos modificar el siguiente programa:

C: C++:
typedef struct Dato { struct Dato {
int a ; int a ;
float b ; float b ;
} Dato ; } ;
int main() int main()
{ {
Dato d = { 1, 3.14 } ; Dato d = { 1, 3.14 } ;
printf("%d %g\n", d.a, d.b) ; cout << d.a << << d.b << endl ;
} }

para que el campo a pase a ser de fipo float, entonces en el caso de

printf es necesario modificar la cadena de formato, mientras que usando
cout no hay que hacer ningun cambio.

C: C++:
typedef struct Dato { struct Dato {
float a ; float a ;
float b ; float b ;
} Dato ; } ;
int main() int main()
{ {
Dato d = { 1, 3.14 } ; Dato d = { 1, 3.14 } ;
printf("%g %g\n", d.a, d.b) ; cout << d.a << << d.b << endl ;
} }

Es mas robusta, porque elimina la posibilidad de que se omita, tanto por

despiste como por desconocimiento, el operador & de las variables a leer
con scanf, elimina posibles errores futuros por cambios en los tipos de
las variables y ademas, evita determinados errores como el que se pro-
ducira en el siguiente programa dependiendo de que sea compilado en
una maquina de 32 bits o de 64 bits2
#include <stdio.h>
int main()
{
printf("sizeof(char): %u\n", sizeof(char)) ;
}

Nota: para solventar el problema indicado anteriormente (basado en el

estandar ANSI C89), en el estandar C99 existe el especificador z para el
tipo size_t:
#include <stdio.h>
int main()
{
printf("sizeof(char): %z\n", sizeof(char)) ;
}

Aunque se trata de un ejemplo que puede parecer extremo, es una indi-

cacion de que la salida de datos homogenea con cout es mas adecuada
que con printf.
2 Ver apendice A

10
 #include <iostream>
int main()
{
cout << "sizeof(char): " << sizeof(char) << endl ;
}

6. Definicion de Tipos
6.1. El Tipo Logico (Booleano)
6.1.1. El Tipo Logico (Booleano) en C (Estandar ANSI C89)
El lenguaje de programacion C, segun el estandar ANSI C89, no define
ningun tipo predefinido para representar valores logicos, y utiliza para ello el
tipo int, utilizando un valor igual a cero (0) para representar el valor logico fal-
so, y cualquier valor distinto de cero para representar el valor logico verdadero.
Por ejemplo:
int main()
{
int x = 7 ;
int ok = 1 && (x > 5) || 0 ;
}

Esta notacion esta desaconsejada, especialmente en un entorno academico,

en un contexto de aprendizaje de los conceptos fundamentales de programacion,
ya que no refleja adecuadamente los conceptos involucrados y puede interferir
en el aprendizaje del uso de expresiones logicas en las estructuras de control.
Por ello, se recomienda seguir un enfoque donde se defina un nuevo tipo para
representar los valores logicos, as como la definicion de constantes que reflejen
adecuadamente dichos valores. por ejemplo:
typedef enum { FALSE, TRUE } bool_t ;
int main()
{
int x = 7 ;
bool_t ok = TRUE && (x > 5) || FALSE ;
}

Sin embargo, esta definicion podra colisionar con otras definiciones realizadas
dentro de bibliotecas que se estuviesen utilizando, por lo que hay que extremar
las precauciones en este esquema.

6.1.2. El Tipo Logico (Booleano) en C (Estandar C99)

El lenguaje de programacion C, segun el estandar C99, define el tipo pre-
definido bool para representar valores logicos, y utiliza el fichero de la biblioteca
estandar <stdbool.h> para definir el tipo bool, as como las constantes false
para representar el valor logico falso, y true para representar el valor logico
verdadero. Por ejemplo:
#include <stdbool.h>
int main()
{
int x = 7 ;
bool ok = true && (x > 5) || false ;
}

11
6.1.3. El Tipo Logico (Booleano) en C++
El lenguaje de programacion C++ dispone del tipo predefinido bool para
representar los valores logicos, as como las constantes predefinidas true y false
para representar los valores logicos verdadero y falso, de tal forma que la eva-
luacion de expresiones logicas produce como resultado un valor de dicho tipo.
int main()
{
int x = 7 ;
bool ok = true && (x > 5) || false ;
}

6.2. El Tipo Enumerado

6.2.1. El Tipo Enumerado en C
El lenguaje de programacion C permite al programador definir tipos enume-
rados. El nombre del tipo enumerado se define dentro de un ambito restringido
de tipos enumerados, y por lo tanto requiere especificar la palabra reservada
enum antes de utilizar el tipo. Ademas, existe una conversion implcita directa
y automatica entre valores del tipo enumerado y el tipo int y viceversa. Para
definir el nombre del tipo enumerado dentro del ambito global, es necesario
utilizar la palabra reservada typedef. Por ejemplo:
Ambito Restringido: Ambito Global:
enum Color { typedef enum {
Rojo, Verde, Azul Rojo, Verde, Azul
} ; } Color ;
int main() int main()
{ {
enum Color c = Rojo ; Color c = Rojo ;
c = c + 1 ; c = c + 1 ;
} }

6.2.2. El Tipo Enumerado en C++

El lenguaje de programacion C++ permite al programador definir tipos
enumerados de una forma similar al lenguaje de programacion C, con algunas
diferencias:
El nombre del tipo definido pertenece al ambito donde haya sido definido
el tipo enumerado, y puede ser utilizado directamente en dicho ambito.
Aunque tanto en C como en C++ se puede convertir de forma implcita
y automatica un valor de la enumeracion al tipo int, ambos lenguajes se
diferencian en que la conversion en la direccion contraria (es decir, de int
al tipo enumerado) no ocurre de forma implcita (automatica) en C++,
requiriendo de un casting explcito. Esto hace que C++ sea mas estricto
y proporcione mayor seguridad en la gestion de los tipos.
Por ejemplo:
enum Color {
Rojo, Verde, Azul
} ;
int main()
{
Color c = Rojo ;
c = Color(c + 1) ;
}

12
 El nuevo estandar de C++ (C++11) define tambien otras clases de tipos
enumerados con mayor control del ambito de los valores definidos, pero no seran
considerados en este documento.

6.3. Registros
6.3.1. Registros en C
El lenguaje de programacion C permite al programador definir tipos estruc-
turados (registros) como composicion de elementos (campos), de tal forma que
el nombre del tipo registro se define dentro de un ambito restringido de tipos
registro, y por lo tanto requiere especificar la palabra reservada struct antes
de utilizar el tipo. Para definir el nombre del tipo registro dentro del ambito
global, es necesario utilizar la palabra reservada typedef. Por ejemplo:

Ambito Restringido: Ambito Global:

struct Fecha { typedef struct Fecha {
int dia, mes, anyo ; int dia, mes, anyo ;
} ; } Fecha ;
int main() int main()
{ {
struct Fecha hoy = { 25, 4, 2012 } ; Fecha hoy = { 25, 4, 2012 } ;
printf("%d/%d/%d\n", printf("%d/%d/%d\n",
hoy.dia, hoy.mes, hoy.anyo) ; hoy.dia, hoy.mes, hoy.anyo) ;
} }

6.3.2. Registros en C++

El lenguaje de programacion C++ permite definir al programador tipos
estructurados (registros) de una forma similar al lenguaje de programacion C,
con la siguiente diferencia:

El nombre del tipo definido pertenece al ambito donde haya sido definido
el tipo registro, y puede ser utilizado directamente en dicho ambito.
Por ejemplo:
struct Fecha {
int dia, mes, anyo ;
} ;
int main()
{
Fecha hoy = { 25, 4, 2012 } ;
cout << hoy.dia << / << hoy.mes << / << hoy.anyo << endl;
}

6.4. Arrays
En general, el tipo array se utiliza para definir una secuencia de un numero
determinado (definido en tiempo de compilacion) de elementos de un mismo
tipo de datos (simple o compuesto), de tal forma que se puede acceder a cada
elemento individual de la secuencia de forma parametrizada mediante ndices
(el valor cero indexa el primer elemento de la coleccion).
Tanto en C como en C++ se pueden utilizar arrays predefinidos, pero en
C++, desde la version del estandar C++11 (previamente en TR1 ) es posible,
ademas, usar el tipo array de la biblioteca estandar de C++.

13
6.4.1. Arrays predefinidos en C y C++
En ambos lenguajes se pueden usar arrays predefinidos de igual forma y con
los mismos operadores. En este tipo de arrays:

Solo es posible inicializar una variable a partir de una enumeracion de

valores constantes, no es posible inicializarla a partir de otra variable.
No es posible utilizar el operador de asignacion para asignar directamente
valores de tipo array a variables de tipo array.
No es posible utilizar los operadores relacionales (==, !=, >, >=, <, <=).

No se comprueba en Tiempo de Ejecucion que los accesos a los elementos

de un array sean correctos y se encuentren dentro de los lmites validos
del array predefinido, por lo que sera responsabilidad del programador
comprobar que as sea.

C: C++:
#define MAX 5 const int MAX = 5 ;
typedef int Vector[MAX] ; typedef int Vector[MAX] ;
int main() int main()
{ {
int i; int i;
Vector v = { 1, 2, 3, 4, 5 } ; Vector v = { 1, 2, 3, 4, 5 } ;
for (i = 0; i < MAX; ++i) { for (i = 0; i < MAX; ++i) {
v[i] = v[i] * 2 ; v[i] = v[i] * 2 ;
} }
} }

En las secciones 7.1.3 y 7.2.3 se describe el paso de parametros de arrays

predefinidos en C y C++ respectivamente.

6.4.2. El Tipo array de la biblioteca estandar de C++

El tipo array se incluyo en el estandar TR1 (Technical Report 1) de C++
(extension del estandar de C++03) en 2005, y se incorporo al estandar de C++
en 2011 (C++11). Aunque los compiladores actuales lo tienen incorporado en
la librera TR1, las nuevas versiones que soporten el nuevo estandar (C++11)
lo traeran incorporado en las libreras de base. Si se utiliza un compilador que
soporte el estandar C++11 se debe incluir la biblioteca estandar <array> y
utilizar el espacio de nombres de std, mientras que si se utiliza un compilador
que soporte el TR1 habra que incluir la biblioteca <tr1/array> y utilizar el
espacio de nombres de std::tr1.

C++11: C++03 + TR1:

#include <array> #include <tr1/array>
using namespace std ; using namespace std::tr1 ;
const int MAX = 5 ; const int MAX = 5 ;
typedef array<int, MAX> Vector ; typedef array<int, MAX> Vector ;
int main() int main()
{ {
Vector v = { 1, 2, 3, 4, 5 } ; Vector v = {{ 1, 2, 3, 4, 5 }} ;
for (unsigned i = 0; i < v.size(); ++i) { for (unsigned i = 0; i < v.size(); ++i) {
v[i] = v[i] * 2 ; v[i] = v[i] * 2 ;
} }
Vector aux = v; Vector aux = v;
aux = v; aux = v;
if (aux <= v) { /* ... */ } if (aux <= v) { /* ... */ }
} }

14
 El tipo array proporciona operadores predefinidos para la copia y asignacion
(=), para las operaciones relacionales (==, !=, >, >=, <, <=)3 y para acceder al
numero de elementos que componen un array (size()). Ademas, se permite la
devolucion de valores de tipo array desde funciones y es posible chequear si el
acceso a elementos del array utiliza ndices dentro del rango definido para el
mismo.
Notese que, en caso de utilizar un compilador que no soporte el nuevo
estandar C++11, la inicializacion de variables de tipo array de TR1 se de-
bera hacer con la enumeracion de los valores constantes entre llaves dobles.
En la seccion 7.2.4 se describe el paso de parametros de arrays de la biblioteca
estandar de C++.

6.4.3. Comparativa entre ambos mecanismos

La introduccion del tipo array de la biblioteca estandar de C++ aporta
numerosas ventajas respecto al uso de arrays predefinidos:
Permite disponer de un tipo de datos que es consistente con el resto de
tipos y dispone de los operadores predefinidos con los comportamientos
habituales. Ello facilita la inicializacion y copia de arrays mediante el
operador de asignacion, la devolucion de arrays por funciones, y el uso de
los operadores relacionales con el comportamiento esperado, como ocurre
en el resto de tipos.
Permite determinar el numero de elementos del array con el operador
size(), en lugar de hacerlo mediante la constante empleada en la defini-
cion del array. Ello disminuye el acoplamiento en el programa respecto a
un valor constante global, y hace que el programa sea mas robusto.
Mejora las facilidades de depuracion y localizacion de errores, ya que hace
posible la deteccion de accesos fuera de rango a elementos del array me-
diante el flag de compilacion -D_GLIBCXX_DEBUG 4 .
Por el contrario, el tratamiento de los arrays predefinidos en C y C++ no
es consistente con el tratamiento de los otros tipos de datos y presenta ademas
algunas anomalas. Por ejemplo:
No es posible la asignacion directa de variables de tipo array predefinido,
ni su devolucion por parte de una funcion. Sin embargo, si el array pre-
definido se encuentra dentro de un registro, el registro si se puede asignar
y devolver.
La aplicacion de los operadores relaciones produce resultados inesperados.
El paso de parametros de arrays predefinidos (sin utilizar el paso por
referencia de C++) es propenso a errores no detectables en tiempo de
compilacion (no comprueba que el numero de elementos de los parametros
sea correcto, as como permite la utilizacion del operador de asignacion
con resultados inesperados). Vease 7.1.3.
3 En este caso, es necesario que los operadores relacionales esten definidos para el tipo base

del array.
4 Disponible en versiones de GCC posteriores a Noviembre de 2012 (version 4.8).

Tambien se puede incorporar de forma facil a las versiones actuales (instalando

http://www.lcc.uma.es/ %7Evicente/docencia/cpplibs/array tr1.zip)

15
 Los arrays predefinidos tienen una conversion implcita automatica al tipo
puntero que es indeseable en muchos casos.
Finalmente, el tipo array de la biblioteca estandar de C++ proporciona
tanto el constructor por defecto como el constructor de copia y el operador
de asignacion, por lo que podra ser utilizado adecuadamente tanto en entornos
de clases (class) como en entornos de programacion generica (templates),
as tambien como tipo base de los contenedores estandares (vector, deque,
stack, list, etc.). Esto no es posible con los arrays predefinidos.
Clases: Clases Genericas:
class Pixel { template <typename TIPO>
public: class Dato {
Pixel() : rgb() {} public:
Pixel(const Pixel& o) Dato() : dat() {}
: rgb(o.rgb) {} Dato(const Dato& o)
Pixel& operator=(const Pixel& o) : dat(o.dat) {}
{ Dato(const TIPO& o)
rgb = o.rgb ; : dat(o) {}
return *this ; Dato& operator=(const Dato& o)
} {
private: dat = o.dat ;
array<short, 3> rgb ; return *this ;
// short rgb[3] ; // ERROR }
} ; void set(const TIPO& o)
{
Genericidad: dat = o ;
}
template <typename Tipo> TIPO get() const
void intercambio(Tipo& x, Tipo& y) {
{ return dat ;
Tipo aux = x ; }
x = y ; private:
y = aux ; TIPO dat ;
} } ;

typedef array<short, 3> RGB ;

// typedef short RGB[3] ; // ERROR
int main()
{
RGB rgb1, rgb2 ;
vector<RGB> imagen ;
Dato<RGB> dat ;
intercambio(rgb1, rgb2) ;
imagen.push_back(rgb1) ;
dat.set(rgb1) ;
rgb2 = dat.get() ;
}

En contra del uso del tipo array se puede argumentar que, aunque forma
parte del estandar de C++, es posible que algunos compiladores aun no lo incor-
poren. Sin embargo, los compiladores mas usados si lo incorporan (incorporado
en 2005 a la version 4.0 de GCC en TR1, y en 2007 a la version 4.3 de GCC
como soporte experimental para C++11 en la biblioteca estandar) y es, ademas,
facilmente incorporable a otros compiladores mas antiguos.

6.5. Cadenas de Caracteres

6.5.1. Cadenas de caracteres en C
En C las cadenas de caracteres se gestionan mediante arrays predefinidos
de caracteres (tipo char) de un determinado tamano especificado en tiempo de
compilacion. Una cadena esta formada por la secuencia de caracteres compren-
didos entre el principio del array y un caracter terminador especial, que marca el

16
final de la misma (el caracter \0). Por lo tanto, siempre habra que considerar
que el array tenga espacio suficiente para almacenar dicho caracter terminador.
Las cadenas de caracteres constantes literales se expresan como una secuencia
de caracteres entre comillas dobles (").
Al estar definidas como arrays predefinidos de caracteres, todo lo explicado
anteriormente respecto a los arrays predefinidos (vease 6.4.1) tambien se aplica
a las cadenas de caracteres. En la seccion 7.1.4 se describe el paso de parametros
de cadenas de caracteres en C.

6.5.2. El Tipo string de la biblioteca estandar de C++

El tipo string de la biblioteca estandar de C++ permite representar cadenas
de caracteres de longitud finita, limitada por la implementacion. Para ello, se
debe incluir la biblioteca estandar <string>, as como utilizar el espacio de
nombres de std.
Es posible asignar (=) un string a variables de dicho tipo, usar los operadores
relacionales (==, !=, >, >=, <, <=) con el comportamiento esperado y devolver un
string desde una funcion. El paso de parametros, tanto por valor como por refe-
rencia y referencia constante, es robusto y mantiene su semantica previamente
establecida.
Ademas, es posible acceder al numero de elementos que lo componen me-
diante el operador size(), acceder a los caracteres que lo componen mediante
el operador [i], y utilizar el flag de compilacion -D_GLIBCXX_DEBUG (en GCC)
para generar codigo en el que se compruebe que en los accesos a posiciones de
un string se utiliza un ndice que esta dentro del rango correcto.
Tambien es posible utilizar operadores (+, +=) para concatenar cadenas y
caracteres y otras operaciones utiles, como la obtencion de una nueva subcadena
(de tipo string) a partir de un ndice i, con un tamano especificado por sz.
Por ejemplo:
#include <string>
using namespace std;
int main()
{
string nombre = "pepe" ;
for (unsigned i = 0; i < nombre.size(); ++i) {
nombre[i] = nombre[i] - a + A ;
}
nombre += "Luis" ;
string aux = nombre.substr(5, 2) ;
if (aux <= nombre) { /* ... */ }
}

En la seccion 7.2.5 se describe el paso de parametros del tipo string de la

biblioteca estandar de C++.

6.5.3. Comparativa entre ambos mecanismos

La definicion de cadenas de caracteres del tipo string permite trabajar con
cadenas de caracteres mas robustas y con mejores caractersticas que las cadenas
de caracteres predefinidas de C. Algunas ventajas del uso del tipo string de la
biblioteca estandar de C++ respecto al uso de array de char son:

Es mas simple, ya que dispone de operadores predefinidos (=, ==, !=, >, >=,
<, <=) cuyo comportamiento es el esperado y no requiere considerar casos

17
especiales. En el caso de array de char los operadores relacionales no
proporcionan los resultados esperados y la asignacion solo esta permitida
en la inicializacion y si el elemento a asignar es un literal constante o es
un campo de un registro que se asigna a una variable de tipo registro.
Es consistente con los otros tipos de datos, permitiendo la asignacion (=)
de variables de dicho tipo, el uso de los operadores relacionales con el
comportamiento esperado y su devolucion desde una funcion.

No requiere definir a priori un tamano en tiempo de compilacion para

cada posible cadena de caracteres que utilice nuestro programa.
No es necesario reservar espacio para el caracter terminador ni considerarlo
en cualquier manipulacion.
Permite acceder al numero de elementos que lo componen mediante el
operador size().
Ofrece una entrada/salida mas limpia y segura, sin posibilidad de des-
bordamiento de memoria (buffer overflow ).
Ofrece operadores predefinidos robustos para concatenacion o para anadir
caracteres. Los correspondientes de array de char son propensos a des-
bordamientos de memoria (buffer overflow ).
El paso de parametros del tipo string es consistente con la semantica
de paso por valor, referencia y referencia constante, sin embargo, en el
caso de array de char, se debe realizar como array abierto (constante
o no) o puntero a char, con las inconsistencias que ello comporta, por
ejemplo permite el operador de asignacion (=) y relacionales con resultados
inesperados.
No se puede declarar un array de caracteres dentro de una funcion, y que
la funcion retorne ese array. Esto provoca errores en tiempo de ejecucion
complicados. Por ejemplo:
#include <stdio.h>
#include <string.h>
typedef char Cadena[100] ;
char* proc_1()
{
Cadena res = "hola" ;
return res ;
}
void proc_2(char* c)
{
c = proc_1() ;
}
void proc_3(char* c)
{
strcpy(c, proc_1()) ;
}
int main()
{
Cadena c ;
proc_2(c) ;
printf("%s\n", c) ;
proc_3(c) ;
printf("%s\n", c) ;
}

18
7. Subprogramas: Paso de Parametros
7.1. Subprogramas y paso de parametros en C
7.1.1. Paso de parametros de tipos simples en C
El lenguaje de programacion C solo define el paso por valor de parametros,
por lo que para soportar parametros de salida (o entrada/salida) el progra-
mador debe utilizar explcitamente otros mecanismos, tales como el uso del tipo
puntero, el operador de direccion de memoria (&) y los operadores de desrefe-
renciacion (* y ->).
int mayor(int x, int y)
{
return (x > y) ? x : y ;
}
void intercambiar(int* x, int* y)
{
int aux = *x ;
*x = *y ;
*y = aux ;
}
void proc(int* z)
{
int i = mayor(5, *z) ;
intercambiar(&i, z) ;
}
int main()
{
int x = 5 ;
int y = mayor(9, x) ;
intercambiar(&x, &y) ;
proc(&x) ;
}

Notese como en el ejemplo se muestra que en determinadas ocasiones se debe

utilizar el operador de direccion (&) y el operador de desreferenciacion, y en de-
terminadas ocasiones no se deben utilizar (invocaciones a mayor e intercambiar
desde dentro de proc y main).
La complejidad de este mecanismo hace que no sea adecuado en un contexto
de aprendizaje de la programacion, ya que requiere el dominio de conceptos
complejos que deben ser introducidos en una etapa temprana del aprendizaje,
dificultando el aprendizaje de los conceptos de programacion modular y uso de
subprogramas.

7.1.2. Paso de parametros de tipo registro en C

El uso de registros puede llevar asociado el uso de estructuras de datos que
requieran un considerable uso de memoria. En este caso, su paso por valor puede
suponer una gran sobrecarga (tanto en tiempo como en memoria).
struct Imagen {
int nfils, ncols ;
int img[1000][1000] ;
} ;
int media(struct Imagen img1, int f, int c)
{
/* en este punto, 4 imagenes de (1000x1000) se */
/* encuentran almacenadas en la Pila de ejecucion */
/* con la posibilidad de desborde de la pila */
}
void transformar(struct Imagen img1, struct Imagen* img2)
{
int f, c ;

19
 img2->nfils = img1.nfils ;
img2->ncols = img1.ncols ;
for (f = 0 ; f < img2->nfils ; ++f) {
for (c = 0 ; c < img2->ncols ; ++c) {
img2->img[f][c] = media(img1, f, c) ;
}
}
}
int main()
{
struct Imagen img1, img2 ;
/* ... */
transformar(img1, &img2) ;
}

Por este motivo, en C los tipos estructurados siempre se pasaran como pun-
teros, que en el caso de parametros de entrada deberan ser punteros a constantes.
Por ejemplo:
struct Imagen {
int nfils, ncols ;
int img[1000][1000] ;
} ;
int media(const struct Imagen* img1, int f, int c)
{
/* ... */
}
void transformar(const struct Imagen* img1, struct Imagen* img2)
{
int f, c ;
img2->nfils = img1->nfils ;
img2->ncols = img1->ncols ;
for (f = 0 ; f < img2->nfils ; ++f) {
for (c = 0 ; c < img2->ncols ; ++c) {
img2->img[f][c] = media(img1, f, c) ;
}
}
}
int main()
{
struct Imagen img1, img2 ;
/* ... */
transformar(&img1, &img2) ;
}

7.1.3. Paso de parametros de arrays predefinidos en C

En C no es posible pasar arrays por valor. Al invocar a un subprograma
con un parametro de tipo array se pasa automaticamente la direccion de dicho
array. Posteriormente, cuando se intenta acceder en el cuerpo del subprograma
a los elementos del array, se realiza (de forma automatica y transparente) una
desreferencia que permite acceder a la posicion de memoria adecuada.
#define MAX 10
typedef int Datos[MAX] ;
void inicializar(Datos d)
{
int i ;
for (i = 0 ; i < MAX ; ++i) {
d[i] = i ;
}
}
int suma(Datos d)
{
int i, s = 0 ;
for (i = 0 ; i < MAX ; ++i) {
s += d[i] ;
}
return s ;

20
 }
int main()
{
Datos d ;
inicializar(d) ;
printf("%d\n", suma(d) ) ;
}

Notese como este paso de parametros de arrays (aparentemente un paso por

valor ) actua de forma implcita como un paso por referencia, permitiendo que
desde dentro del subprograma se modifique el parametro. Para evitar esta cir-
cunstancia, cuando se desee pasar un array como parametro de entrada a un
subprograma se debe cualificar el parametro con const, consiguiendo as que el
compilador nos avise de accesos incorrectos al parametro en los que se intente
modificar alguna posicion del array. Por ejemplo:
int suma(const Datos d)
{
int i, s = 0 ;
for (i = 0 ; i < MAX ; ++i) {
s += d[i] ;
}
return s ;
}

Tambien es posible realizar el paso de parametros de arrays abiertos (en caso

de multiples dimensiones, solo se permite dejar abierta la primera dimension),
por ejemplo:
int copiar(int d[], int nd, const int o[], int no)
{
int i, m = menor(nd, no) ;
for (i = 0 ; i < m ; ++i) {
d[i] = o[i] ;
}
return m ;
}

El paso de parametros de arrays en C esta sujeto a numerosas peculiaridades

que hacen de su tratamiento un caso excepcional con respecto a los otros tipos y
es propenso a introducir numerosos errores de programacion (especialmente en
un contexto de aprendizaje a la programacion), por lo que exige un tratamiento
cauteloso por parte del programador.
No se comprueba que los parametros actuales y formales sean del mismo
tipo (tamano), siendo posible pasar como parametro actual un array de un
tamano diferente al especificado como parametro formal, con los errores
que ello conlleva. Por ejemplo:
#define NELMS_1 9
#define NELMS_2 5
typedef int Vector_1[NELMS_1] ;
typedef int Vector_2[NELMS_2] ;
void copiar(Vector_1 destino, const Vector_1 origen)
{
int i ;
for (i = 0 ; i < NELMS_1 ; ++i) {
destino[i] = origen[i] ;
}
}
int main()
{
Vector_1 v1 = { 1, 2, 3, 4, 5, 6, 7, 8, 9 } ;
Vector_2 v2 ;
copiar(v2, v1) ; /* Error al pasar una variable de tipo Vector_2 */
}

21
 Si se utiliza el operador de asignacion (=), no se produce ningun error de
compilacion. Este comportamiento es diferente si se utiliza la asignacion
entre arrays que no son parametros. En el primer caso el compilador no
nos avisa de ningun error (aunque en realidad obtendremos resultados
inesperados) mientras que en el segundo si tendremos aviso de error. Por
ejemplo:
#define MAX 5
typedef int Datos[MAX] ;
void copiar(Datos d, Datos o)
{
d = o ; /* No error de compilacion. resultados inesperados */
}
int main()
{
Datos d2, d1 = { 1, 2, 3, 4, 5 } ;
d2 = d1 ; /* error: invalid array assignment */
copiar(d2, d1) ;
}

Comportamiento inesperado cuando los cambios realizados en un parametro,

aparentemente pasado por valor, modifican el parametro actual en la lla-
mada.
#define MAX 10
typedef int Datos[MAX] ;
void inicializar(Datos d)
{
int i ;
for (i = 0 ; i < MAX ; ++i) {
d[i] = i ;
}
}
int main()
{
Datos d ;
inicializar(d) ;
}

7.1.4. Paso de parametros de cadenas de caracteres en C

Las cadenas de caracteres en C se definen como arrays predefinidos de tipo
base char, por lo que todo lo mencionado en la seccion 7.1.3 anterior tambien
es aplicable a cadenas de caracteres.
Cuando se trabaja con cadenas de caracteres es frecuente tratar con cadenas
de caracteres almacenadas en arrays de diferentes tamanos. El procesamiento en
subprogramas de dichas cadenas suele ser equivalente, por lo que frecuentemente
es adecuado tratar los parametros de tipo cadena de carateres como arrays
abiertos de tipo char. Ello permite disponer de subprogramas para manipular
cadenas almacenadas en arrays de tamanos diferentes.
En este tipo de situaciones es importante que el subprograma reciba tambien
el tamano maximo que la cadena puede alcanzar. De esta forma podemos evitar
acceder mas alla de sus lmites. Si la cadena se utiliza como parametro de entrada
no es necesario pasar el tamano del array, ya que el final de la cadena viene
marcado por el caracter terminador.
#include <stdio.h>
#define MAX_CADENA 10
typedef char Cadena[MAX_CADENA] ;
void escribir(const char cad[])
{
int i ;

22
 for (i = 0; cad[i] != \0; ++i) {
printf("%c",cad[i]) ;
}
}
int longitud(const char cad[])
{
int i = 0 ;
while (cad[i] != \0) {
++i ;
}
return i ;
}
void copiar(char destino[], const char origen[], int sz)
{
int i ;
for (i = 0; (i < sz-1)&&(origen[i] != \0); ++i) {
destino[i] = origen[i] ;
}
destino[i] = \0 ;
}
int main()
{
Cadena c1 = "Pepe" ;
Cadena c2 ;
int l = longitud(c1) ;
copiar(c2, c1, MAX_CADENA) ;
escribir(c2) ;
copiar(c2, "Luis", MAX_CADENA) ;
escribir(c2) ;
}

Nota: tambien es posible realizar el paso de parametros de cadenas de carac-

teres como char* y const char* con la misma semantica que la especificada
anteriormente.

7.2. Subprogramas y paso de parametros en C++

7.2.1. Paso de parametros de tipos simples en C++
El lenguaje de programacion C++ define el paso por valor y el paso por
referencia de parametros, de tal forma que los parametros de entrada de tipos
simples se pasaran por valor, y los parametros de salida (o entrada/salida) se
pasaran por referencia. Por ejemplo:
int mayor(int x, int y)
{
return (x > y) ? x : y ;
}
void intercambiar(int& x, int& y)
{
int aux = x ;
x = y ;
y = aux ;
}
void proc(int& z)
{
int i = mayor(5, z) ;
intercambiar(i, z) ;
}
int main()
{
int x = 5 ;
int y = mayor(9, x) ;
intercambiar(x, y) ;
proc(x) ;
}

El ejemplo muestra como toda la complejidad asociada del paso de parametros

por referencia es manejada de forma transparente por el compilador, primando

23
su facilidad y consistencia de uso (comparese con la complejidad del codigo
equivalente en C 7.1.1).

7.2.2. Paso de Parametros de tipo registro en C++

En C++ es posible pasar valores de tipo registro como parametros por valor.
Sin embargo, como se vio en una seccion 7.1.2, ello conlleva una sobrecarga
asociada (mayor consumo de memoria, y tiempo de ejecucion en copiar los
elementos), que puede ser considerable en el caso de estructuras grandes.
Por este motivo, en C++ los tipos estructurados siempre se pasaran por
referencia, que en el caso de parametros de entrada deberan ser referencias
constantes. Por ejemplo:
struct Imagen {
int nfils, ncols ;
int img[1000][1000] ;
} ;
int media(const Imagen& img1, int f, int c)
{
/* ... */
}
void transformar(const Imagen& img1, Imagen& img2)
{
img2.nfils = img1.nfils ;
img2.ncols = img1.ncols ;
for (int f = 0 ; f < img2.nfils ; ++f) {
for (int c = 0 ; c < img2.ncols ; ++c) {
img2.img[f][c] = media(img1, f, c) ;
}
}
}
int main()
{
Imagen img1, img2 ;
/* ... */
transformar(img1, img2) ;
}

7.2.3. Paso de parametros de arrays predefinidos en C++

En C++ no es posible pasar valores que sean arrays predefinidos como
parametros por valor. Al igual que ocurre en C (ver seccion 7.1.3) el paso de
un array como parametro supone el paso como parametro de su direccion de
memoria. A diferencia del mecanismo planteado en C para el paso de este tipo
de parametros, en C++ siempre pasaremos los arrays por referencia, emplean-
do paso por referencia constante cuando el parametro sea de entrada 5 . De esta
forma conseguiremos un comportamiento mas robusto que en el enfoque usado
en C.
const int MAX = 10 ;
typedef int Datos[MAX] ;
void inicializar(Datos& d)
{
for (int i = 0 ; i < MAX ; ++i) {
d[i] = i ;
}
}
int suma(const Datos& d)
{
int s = 0 ;
for (int i = 0 ; i < MAX ; ++i) {
s += d[i] ;
5 Notese que este enfoque no podra ser empleado en caso de arrays abiertos.

24
 }
return s ;
}
int main()
{
Datos d ;
inicializar(d) ;
printf("%d\n", suma(d) ) ;
}

En la seccion 7.1.3 vimos como el paso de parametros de tipo array en C

tiene una serie de inconvenientes. El uso del paso por referencia para parametros
de tipo array proporciona una serie de ventajas que permiten superar dichos
inconvenientes:

Chequeo de tipos. Al usar el paso por referencia el compilador comprueba

que los parametros actuales y formales sean del mismo tipo, comprobando
que ambos posean el mismo numero de elementos, generando un error en
caso contrario. Por ejemplo:
const int NELMS_1 = 9 ;
const int NELMS_2 = 5 ;
typedef int Vector_1[NELMS_1] ;
typedef int Vector_2[NELMS_2] ;
void copiar(Vector_1& destino, const Vector_1& origen)
{
for (int i = 0 ; i < NELMS_1 ; ++i) {
destino[i] = origen[i] ;
}
}
int main()
{
Vector_1 v1 = { 1, 2, 3, 4, 5, 6, 7, 8, 9 } ;
Vector_2 v2 ;
copiar(v2, v1) ; /* Error de Compilacion */
}

Deteccion de errores por asignacion de arrays. El compilador avisara me-

diante un mensaje de error en caso de que se intente utilizar el operador
de asignacion predefinido (=) para asignar un array a un parametro de
tipo array.
const int MAX = 5 ;
typedef int Datos[MAX] ;
void copiar(Datos& d, Datos& o)
{
d = o ; /* Error de Compilacion */
}
int main()
{
Datos d2, d1 = { 1, 2, 3, 4, 5 } ;
d2 = d1 ; /* error: invalid array assignment */
copiar(d2, d1) ;
}

Deteccion de intento de modificacion de parametros de entrada. El para-

metro actual que se corresponda con un parametro de entrada no debe
verse afectado por ninguna modificacion en el subprograma llamado. Uti-
lizando paso por referencia constante conseguimos que el compilador avise
de cualquier intento de alterar el parametro formal correspondiente, obte-
niendo as un codigo mas robusto.
const int MAX = 5 ;
typedef int Datos[MAX] ;

25
 void inicializar(const Datos& d)
{
for (int i = 0 ; i < MAX ; ++i) {
d[i] = i ; /* Error de Compilacion */
}
}
int main()
{
Datos d ;
inicializar(d) ;
}

7.2.4. Paso de parametros del tipo array de la biblioteca estandar

de C++
El tipo array de la biblioteca estandar es consistente con el resto de tipos
de datos en otros aspectos y tambien lo es en el paso de parametros. Por tanto,
cuando se pasa por valor uno de estos arrays se realiza una copia del valor situado
como parametro actual. Por este motivo y para evitar la sobrecarga asociada
al proceso de copia del valor pasado, cuando este tipo de arrays vayan a ser
utilizados como valores de entrada a subprogramas deben pasarse por referencia
constante. De igual forma, cuando vayan a ser utilizados como valores de salida
o entrada/salida deben ser pasados por referencia. Por ejemplo:
#include <tr1/array>
using namespace std::tr1 ;
typedef array<int, 50> Datos ;
void copiar(Datos& destino, const Datos& origen)
{
destino = origen ;
}
void escribir(const Datos& d)
{
for (unsigned i = 0 ; i < d.size() ; ++i) {
cout << d[i] << ;
}
cout << endl ;
}
int main()
{
Datos datos_1, datos_2 = {{ 1, 2, 3, 4, 5 }} ;
copiar(datos_1, datos_2) ;
escribir(datos_1) ;
}

7.2.5. Paso de parametros del tipo string de la biblioteca estandar

de C++
Al igual que ocurre con los arrays de la biblioteca estandar y por los mismos
motivos, cuando se deseen pasar valores de tipo string como estrada a subpro-
gramas debera hacerse por referencia constante. Asmismo, cuando se deseen
pasar valores de tipo string como parametros de salida o entrada/salida, de-
bera hacerse por referencia. Por ejemplo:
#include <string>
using namespace std ;
void copiar(string& destino, const string& origen)
{
destino = origen ;
}
void escribir(const string& d)
{
for (unsigned i = 0 ; i < d.size() ; ++i) {
cout << d[i] << ;

26
 }
cout << endl ;
}
int main()
{
string nombre_1, nombre_2 = "hola" ;
copiar(nombre_1, nombre_2) ;
escribir(nombre_1) ;
}

8. El Tipo Puntero y la Gestion de Memoria

Dinamica
8.1. El tipo puntero y la gestion de memoria dinamica en
C
8.1.1. El tipo puntero en C
La lenguaje de programacion C permite definir punteros a variables de tipos
especificados. Esta definicion se puede realizar tanto mediante la definicion de
un tipo simbolico:
typedef struct Nodo* PNodo ;
struct Nodo {
PNodo sig ;
int dato ;
} ;
int main()
{
PNodo lista = NULL ;
/* ... */
}

como mediante la definicion explcita de punteros:

struct Nodo {
struct Nodo* sig ;
int dato ;
} ;
int main()
{
struct Nodo* lista = NULL ;
/* ... */
}

Notese que para poder definir listas enlazadas, es necesario proporcionar un

nombre al tipo registro, por lo que la siguiente definicion del tipo registro no es
adecuada para definir listas enlazadas:
typedef struct {
/* Tipo puntero a Nodo */ sig ; /* No es posible definir el enlace */
int dato ;
} Nodo ;
int main()
{
struct Nodo* lista = NULL ;
/* ... */
}

Dada las caractersticas de bajo nivel del lenguaje de programacion C, en las

cuales la utilizacion de punteros surge en muy diversas situaciones, la definicion
explcita de punteros suele ser mas habitual, debido a su flexibilidad y capacidad
de adaptarse mas facilmente a cada contexto de utilizacion. Notese que, en C,
la semantica del paso de parametros por referencia recae en la utilizacion de

27
punteros, por lo que cada tipo de datos es susceptible de ser utilizado como
base para ser apuntado por un puntero.
struct Imagen {
int nfils, ncols ;
int img[1000][1000] ;
} ;
void transformar(const struct Imagen* img1, struct Imagen* img2)
{
/* ... */
}
int main()
{
struct Imagen img1, img2 ;
/* ... */
transformar(&img1, &img2) ;
}

No obstante, para distinguir el tipo puntero a un nodo en memoria dinamica, de

un puntero a un parametro, podra ser conveniente definir el tipo puntero a un
nodo en memoria dinamica con un nombre, de tal forma que pueda ser pasado
como parametro de forma adecuada.
typedef struct Nodo* PNodo ;
struct Nodo {
PNodo sig ;
int dato ;
} ;
void crear(PNodo* l)
{
*l = NULL ;
}
int main()
{
PNodo lista ;
crear(&lista) ;
/* ... */
}

Ademas de las operaciones de asignacion (=) y comparacion (== y !=) entre

punteros del mismo tipo, C posee dos operadores de desreferenciacion, el opera-
dor prefijo asterisco (*) permite desreferenciar un puntero no NULO, y acceder
a todo el objeto apuntado, mientras que el operador postfijo flecha (->) permite
desreferenciar un puntero no NULO, y acceder a un miembro del registro apun-
tado. As mismo, el operador prefijo ampersand (&) permite obtener la direccion
en memoria (valor de un puntero) de un determinado objeto.
struct Imagen {
int nfils, ncols ;
int img[1000][1000] ;
} ;
void transformar(const struct Imagen* img1, struct Imagen* img2)
{
*img2 = *img1 ;
/* ... */
img2->nfils = 2 * img1->nfils ;
}
int main()
{
struct Imagen img1, img2 ;
/* ... */
transformar(&img1, &img2) ;
}

8.1.2. La gestion de memoria dinamica en C

El lenguaje de programacion C proporciona mecanismos para la gestion de
la memoria dinamica mediante las siguientes funciones proporcionadas por la

28
biblioteca estandar (stdlib.h).
void *malloc(size_t size): reserva un area de size bytes en la zona de memo-
ria dinamica (heap), y devuelve un puntero a dicha area reservada.
void *calloc(size_t nelms, size_t size): reserva (e inicializa a cero) un
area de memoria consecutiva en la zona de memoria dinamica (heap) para alma-
cenar un array de nelms elementos de tamano size bytes cada uno, y devuelve
un puntero a dicha area reservada.
void *realloc(void *ptr, size_t size): cambia el tamano del area de memo-
ria dinamica apuntado por ptr para que pase a ocupar un nuevo tamano de size
bytes, y devuelve un puntero a la nueva area reservada. Si el area de memoria
original puede ser expandida o contrada al nuevo tamano size, entonces se ex-
pande o contrae al nuevo tamano, sin necesidad de copiar los datos. Sin embargo,
si el area de memoria original no puede ser expandida, entonces se reserva un
nuevo area de memoria, se copian los datos originales almacenados en el area
original, y se libera el area original. Finalmente se devuelve un puntero al area
reservada.
void free(void *ptr): libera el area de memoria dinamica apuntada por ptr,
que debe haber sido reservada previamente mediante una invocacion a malloc,
calloc o realloc.
El operador sizeof(Tipo) devuelve el tamano en bytes necesario para al-
macenar una variable del tipo especificado. Si este operador se aplica a una
determinada expresion, entonces devuelve el tamano en bytes necesario para
almacenar el resultado de dicha expresion.
struct Dato {
int valor ;
} ;
int main()
{
struct Dato* ptr = malloc(sizeof(*ptr)) ;
if (ptr != NULL) {
ptr->valor = 5 ;
/* ... */
free(ptr) ;
}
}

8.1.3. El operador de direccion en C

El lenguaje de programacion C permite que los punteros no solo apunten
a objetos en memoria dinamica, sino que tambien apunten a objetos alojados
en cualquier parte de la memoria. Para ello, el operador prefijo ampersand (&)
permite obtener la direccion en memoria donde se encuentra alojado un deter-
minado objeto. Esta direccion en memoria se representa mediante un puntero
a la zona de memoria donde se encuentra alojado el objeto. Este mecanismo se
utiliza extensivamente en el paso de parametros (vease 7.1), as como en muy
diversas situaciones.
struct Dato {
int valor ;
} ;

void incremento(int* val, int x)

{
*val += x ;
}
int main()
{

29
 struct Dato dat ;
struct Dato* ptr = &dat ;
int* pv = &ptr->valor ;
ptr->valor = 5 ;
*pv += 3 ;
incremento(&dat.valor, 7) ; /* dat.valor toma el valor 15 */
}

Es importante hacer notar que en un ambito de aprendizaje a la progra-

macion, es posible que la comprension de los conceptos relacionados con los
punteros y la gestion de memoria dinamica se vea dificultada si estos son mez-
clados con los conceptos de punteros a objetos en otras zonas de memoria.

8.1.4. Arrays y aritmetica de punteros en C

Cuando los arrays se pasan como parametros a un subprograma, se produce
una conversion automatica, y lo que realmente se pasa es un puntero al primer
elemento del array. Del mismo modo, cuando se asigna un array a un puntero,
se produce una conversion automatica y se asigna un puntero al primer elemen-
to del array. Dicho de otra forma, siempre que se utiliza un array, se realiza
una conversion automatica y se genera un puntero con la direccion en memoria
del primer elemento del array. Es importante resaltar que esta conversion au-
tomatica de array a puntero no significa que arrays y punteros sean lo mismo,
son conceptos y estructuras diferentes.

#define NELMS 5 p
typedef int Datos[NELMS] ;
int main()
{ dat 0 1 2 3 4
Datos dat = { 0, 1, 2, 3, 4 } ;
int* p = dat ;
int* q = &dat[0] ; q
}

En C es posible utilizar aritmetica de punteros, tanto para sumar (+) como

para restar (-) un numero entero a un puntero. El resultado es un puntero a un
objeto del mismo tipo, pero situado tantas posiciones a la derecha o izquierda
como indique el valor del numero entero sumado o restado.
#define NELMS 5
typedef int Datos[NELMS] ;
int main()
{ dat 5 1 9 7 4
Datos dat = { 0, 1, 2, 3, 4 } ;
int* p = dat ;
int* q = p + 3 ; p
int* r = q - 1 ;
*p = 5 ; q
*q = 7 ;
*r = 9 ; r
}

La siguiente table muestra algunas equivalencias entre operadores al tratar

con arimetica de punteros:
++p p = p + 1
--p p = p - 1
p += n p = p + n
p -= n p = p - n
p[i] *(p + i)

30
8.1.5. Punteros genericos en C
Ademas de la definicion de punteros a tipos especficos, el lenguaje de pro-
gramacion C permite definir punteros a tipos desconocidos (genericidad de bajo
nivel, sin control estricto de tipos), que no pueden ser desreferenciados. Para
poder ser desreferenciados antes deben ser convertidos (casting) a punteros a un
determinado tipo concreto. Las conversiones entre void* y otros tipos punteros
son automaticas en C, y no es necesaria la conversion explcita.
struct Imagen {
int nfils, ncols ;
int img[1000][1000] ;
} ;
void cero(void* dato, unsigned sz)
{
int i ;
char* dat = (char*)dato ;
for (i = 0; i < sz; ++i) {
dat[i] = 0 ;
}
}
int main()
{
struct Imagen img ;
cero(&img, sizeof(img)) ;
}

8.1.6. Tipos opacos en C

As mismo, el lenguaje de programacion C tambien permite la definicion
de tipos opacos mediante la definicion de punteros a tipos incompletos (deben
ser registros), los cuales podran ser definidos en modulos de implementacion
independientes. Estos tipos incompletos deberan ser definidos en el modulo de
implementacion antes de poder ser desreferenciados.
//- dato.h -----------------------------
#ifndef dato_h_
#define dato_h_
typedef struct DatoImpl* Dato ;
Dato crear() ;
void incrementar(Dato d, int x) ;
void destruir(Dato d) ;
#endif
//- dato.c -----------------------------
#include "dato.h"
struct DatoImpl {
int valor ;
};
Dato crear()
{
Dato ptr = malloc(sizeof(*ptr)) ;
if (ptr != NULL) {
ptr->valor = 0 ;
}
return ptr;
}
void incrementar(Dato d, int x)
{
if (d != NULL) {
d->valor += x ;
}
}
void destruir(Dato d)
{
free(d) ;
}
//- main.c -----------------------------
#include "dato.h"

31
 int main()
{
Dato dat ;
dat = crear() ;
incrementar(dat, 5) ;
destruir(dat) ;
}
//--------------------------------------

8.2. El tipo puntero y la gestion de memoria dinamica en

C++
8.2.1. El tipo puntero en C++
Aunque C++ soporta la semantica de punteros de forma similar a C (vease
la seccion 8.1.1), C++ es un lenguaje mas fuertemente tipado que C y esta orien-
tado a la definicion de abstracciones de mas alto nivel. Ademas, C++ soporta
directamente la semantica del paso de parametros por referencia, por lo que
no es necesario utilizar punteros para el paso de parametros. Por todo ello,
la utilizacion de punteros en C++ se restringe mas a entornos de bajo nivel
(encapsulados en abstracciones de mayor nivel) relacionados con la gestion de
memoria dinamica, as como en entornos polimorficos orientados a objetos.
En estas circunstancias de punteros orientados a la gestion de memoria
dinamica, dentro de un entorno academico de aprendizaje de la programacion,
suele ser mas adecuado realizar una definicion simbolica del tipo de datos pun-
tero.6
Al igual que C, el lenguaje C++ posee operadores para asignacion (=) y
comparacion (== y !=) entre punteros del mismo tipo. Del mismo modo, tambien
posee dos operadores de desreferenciacion: el operador prefijo asterisco (*) y el
operador postfijo flecha (->).
typedef struct Nodo* PNodo ;
struct Nodo {
PNodo sig ;
int dato ;
} ;
int main()
{
PNodo lista = NULL ;
/* ... */
if (lista != NULL) {
lista->sig = NULL ;
lista->dato = 5 ;
}
/* ... */
}

8.2.2. La gestion de memoria dinamica en C++

Aunque los mecanismos de gestion de la memoria dinamica en C (vease 8.1.2)
estan soportados en C++, no resultan adecuados en C++. Ello es as porque
C++ esta fuertemente basado en la invocacion automatica de constructores y
destructores, mientras que los mecanismos proporcionados en C no ofrecen dicho
soporte.
6 Laventaja de la definicion del tipo simbolico respecto a la utilizacion del tipo explcito es
equivalente a la ventaja de la definicion de constantes simbolicas respecto a la utilizacion de
constantes explcitas. Ademas, favorece la utilizacion de punteros inteligentes (vease 8.2.7).

32
 As, C++ define dos nuevos operadores (new y delete) que permiten reservar
y liberar memoria dinamica, pero invocando a los contructores y destructores
de los objetos que se crean y destruyen respectivamente.
ptr = new Tipo: reserva un area de memoria dinamica de tamano adecuado
para contener un objeto de tipo Tipo, y lo construye invocando al constructor
especificado. Finalmente devuelve un puntero al objeto alojado y construido en
memoria dinamica.
delete ptr: destruye, invocando a su destructor, el objeto apuntado por ptr, y
libera el area de memoria dinamica que ocupaba. Este objeto debe haber sido
construido utilizando el operador new.
typedef struct Dato* PDato ;
struct Dato {
int valor ;
} ;
int main()
{
PDato ptr = new Dato ;
ptr->valor = 5 ;
/* ... */
delete ptr ;
}

C++ tambien proporciona mecanismos para alojar y desalojar un array de

elementos en memoria dinamica, sin embargo, son raramente utilizados, ya que
C++ proporciona el tipo vector en la biblioteca estandar, que proporciona una
abstraccion de alto nivel mas flexible y potente.
typedef struct Dato* PDato ;
struct Dato {
int valor ;
} ;
int main()
{
PDato ptr = new Dato[5] ;
for (int i = 0; i < 5; ++i) {
ptr[i].valor = 7 ;
}
/* ... */
delete [] ptr ;
}

8.2.3. El operador de direccion en C++

El operador de direccion es similar tanto en C como en C++ (vease 8.1.3).
Sin embargo, es bastante menos utilizado en C++, ya que este dispone del paso
de parametros por referencia. No obstante, suele ser utilizado a menudo para
evitar la autoasignacion en la implementacion del operador de asignacion:
Dato& operator= (const Dato& o)
{
if (this != &o) {
/* asignacion */
}
return *this;
}

8.2.4. Arrays y aritmetica de punteros en C++

Aunque C++ soporta la aritmetica de punteros y la conversion automatica
de arrays predefinidos (vease 8.1.4), dichas caractersticas no suelen ser uti-
lizadas con frecuencia. Ello es as porque C++ esta mas orientado a crear abs-
tracciones de alto nivel sobre los datos. Dichas caractersticas de bajo nivel

33
solo son utilizadas en contadas ocasiones y siempre dentro de abstracciones que
encapsulen estos mecanismos de bajo nivel. De hecho, el tipo vector de la bi-
blioteca estandar proporciona una abstraccion adecuada de alto nivel.

8.2.5. Punteros genericos en C++

C++ soporta la posibilidad de trabajar con punteros a tipos desconocidos
(genericos de bajo nivel) (void*). Sin embargo, no suelen ser utilizados, salvo
en contadas ocasiones que requieran programacion de bajo nivel, porque pueden
dar lugar a construcciones erroneas. De hecho, a diferencia de C (vease 8.1.5), en
C++ las conversiones entre void* y otros tipos de punteros no son automaticas,
y requieren conversiones explcitas.
Ademas, C++ proporciona un mecanismo mas adecuado y robusto (con com-
probacion estricta de tipos) para soportar la genericidad mediante las plantillas
(templates).

8.2.6. Tipos opacos en C++

Al igual que C (vease 8.1.6), C++ permite la definicion de punteros a tipos
incompletos (registros y clases), los cuales podran ser definidos en modulos de
implementacion independientes. Estos tipos incompletos deberan ser definidos
en el modulo de implementacion antes de poder ser desreferenciados.
Ademas, la utilizacion de punteros a tipos incompletos dentro de clases per-
mite definir TADs con implementacion oculta.
//- dato.hpp ---------------------------
#ifndef dato_hpp_
#define dato_hpp_
class Dato {
struct DatoImpl ;
struct DatoImpl* dato ;
public:
Dato() ;
~Dato() ;
void incrementar(int x) ;
} ;
#endif
//- dato.cpp ---------------------------
#include "dato.hpp"
struct Dato::DatoImpl {
int valor ;
};
Dato::Dato() : dato()
{
dato = new DatoImpl ;
dato->valor = 0 ;
}
void Dato::incrementar(int x)
{
dato->valor += x ;
}
Dato::~Dato()
{
delete dato ;
}
//- main.cpp ---------------------------
#include "dato.hpp"
int main()
{
Dato dat ;
dat.incrementar(5) ;
}
//--------------------------------------

34
8.2.7. Punteros inteligentes en C++
La potencia de C++, con contructores, destructores y sobrecarga de opera-
dores, permite definir punteros inteligentes que gestionen automaticamente la
liberacion de los recursos (memoria dinamica) asociados a ellos.
La biblioteca estandar (C++11) define los siguientes punteros inteligentes:
shared_ptr, weak_ptr y unique_ptr, as como el obsoleto auto_ptr. Para
compiladores anteriores al estandar de 2011, se debe utilizar la biblioteca TR1.
As mismo, tambien hace posible la definicion de punteros inteligentes que
proporcionen una considerable ayuda en la depuracion de programas y en el
aprendizaje de los conceptos y practica de punteros y gestion de memoria
dinamica.

9. Conclusion
Este documento presenta las primitivas proporcionadas por los lenguajes de
programacion C y C++ como herramientas docentes para el aprendizaje de la
programacion desde un ambito academico.
As, se ha podido mostrar como para cada construccion alternativa que pre-
senta C++ respecto a C, la alternativa presentada por C++ proporciona un
esquema mas simple, seguro y robusto, ante la introduccion de posibles errores
actuales y futuros, respecto a la propuesta original proporcionada por C.

A. Problemas del uso de printf y scanf: un ejem-

plo
A continuacion mostramos un ejemplo donde se puede comprobar como el
uso de scanf para la entrada de datos hace que un mismo programa produzca
error o no dependiendo de la maquina para la que se compila.
Nota: para solventar el problema indicado (basado en el estandar ANSI C89),
en el estandar C99 existe el especificador z para el tipo size_t.
#include <stdio.h>

struct Dato_1 {
int x ;
size_t y ;
int z ;
} ;

struct Dato_2 {
int x ;
unsigned int y ;
int z ;
} ;

struct Dato_3 {
int x ;
unsigned long long y ;
int z ;
} ;

/*
* El tipo size_t es el tipo del valor devuelto por el operador
* sizeof(...), as como el tipo de numerosos parametros de la
* biblioteca estandar de C (y C++).
*

35
 * Aunque el tipo size_t no es el centro de la argumentacion
* que se describe en este ejemplo, si da idea de los problemas
* asociados al modelo de entrada/salida de C, donde una cadena
* de formato controla la entrada/salida.
*
* El principal problema con size_t es que es un tipo definido
* por la biblioteca estandar sobre el que no se especifica su
* tipo base, y por lo tanto en algunos sistemas de 32 bits se
* define como un tipo unsigned int (de 32 bits), sin embargo,
* en algunos sistemas de 64 bits se define como un tipo
* unsigned long (de 64 bits). Por lo que hacer codigo correcto
* que compile adecuadamente en cualquier maquina, independientemente
* de si es de 32 o 64 bits se vuelve una tarea complicada sin
* utilizar directivas de compilacion condicional (tambien
* dependientes de la maquina).
*
* Este tipo de problema tambien surge cuando se cambia el tipo
* de una variable, parametro o campo de estructura, por ejemplo
* de float a double, de unsigned a int, de short a int, de int
* a long, etc.
*/

void p0_32_bits()
{
/*
* En una maquina de 32 bits, este codigo debe compilar
* adecuadamente, ya que size_t es de tipo unsigned int.
* Sin embargo, en una maquina de 64 bits este codigo
* no compilara adecuadamente (GCC -Wall), y producira
* codigo ejecutable erroneo (en caso de compilar sin flags)
*/
printf("sizeof(char): %u\n", sizeof(char)) ;
}

void p0_64_bits()
{
/*
* En una maquina de 64 bits, este codigo debe compilar
* adecuadamente, ya que size_t es de tipo unsigned long.
* Sin embargo, en una maquina de 32 bits este codigo
* no compilara adecuadamente (GCC -Wall), y producira
* codigo ejecutable erroneo (en caso de compilar sin flags)
*/
printf("sizeof(char): %lu\n", sizeof(char)) ;
}

void p1_32_bits()
{
/*
* Este ejemplo muestra como sera la Entrada/Salida de
* un elemento de tipo size_t en una maquina de 32 bits.
* En una maquina de 64 bits producira errores de compilacion
* (GCC -Wall) o codigo erroneo que afectara a los valores
* de los otros campos.
*/
struct Dato_1 d = { 5, 7, 9 } ;

printf(" X: %d Y: %u Z: %d\n", d.x, d.y, d.z) ;

printf("Introduce un numero: ") ;
scanf(" %u", &d.y) ;
printf(" X: %d Y: %u Z: %d\n", d.x, d.y, d.z) ;
}

void p1_64_bits()
{
/*
* Este ejemplo muestra como sera la Entrada/Salida de
* un elemento de tipo size_t en una maquina de 64 bits.
* En una maquina de 32 bits producira errores de compilacion
* (GCC -Wall) o codigo erroneo que afectara a los valores
* de los otros campos.
*/
struct Dato_1 d = { 5, 7, 9 } ;

36
 printf(" X: %d Y: %lu Z: %d\n", d.x, d.y, d.z) ;
printf("Introduce un numero: ") ;
scanf(" %lu", &d.y) ;
printf(" X: %d Y: %lu Z: %d\n", d.x, d.y, d.z) ;
}

void p2()
{
/*
* Ejemplo para mostrar los problemas de codigo donde el
* formato de Entrada/Salida especifica 64 bits, y el tipo
* de datos es de 32 bits. Se puede apreciar como la salida
* es incorrecta, y la entrada de datos modifica otras
* variables (Z).
*/
struct Dato_2 d = { 5, 7, 9 } ;
printf("Valores correctos: X: %d Y: %u Z: %d\n", d.x, d.y, d.z) ;
printf(" X: %d Y: %llu Z: %d\n", d.x, d.y, d.z) ;
printf("Introduce un numero: ") ;
scanf(" %llu", &d.y) ;
printf(" X: %d Y: %llu Z: %d\n", d.x, d.y, d.z) ;
printf("Valores correctos: X: %d Y: %u Z: %d\n", d.x, d.y, d.z) ;
}

void p3()
{
/*
* Ejemplo para mostrar los problemas de codigo donde el
* formato de Entrada/Salida especifica 32 bits, y el tipo
* de datos es de 64 bits. Se puede apreciar como la salida
* es incorrecta. El error en la entrada de datos dependera
* de si la maquina es big-endian o little-endian.
*/
struct Dato_3 d = { 5, 7, 9 } ;
printf("Valores correctos: X: %d Y: %llu Z: %d\n", d.x, d.y, d.z) ;
printf(" X: %d Y: %u Z: %d\n", d.x, d.y, d.z) ;
printf("Introduce un numero: ") ;
scanf(" %u", &d.y) ;
printf(" X: %d Y: %u Z: %d\n", d.x, d.y, d.z) ;
printf("Valores correctos: X: %d Y: %llu Z: %d\n", d.x, d.y, d.z) ;
}

int main()
{
printf("-------------------------------\n") ;
p0_32_bits() ;
printf("-------------------------------\n") ;
p0_64_bits() ;
printf("-------------------------------\n") ;
p1_32_bits() ;
printf("-------------------------------\n") ;
p1_64_bits() ;
printf("-------------------------------\n") ;
p2() ;
printf("-------------------------------\n") ;
p3() ;
printf("-------------------------------\n") ;
return 0 ;
}

37