Aprendiendo C/C++ Paso a Paso - Página 9

 printf("\nDirección de A es     : 0x%x", &a);

int *ptr;

puntero   ptr;                 /*  inválido */
``` El problema es que el compilador necesita saber qué tipo de variable apunta el puntero.  |


|  | Declaración de una variable puntero  
char *cptr;           /* Puntero a carácter */  
int *iptr;            /* Puntero a int */  
float *fptr;            /* Puntero a float */  
struct emp *e;            /* Puntero a datos abstractos emp e */ |

#### Accediendo a la variable apuntada:

Aquí hay una forma especial de acceder a los valores de una variable usando su dirección en lugar de su nombre.



|  | /* 60_addr.c */  
#include   
int main()  
{  
int var1 = 11; /* variable var1 = 11 */  
int *ptr; /* Variable ptr como puntero a */  
  
ptr = &var1; /* Mantener la dirección de var1 en ptr */  
  
printf("Valor de var1 es %d", *ptr); /* Puntero a la dirección de var1 */  
return 0;  
} |


|  | ![](/files/4f55092a-e6b6-422d-af47-d517ba51db5b.jpg) |


Si la declaración es printf ("%d", ptr); entonces muestra el valor de ptr, es decir, la dirección de var1, pero la declaración anterior puede mostrar el contenido de la dirección, que se almacenó en la variable ptr.

Programa para demostrar el uso de Dirección_De y Puntero_A


|  | /* 61_ptrdemo.c */  
#include   
int main()  
{  
int a = 10, *p; /* Entero a y puntero p */  
p = &a; /* Asignar dirección de a a p */  
  
printf("\nValor de A : %d", a); /* Contenido de a */  
printf("\nDirección de A : 0x%x", &a); /* Dirección de a */  
printf("\nValor de P : 0x%x", p); /* Contenido de p */  
printf("\nDirección de P : 0x%x", &p); /* Dirección de p */  
printf("\nContenido en dirección de a : %d", *p); /* Puntero a &a */  
return 0;  
} |


#### 5. Aritmética de Punteros

Todas las variables pueden soportar operaciones aritméticas, así como también podemos realizar operaciones aritméticas en punteros. El lenguaje C/C++ puede soportar 4 operaciones aritméticas en punteros, a saber.


|  | Operación  
Adición  
Sustracción  
Incremento  
Decremento | Símbolo  
+  
-  
++  
-- |



Nota: La característica principal de la aritmética de punteros es que los operadores anteriores se aplican en bytes con referencia a su tipo de variable.


|  | /* 62_ptr.c */  
/* Demostración de aritmética de punteros */  
#include   
int main()  
{  
int a, *p;  
a = 100;  
p = &a;  
(*p)++; /* Incrementar puntero a (contenido en dirección) en 1 */  
printf("%d", *p);  
return 0;  
} |
|  | Salida  
101 |


Demostración de la aritmética de punteros, Incrementar el valor de la dirección


|  | /* 63_ptr.c */  
/* Incrementar el valor de la dirección en 1 */  
#include   
int main()  
{  
int a, *p;  
a = 100;  
p = &a;  
*p++; /* Incrementar el valor de la dirección en p en 1 */  
printf("%d", *p);  
return 0;  
}  |
|  | Salida  
Salida inesperada |


El programa anterior ilustra los operadores aritméticos con respecto tanto al valor como a la incrementación de la dirección. p es una variable puntero y a se asigna con 100, así como p se asigna con la dirección de a.

Ahora *p++ afecta a incrementar o realmente saltar la memoria en 2 bytes para obtener una nueva dirección y su contenido.  

Si es **(*p)++, entonces el contenido apuntado por p** es 100, se incrementa, resultando en 101.

#### 6. Punteros y Arreglos

En el lenguaje C/C++, los tipos de datos punteros y arreglos se asemejan entre sí. Los elementos del arreglo se refieren así como la variable puntero, ambos se utilizan para contener la dirección de los elementos de datos en memoria.


|  | char name[20];  
O  
char *name ;  
  
char months[12][10];  
O  
char **months; |


Hay una estrecha asociación entre punteros y arreglos. Aquí hay una revisión sobre arreglos.


|  | /* 64_ptrarr.c */  
#include   
int main()  
{  
int i, a[5] = { 56, 43, 78, 98, 12 };  
for( i = 0; i < 5; i++)  
printf("\n%d", a[i]);  
return 0;  
} |


Hay una posibilidad de acceder a los elementos del arreglo usando la notación de puntero.  
Encuentra la salida del siguiente programa.


|  | /* 65_ptrarr.c */  
#include   
int main()  
{  
int i, a[5] = { 56, 43, 78, 98, 12 };  
for( i = 0; i < 5; i++)  
printf("\n%d", *(a + i) );  
return 0;  
} |


Sigue el siguiente programa:


|  | /* 66_ptrarr.c */  
#include   
int main()  
{  
int i, a[ ] = { 56, 43, 78, 98, 12 }, *p;  
p = a;  
for( i = 0; i < 5; i++)  
printf("\n%d", *(p + i) );  
return 0;  
} |


Aquí hay un enfoque más fácil para imprimir los elementos del arreglo dado (no se requiere tamaño).


|  | /* 67_ptrarr.c */  
#include   
int main()  
{  
int i, a[ ] = { 56, 43, 78, 98, 12 }, *p;  
p = a;  
while (*p)           /* o for(int i = 0; i<5; i++ ) */  
printf("\n%d", *p++);  
return 0;  
} |

#### 7. Punteros y Cadenas

Una cadena es una colección de caracteres que incluye espacios. Esta vez discutimos cómo manejar cadenas usando punteros. No más discusiones para crear confusión. Aquí está la tarea simple para verificar tanto puntero como arreglo de cadenas.

Hay una sutil diferencia entre cadenas y punteros, sigue el programa.


|  | /* 68_ptrstr.c */  
#include   
int main()  
{  
char str1[ ] = "Te gustaría explorar C.";  
char *str2 = "Te gustaría explorar C.";  
puts(str1);  
puts(str2);  
str1++; /* Expresión inválida */  
str2++; /* Expresión válida */  
puts(str2); /* imprime ou gustaría explorar…… */  
return 0;  
} |


Cadenas como Argumentos de Función

Una variable puntero es más flexible que las variables de arreglo, aquí está el programa para demostrar y mostrar una cadena con notación de puntero.


|  | /* 69_ptrarr.c */  
#include   
void disp(char *p);  
int main()  
{  
char str[ ] = "¡Hola!!..¡Hola!!.. ¿Los punteros pueden manejarlo?";  
disp(str);  
return 0;  
} void disp(char *p)  
{  
while(*p)  
printf("%c", *p++);  
} |


Arreglo de punteros a cadenas

Hay una desventaja al almacenar un arreglo de cadenas, en que los subarreglos que contienen la cadena deben tener todos la misma longitud. Por lo que se desperdicia espacio cuando las cadenas son más cortas que los subarreglos.  
Aquí está la solución:


|  | /* 70_strings.c */  
#include   
int main()  
{  
char *weeks[7 ] = { "Domingo", "Lunes", "Martes", "Miércoles",  
"Jueves", "Viernes", "Sábado" };  
int i;  
for( i = 0; i<7; i++)  
puts(weeks[ i ] );  
return 0;  
} |


Cuando las cadenas no son parte de un arreglo, C/C++ las coloca contiguas en memoria, por lo que no hay espacios desperdiciados.  

**/* Un programa de ejemplo para contener un arreglo de punteros de tipo ‘int’ */**


|  | /* 71_ptrarr.c */  
#include   
int main()  
{  
int *arr[4]; /* Arreglo de punteros a int */  
int i = 31, j = 5, k = 19, l = 71, m;  
  
arr[0] = &i;  
arr[1] = &j;  
arr[2] = &k;  
arr[3] = &l;  
  
for(m = 0; m <= 3; m++)  
printf("\n%d", *(arr[m]) );  
return 0;  
} |


Una mirada a las Funciones de Biblioteca

Ya estamos familiarizados con las funciones estándar de cadenas. Tienen argumentos de cadena que se especifican usando notación de puntero,  
Si tenemos claro el concepto de punteros y cadenas, podemos escribir nuestras propias funciones de cadena.  
Aquí hay un programa de ejemplo para copiar cadenas.  

**/* Copia una cadena a otra con punteros */**


|  | /* 72_strcpy1.c */  
#include   
void strcpy1(char * dest, char *src);  
  
int main()  
{  
char *str1 = "¿Cómo puedo aprender más sobre C/C++ !!!";  
char *str2;  
strcpy1(str2, str1);  
puts(str2);  
return 0;  
} void strcpy1(char * dest, char *src)  
{  
while(*src)  
*dest++ = *src++;  
*dest = '\0';  
} |


#### 8. Glosario


| Dirección | Un valor que apunta a una ubicación en memoria. Un puntero contiene la dirección o ubicación de un valor, en lugar del valor en sí. |
| Arreglo | Un arreglo es una colección de elementos de datos del mismo tipo. |
| Contiguo | Una característica de almacenamiento que especifica que los valores se almacenan en ubicaciones consecutivas, ya sea en memoria o en disco. |
| Función | Una serie de instrucciones para realizar una tarea específica, que se puede combinar con otras funciones para crear un programa. |
| Memoria | Descriptivo de un dispositivo o medio que puede aceptar datos, mantenerlos y entregarlos a demanda en un momento posterior. Sinónimo de almacenamiento. |
| Puntero | Contiene la dirección o ubicación de memoria de un valor, en lugar del valor en sí. |
| RAM | (Memoria de Acceso Aleatorio) 1. Un dispositivo de almacenamiento estructurado de tal manera que el tiempo requerido para recuperar datos no se ve afectado significativamente por la ubicación física de los datos.  2. La *sección de almacenamiento primaria* de una computadora personal. |
| Cadena | Un arreglo capaz de almacenar cero o más caracteres. En C, una cadena se declara como un arreglo de caracteres con el carácter NULL (\0) agregado para especificar el final de la cadena. |
| Variable | Un nombre asociado con una ubicación en memoria cuyo valor puede cambiar durante la ejecución del programa. |