// Fig. 5.13: fig05_13.

cpp
// Intento para modificar un apuntador constante a un
// dato no constante.

int main()
{
int x, y;

// ptr es un apuntador constante a un entero que se

puede
// modificar a través de ptr, pero ptr siempre apunta a la
// misma localidad de memoria.
int * const ptr = &x;

*ptr = 7; // permitido: *ptr no es const

ptr = &y; // error: ptr es const; no se puede asignar
nueva dirección

return 0; // indica terminación exitosa

} // fin de main
/// Este programa coloca valores dentro de un arreglo, ordena los valores en orden ascendente, e imprime el arreglo resultante.
#include <iostream>
using std::cout;
using std::endl;
#include <iomanip>
using std::setw;
void ordenamBurbuja( int *, const int ); // prototipo
void intercambio( int * const, int * const ); // prototipo
int main()
{
const int tamanoArreglo = 10;
int a[ tamanoArreglo ] = { 2, 6, 4, 8, 10, 12, 89, 68, 45, 37 };
cout << "Elementos de datos en su orden original\n";
for ( int i = 0; i < tamanoArreglo; i++ )
cout << setw( 4 ) << a[ i ];
ordenamBurbuja( a, tamanoArreglo ); // ordena el arreglo
cout << "\nElementos de datos en orden ascendente\n";
for ( int j = 0; j < tamanoArreglo; j++ )
cout << setw( 4 ) << a[ j ];
cout << endl;
return 0; // indica terminación exitosa
} // fin de main

// ordena un arreglo de enteros mediante el algoritmo de ordenamiento burbuja

void ordenamBurbuja( int *arreglo, const int tamano ){
// ciclo para controlar las pasadas
for ( int pasada = 0; pasada < tamano - 1; pasada++ ) // ciclo para controlar las comparaciones durante cada pasada
for ( int k = 0; k < tamano - 1; k++ ) // intercambia elementos adyacentes, si éstos se encuentran en
desorden
if ( arreglo[ k ] > arreglo[ k + 1 ] )
intercambio( &arreglo[ k ], &arreglo[ k + 1 ] );
} // fin de la función ordenamBurbuja

// intercambia valores en localidades de memoria a los que apuntan ptrElemento1 y ptrElement2

void intercambio( int * const ptrElemento1, int * const ptrElemento2 )
{
int mantiene = *ptrElemento1;
*ptrElemento1 = *ptrElemento2;
*ptrElemento2 = mantiene;

} // fin de la función intercam

// Fig. 5.16: fig05_16.cpp
// Cuando se utiliza al operador sizeof con el nombre de un arreglo
// éste devuelve el número de bytes en el arreglo.
#include <iostream>

using std::cout;
using std::endl;

size_t obtieneTamano( bool * ); // prototipo

int main()
{
bool arreglo[ 20 ];
int a;

cout << "El numero de bytes en el arreglo es "

<< sizeof( arreglo )<<endl;
cout << "El numero de bytes un entero "
<< sizeof( a )<<endl;

cout << "\nEl numero de bytes que devuelve obtieneTamano es "

<< obtieneTamano( arreglo ) << endl;

return 0; // indica terminación exitosa

} // fin de main

// devuelve el tamaño de ptr

size_t obtieneTamano( bool *p )
{
return sizeof( p );

} // fin de la función obtieneTamano

#include<iostream>
using std::cout;
using std ::cin;
using std::endl;
void funcion1( char *, const char * );
void funcion2( char *, const char * );
int main()
{
char cadena1[ 10 ]="MM 314";
char *cadena2 = "Feliz";
char cadena3[ 10 ];
char cadena4[] = "Navidad";
funcion1( cadena1, cadena2 );
cout << "cadena1 = " << cadena1 << endl;
funcion2( cadena3, cadena4 );
cout << "cadena3 = " << cadena3 << endl;
return 0; }

void funcion1( char *s1, const char *s2 ){

for ( int i = 0; ( s1[ i ] = s2[ i ] ) != '\0'; i++ )
;
}
#include<iostream>
using std::cout;
using std ::cin;
using std::endl;
void funcion1( char *, const char * );
void funcion2( char *, const char * );
int main()
{
char cadena1[ 10 ]="MM 314";
char *cadena2 = "Feliz";
char cadena3[ 10 ];
char cadena4[] = "Navidad";
funcion1( cadena1, cadena2 );
cout << "cadena1 = " << cadena1 << endl;
funcion2( cadena3, cadena4 );
cout << "cadena3 = " << cadena3 << endl;
return 0; }

void funcion1( char *s1, const char *s2 ){

for ( int i = 0; ( s1[ i ] = s2[ i ] ) != '\0'; i++ )
;
}