// Ejemplo version 0.07, 06 Dic 2012 By: CompSystems
// Se la paso la vida anhelando que pasara algo maravilloso y lo unico que paso fue la vida.
#include<iostream>
using namespace std;
#include <cstdlib>
typedef unsigned char Byte;
#define NO 0 // No NewLine // No Imprimir una linea en blanco
#define NL 1 // NewLine // Imprimir una linea en blanco
#define PS 2 // Pausar
#define Flag_Pausar 0 // Cambiar 1 para activar las Pausas, 0 para No Pausar
#define PAUSAR system("PAUSE")
#define noConst // empty
//Notación utilizada en los comentarios:
// := (Asignación) por ejemplo a := 2, al identificador a, se le asigna el valor de 2
// => (Contenido) por ejemplo a => 2, el identificador a, tiene como contenido el valor de 2
// idNm (Identifier Name) Nombre Identificador: Variable
// kIdNm (Constant Identifier Name) Nombre Identificador Constante: Variable solo de lectura.
// pIdNm (Pointer Identifier Name) Nombre Identificador: Puntero
// pKIdNm (Constant Pointer Identifier Name) Nombre Identificador: Puntero Constante
// -> (puntero) por ejemplo p1 -> b, p1 apunta a b. ->p1 => 3, el punt p1 tiene como valor final 3
// Funciones para imprimir resultados e informacion
void printStr ( const char kStr[], char TypePrint);
void prtStrAndVal( const char kStr[], char Value, char TypePrint);
void prtStrAndChr( const char kStr[], char Value, char TypePrint);
void prtStr1And2 ( const char kStr[], const char k2Str[], char TypePrint);
void fnt1_val ( char *p1_fnt1_val );
void fnt1_str ( const char *p1_fnt2_str, char SizeFlag );
void function0( const char *p1_fnt0 ){
prtStrAndVal( "->p1_fnt0=", *(p1_fnt0), NO ); // Imprime cadena
}
struct strc1_3elements{
char SubElm1_Byte; // SubElemento1 tipo char
int SubElm2_Int; // SubElemento2 tipo Integer
const char *SubElm3_Array4Elm[ 2 ]; // SubElemento3 tipo char de 2 subelementos (Array)
};
void printStrVal3( strc1_3elements X, char TypePrint);
int main( int argc, char *argv[] ){
printStr( "Identificador Estandar:", PS );
char a = 2; // a := 2 // Declaración y Asignación de un Nombre Identificador (idNm)
// El idNm (a) tiene como tipo de dato char
prtStrAndVal( "a=", a, NO ); // a => 2 // Impresión del dato de idNm.
prtStrAndVal( "a=>", a, NL ); // a => 2
char b = a + 4; // b := 2+4, b := 6 // Declaración y Asignación de un Nombre Identificador (idNm)
prtStrAndVal( "b=", b, NL ); // b => 6 // Impresión del dato o valor del idNm
printStr( "Identificador Constante:", PS );
char const kA = 2; // lock kA := 2 // Declaración y Asignación de un Nombre Identificador Constante (kIdNm )
prtStrAndVal( "kA=", kA, NL ); // kA => 2
//kA = 7;
//prtStrAndVal( "kA=>", kA, NL ); // kA => 7
// Descomentar las 2 lineas anteriores para verificar que no se puede reescribir
const char kA1 = 2;
prtStrAndVal( "kA1=", kA1, NL ); // kA1 => 2
//kA1 = 55;
//prtStrAndVal( "kA1=>", kA1, NL ); // kA1 => 55
// Descomentar las 2 lineas anteriores para verificar que no se puede reescribir
// En el encabezado se definio noConst como vacio, simplemente como palabra didactica
//noConst char c = 2; // c := 2 // Declaración y Asignación de un Nombre Identificador No Constante
//prtStrAndVal( "c=", c, NO ); // c => 2 // Impresión del dato de idNm.
// Descomentar las 2 lineas anteriores para ejecutar las sentencias
printStr( "Identificadores Punteros:", NO );
printStr( "Caso I: Puntero No Constante a Dato No Constante", PS );
printStr( "ptr1:", NL );
char *p1 = &a; // p1 -> a, a => 2 // Declaración y Asignación de un Nombre Identificador Puntero (pIdNm)
// p1 apunta a un tipo de dato Byte
// noConst char *noConst p1 = &a; // La Declaración y Asignación anterior se puede ver como esta
prtStrAndVal( "->p1=", *p1, NO ); // (->p1 and a) => 2 // 2 es el valor contenido por la direccion final del pIdNm
prtStrAndVal( "a=", a, NL ); // a => 2 // Prueba del contenido final de la direccion apuntada.
printStr( "ptr2:", NL );
char *p2; // p2 -> ? // Solo Declaración de un Nombre Identificador Puntero (pIdNm)
p2 = &b; // p2 -> b, b => 6 // Asignación de una direccion al pIdNm.
prtStrAndVal( "->p2=", *p2, NO ); // (->p2 and b) => 6
prtStrAndVal( "b=", b, NL ); // b => 6 // Prueba del contenido final de la direccion apuntada.
p2 = p1; // p2 -> p1, Como p1 -> a entonces p2 -> a, a => 2 // Cambio de dirección de apuntamiento de p2
prtStrAndVal( "->p1=", *p1, NO ); // (->p1 and ->p2) => 2
prtStrAndVal( "->p2=", *p2, NO ); // (->p2 and a) => 2
prtStrAndVal( "a=", a, NL ); // a => 2 // Prueba del contenido final de la direccion apuntada.
*p2 = 4; // p2 -> p1, p1 -> a, a := 4 // Reasignación del contenido de apuntamiento.
prtStrAndVal( "->p1=", *p1, NO ); // (->p1 and ->p2) => 4
prtStrAndVal( "->p2=", *p2, NO ); // (->p2 and a) => 4
prtStrAndVal( "a=", a, NL ); // a => 4 // Prueba del contenido final de la direccion apuntada.
*p2 = *p2 + 3; // p2 -> p1, p1 -> a, a := a + 3: a:= 7
prtStrAndVal( "->p2=", *p2, NO ); // (->p2 and a) => 7
prtStrAndVal( "a=", a, NL ); // a => 7 // Prueba del contenido final de la direccion apuntada.
// Ver otros tipos de operaciones con punteros
printStr( "ptr3:", NL );
char *p3 = p2; // p3 -> p2 Como p2 -> p1 y p1 -> a,Entonces p3 -> a , a => 7 // Declaración y Asignación de pIdNm
// char *p3 = &p2; // &p2, No valido. direccion de direccion
// char *p3 = 0x3F; // En algunos casos es valido
// Descomentar las 2 lineas anteriores para verificar la sintaxis invalida
prtStrAndVal( "->p3=", *p3, NO ); // ->p3 and a => 7
prtStrAndVal( "a=", a, NL ); // a => 7 // Prueba del contenido final de la direccion apuntada.
*p3 = 9; // p3 -> a, a := 9 // Reasignación del contenido del apuntamiento.
prtStrAndVal( "->p3=", *p3, NO ); // ->p3 => 9
prtStrAndVal( "a=", a, NL ); // a => 9 // Prueba del contenido final de la direccion apuntada.
printStr( "Arreglos:", NL );
printStr( "Arreglos numericos: 01324, ...", PS );
char num[4]= { 19, 12, 13, 14 }; // num0 := 19, num1 := 12, num2 := 13 num3 := 14
prtStrAndVal( "num[0]=", num[0], NO ); // num[0]=>19 Despliega el contenido del 1er elemento
prtStrAndVal( "num[1]=", num[1], NO ); // num[1]=>12 Despliega el contenido del 2d0 elemento
prtStrAndVal( "num[2]=", num[2], NO ); // num[2]=>13 Despliega el contenido del 3er elemento
prtStrAndVal( "num[3]=", num[3], NL ); // num[3]=>14 Despliega el contenido del 4to elemento
num[0] = 11; // Reasignación del contenido del primer elemento num[0]
prtStrAndVal( "num[0]=", num[0], NL ); // num[0]=>11 Despliega el contenido del 1er elemento
// No funciona esto
//char num2[5]; // Declaracion de un idNm de 5 caracteres consecutivos
//num2[5] = { 11, 12, 13, 14 }; // d0 := 11, d1 := 12, d2 := 13, d3 := 14
//Descomentar las 2 lineas anteriores para verificar la sintaxis invalida
p3 = &( num[0] ); // p3 -> num[0], num[0] => 11 // Redireccionamiento de p3 a num[0]
prtStrAndVal( "->p3=", *p3, NO ); // ->p3 and num[0] => 11
prtStrAndVal( "num[0]=", num[0], NL ); // num[0] => 11 // Prueba del contenido final de la direccion apuntada.
p3 = num; // == p3 = &( num[0] ) // El nombre de un array es igual a la direc del mismo
prtStrAndVal( "->p3=", *p3, NO ); // ->p3 and num[0] => 11
prtStrAndVal( "num[0]=", num[0], NL ); // num[0] => 11 // Prueba del contenido final de la direccion apuntada.
// La sentencia p3 = num; es equivalente a p3 = &( num[0] );
printStr( "", NL );
printStr( "Desplazamiento de direccion >>:", PS);
prtStrAndVal( "->p3=", *p3, NO ); // num[0] => 11
p3 = p3 + 2; // p3 -> (p3 + 2pos), p3 -> num[ 0+2 ] , p3 -> num[2], num[2] => 13
prtStrAndVal( "->p3=", *p3, NO ); // num[2] => 13
prtStrAndVal( "num[2]=", num[2], NL ); // num[2] => 13 // Prueba del contenido final de la direccion apuntada.
//p3 = p3 + 4; // p3 -> p3 + 4pos , p3 -> num[ 0+4 ] , p3 -> num[4] No existe se sale del array, apunta a una dir no calculada por el algoritmo
//prtStrAndVal( "->p3=", *p3 );
// Descomentar las 2 lineas anteriores para verificar el desborde de la direccion
prtStrAndVal( "->p3=", *p3, NO ); // num[2] => 13
b = *p3 + 4; // b := num[2] + 4, b := 13 + 4, b := 17
prtStrAndVal( "b=", b, NO ); // b => 14
printStr( "Nota: (p3 + 4) es diferente a (*p3 + 4)", NL );
printStr( "Desplazamiento de direccion <<:", PS );
p3 = &( num[2] ); // p3 -> num[2], num[2] => 13 // Redireccionamiento de p3
prtStrAndVal( "->p3=", *p3, NO ); // num[2] => 13
p3 = p3 - 1; // p3 -> (p3 - 1pos), p3 -> num[ 2-1 ] , p3 -> num[1], num[1] => 13
prtStrAndVal( "->p3=", *p3, NO ); // num[1] => 12
prtStrAndVal( "num[1]=", num[1], NL ); // num[1] => 12 // Prueba del contenido final de la direccion apuntada.
//prtStrAndVal( "->p3=", *p3, NO ); // num[1] => 12
//p3 = p3 - 2; // p3 -> (p3 - 2pos), p3 -> num[ 1-2 ] , p3 -> num[-1], num[-1] => ?,
//No existe en el array, apunta a una dir no calculada por el algoritmo
//prtStrAndVal( "->p3=", *p3, NO ); // num[-1] => ??
//prtStrAndVal( "num[0]=", num[-1], NL ); // num[-1] => ?? // Prueba del contenido del puntero
//Descomentar las 4 lineas anteriores para verificar el desborde de la direccion
prtStrAndVal( "->p3=", *p3, NO ); // num[1] => 12
b = *p3 - 2; // b := num[1] - 2, b := 12 - 2, b := 10
prtStrAndVal( "b=", b, NO ); // b => 10
printStr( "Nota: (p3 - 2) es diferente a (*p3 - 2)", NL );
printStr( "Manejo de Identificadores Punteros con Subindices", PS );
p1 = &( num[0] ); // p1 -> num[0], num[0] => 11 // Redireccionamiento de p1
prtStrAndVal( "->p1=", *p1, NO ); // num[0] and p1 => 11
p2 = &( p1[0] ); // == p2 = p1 + 0; // p2 -> p1[0], como p1[0] -> num[0], entonces p2 -> num[0]
prtStrAndVal( "->p2=", *p2, NO ); // num[0] => 11
p2 = &( p1[3] ); // == p2 = p1 + 3; // p2 -> p1[3], como p1[3] -> num[0+3], entonces p2 -> num[3]
prtStrAndVal( "->p2=", *p2, NL ); // num[3] => 14
a = p1[0]; // == a = *( p1+0 ); // pidNm[ # ] se debe tener mucho cuidado a donde apunta inicialmente
prtStrAndVal( "a=", a, NO ); // a => 11
a = p1[1]; // == a = *( p1+1 ); // a := num[0+1], a := num[1], a => 12
prtStrAndVal( "a=", a, NO ); // a => 12
a = p1[2]; // == a = *( p1+2 );
prtStrAndVal( "a=", a, NL ); // a => 13
a = *(p1+0);
prtStrAndVal( "a=", a, NO ); // a => 11
a = *(p1+1);
prtStrAndVal( "a=", a, NO ); // a => 12
a = *(p1+2);
prtStrAndVal( "a=", a, NL ); // a => 13
p1 = &( num[2] ); // p1 -> num[2], num[2] => 13 // Redireccionamiento de p1
prtStrAndVal( "->p1=", *p1, 0 ); // num[2] => 13
a = p1[-1]; // == a = *( p1-1 ); // a := num[2-1], a := num[1], a => 12
prtStrAndVal( "a=", a, NO ); // a => 12 // Coincide con el calculo anterior
a = p1[-2]; // == a = *(p1-2); // a := num[2-2], a := num[2], a => 11
prtStrAndVal( "a=", a, NO ); // a => 11 // Coincide con el calculo anterior
//a = p1[-3]; // == a = *(p1-3); // a := num[2-3], a := num[-1], num[-1]=??
//prtStrAndVal( "a=", a, NO ); // a => ? // Imprime un valor basura
// Descomentar las 2 lineas anteriores para verificarlo
prtStrAndVal( "->p1=", *p1, 0 ); // num[2] => 13
a = *(p1-1);
prtStrAndVal( "a=", a, NO ); // a => 12
a = *(p1-2);
prtStrAndVal( "a=", a, NL ); // a => 11
//a = *(p1-3);
//prtStrAndVal( "a=", a, NL ); a => ? // Imprime un valor basura
// Descomentar las 2 lineas anteriores para verificarlo
printStr( "Manejo de Arrays como Punteros", PS );
// char num[3]= { 20, 55, 87 }; // num0 := 20, num1 := 55, c3 := 87
*(num+0) = 20; // == num[0] = 20;
prtStrAndVal( "num[0]=", num[0], NO );
*(num+1) = 55; //
prtStrAndVal( "num[1]=", num[1], NO );
*(num+2) = 87; //
prtStrAndVal( "num[2]=", num[2], PS );
printStr( "", NL );
printStr( "Desplazamiento de Direccion Formato Simplificado ver def", PS );
// num[3]= { 20, 55, 87 }; // num0 := 20, num1 := 55, c3 := 87
p1 = &( num[0] ); // p1 -> num[0], num[0] => 20 // Re-direccionamiento de p1
prtStrAndVal( "->p1=", *p1, NL ); // num[0] => 20
printStr( "++ como prefijo", NL );
p2 = ++p1; // p2 -> p1, pero efectúa dos operaciones, primero preincrementa el
// apuntamiento de p1 asi: p1 = p1 + 1; (P1 -> num[0+1]) luego redirecciona p2: p2 = p1;// P2 -> num[1]
prtStrAndVal( "->p1=", *p1, NO ); // num[1] => 55
prtStrAndVal( "->p2=", *p2, NO ); // num[1] => 55
prtStrAndVal( "num[1]=", num[1], NO ); // num[1] => 55
printStr( "Note que tanto p1 como p2 apuntan a la misma direccion num[1]", PS );
printStr( "", NL);
printStr( "++ como postfijo", NL);
p1 = &( num[0] ); // p1 -> num[0], num[0] => 20 // Re-direccionamiento de p1
prtStrAndVal( "->p1=", *p1, 0 ); // num[0] => 20
p2 = p1++; // p2 -> p1, pero efectúa dos operaciones, primero redirecciona p2: p2 = p1;// P2 -> num[0]
// luego posincrementa el apuntamiento de p1 asi: p1 = p1 + 1; (P1 -> num[0+1]) luego
prtStrAndVal( "->p1=", *p1, NO ); // num[1] => 55
prtStrAndVal( "->p2=", *p2, NO ); // num[0] => 20
printStr( "Note que tanto p1 como p2 NO apuntan a la misma direccion", PS );
printStr( "Llamada con ++ como prefijo", PS );
p1 = &( num[0] );
prtStrAndVal( "->p1=", *p1, NO ); // num[0] => 20
char c = *( ++p1 ); // Primero preincrementa el apuntamiento de p1 asi: p1 = p1 + 1; (P1 -> num[0+1]) P1 -> num[1]
//luego asigna a c: c = *p1; // P1 -> num[1]
prtStrAndVal( "->p1=", *p1, NO ); // num[1] => 55
prtStrAndVal( " c=", c, PS ); // num[1] => 55
printStr( "Llamada con ++ como posfijo", PS );
p1 = &( num[0] );
prtStrAndVal( "->p1=", *p1, NO ); // num[0] => 20
c = *( p1++ ); // Primero asigna a c: c = *p1; // P1 -> num[0] // Luego
// postincrementa el apuntamiento de p1 asi: p1 = p1 + 1; (P1 -> num[0+1]) P1 -> num[1]
prtStrAndVal( "->p1=", *p1, NO ); // num[1] => 55
prtStrAndVal( " c=", c, NO ); // num[0] => 20
printStr( "Analogamente con -- como pos/prefijo", PS );
printStr( "Punteros como Argumento de Funciones", PS);
printStr( "Utilizando como ejp la funcion: void fnt1_val( char *p1_fnt1_val ){ ... }" , NL );
printStr( "Pensar como una sola sentencia: char *p1_fnt1_val = &( num[0] );", NL);
fnt1_val( &( num[0] ) ); // Llamada de la funcion con el argumento "&( num[0] )"
// *p1_fnt1_val = &( num[0] ); // Transfiere la direccion contenida por Array posicion valor (0) en el pIdNm (p1_fnt1)
prtStrAndVal( "num[0]=", num[0], NL ); // num[1] => 20
printStr( "Utilizando como ejp la funcion: void printStr( const char kStr[], char TypePrint){ cout << Str << endl; ... }" , PS );
printStr( "Pensar como una sola sentencia: const char kStr[] = ''Hola''; char TypePrint = NL;", NL);
printStr( "los objetos temporales y/o literales debeb ser const", PS );
printStr( "Punteros como Argumento de Estructuras", PS );
struct strc1_3elements strc1_ElementX; // Define el id strc1_ElementX de tipo estructura de elementos de nombre strc1_3elements
strc1_ElementX.SubElm1_Byte = 99;
strc1_ElementX.SubElm2_Int = 88;
*(strc1_ElementX).SubElm3_Array4Elm = "Hello3";
//cout << "strc1_ElementX.SubElm1_Byte=" << ((strc1_ElementX).SubElm1_Byte)+0 << endl;
prtStrAndVal( "strc1_ElementX.1=", strc1_ElementX.SubElm1_Byte, NO );
prtStrAndVal( "strc1_ElementX.2=", strc1_ElementX.SubElm2_Int, NO );
//printStrVal3( "strc1_ElementX.3=", (*strc1_ElementX).SubElm3_Array4Elm, NO );
printStr( "Punteros de Cadena de Caracteres", NL );
printStr( "Arreglo Caracteres 'A','B','C'...'1','2','3','@', '#'...", PS );
// Un caracteres se codifica entre comillas simple 'H' y se usa en este tutorial la funcion de impresion prtStrAndVal()
// y una cadena de caractres entre comillas dobles "Hello" y se usa en este tutorial la funcion de impresion printStr()
// Cada caracter tiene asociado un valor numerico entre 64 y 256
// En una cadena o arreglo de caracteres estos se toman como un conjunto de constantes de numeros
char str1[ 4 ] = "ABC"; // Define e inicializa un identificador que contiene un
//arreglo de 4 caracteres constantes "ABC+Nulo", el caracter nulo '\0' no se incluye en la definicion.
// Se puede obviar la definicion de la cantidad de los elementos del arreglo asi:
// char str1[] = "ABC"; // == // char str1[ 4 ] = "ABC";
// Si se incluye el caracter nulo '\0' el arreglo que da como "ABC\0\0"
// char str1_[ 4 ] = "ABC\0"; // == "ABC\0\0"
//char str0[ 4 ];
//str0[4] = "ABC"';
//Descomentar las 2 lineas anterior para verificar QUE NO SE PUEDE primero declarar y luego asignar la cadena.
//pero por que si funciona en funcion
prtStr1And2( "str1=", str1, NL ); // str1 => "ABC" // El caracter nulo no se visualiza
prtStr1And2( "str1=", &str1[0], NO ); // str1 => "ABC"
prtStr1And2( "str1=", &str1[1], NO ); // str1 => "BC"
prtStr1And2( "str1=", &str1[2], NO ); // str1 => "C"
prtStr1And2( "str1=", &str1[3], PS ); // str1 => "" // Nulo
printStr( "", NL );
str1[0] = 'a'; // Reescribiendo la 1er posicion de la cadena de caracteres (Cambio a minuscula)
prtStr1And2( "str1=", str1, NL ); // str1 => "aBC"
str1[1] = 'b'; // Reescribiendo la 2da posicion de la cadena de caracteres (Cambio a minuscula)
str1[2] = '7'; // Reescribiendo la 3 posicion de la cadena de caracteres (Cambio de caracter)
prtStr1And2( "str1=", str1, NL ); // str1 => "ab8"
str1[0] = 'efg'; // Solo toma el 1er byte de derecha a izquierda ('efg') por que la definicon del idNm
// es de 1 Byte (char) // Se genra una advertencia de multiples caracteres o perdida de informacion
prtStr1And2( "str1=", str1, NL ); // str1 => "gb8"
printStr( "Otra definicion para Arreglo de Caracteres", NL );
char str2[ 4 ] = { 'A', 'B', '7', '\0' }; // define e inicializa un identificador que contiene
// un arreglo de 4 caracteres ABCD+Nulo, como lista de caracteres si se debe incluir '\0'
prtStr1And2( "str2=", str2, NO ); // str1 => "ABC"
prtStr1And2( "str2=", &str2[0], NO ); // str2 => "AB7"
prtStr1And2( "str2=", &str2[1], NO ); // str2 => "B7"
prtStr1And2( "str2=", &str2[2], NO ); // str2 => "7"
prtStr1And2( "str2=", &str2[3], PS ); // str2 => "" // Nulo
//prtStr1And2( "str2=", &str2[4], NO ); // str1 => ? // No existe la posicion 4
// Descomentar la linea anterior para verificar el Bug
printStr( "", NL );
char Str3[ 3 ] = "xy"; // Define e inicializa un identificador que contiene
// un arreglo de 3 caracteres xy+Nulo
char *p4 = &( Str3[0] ); // Define un identificador puntero que apunta al identificador Str3,
// Nota: El nombre de una cadena es igual a la direccion inicial del mismo
// char *p4 = Str3; // == // char *p4 = &( Str3[0] );
prtStr1And2( "str3=", p4, NL ); // str3 => "xy"
// Cuando se separa se requiere predefinirlo como connstante
const char *p5; // Solo Declaración de un Nombre Identificador Puntero (pIdNm)
p5 = "xy"; // Asigna la dirección de "xy" a p5 donde "xy" fue almacenado en una posicion de memoria
prtStr1And2( "->p5=", p5, NL ); // str3 => "xy"
// Pero no funciona esto
//char *p5;
//p5 = { 'x', 'y' }; // asigna la dirección de "xy", Duda: "xy" es igual a { 'x', 'x' }?
printStr( "Caso II: Puntero No Constante (Redireccionable) a Dato Constante (const char) (NO reescribible)", PS );
// Sirve por ejemplo para transferir informacion y que esta no se reescriba (solo lectura)
char strn[] = "Enter Equation:";
const char *pStrn_kD; // Caso 2: Declaracion de un Puntero No Constante (Redireccionable)
// a Dato Constante (const char) (NO reescribible)
pStrn_kD = &( strn[0] ); // dir de "Enter Equation:" posicion inicial "E"
prtStr1And2( "->pStrn_kD=", pStrn_kD, NL ); // => "Enter equation:"
//*pStrn_kD = 'e'; // reaccionacion del contenido // pStrn_kD es solo de lectura
// Descomentar la linea anterior para verificar QUE NO SE PUEDE modificar el contenido
// de la direccion apuntada por ser un dato constante
pStrn_kD = &( strn[6] ); // Pero si se puede redireccionar un ptr no constante.
prtStr1And2( "->pStrn_kD=", pStrn_kD, NL ); // => "Equation:"
////////////////
printStr( "Caso III: Puntero Constante (NO Redireccionable) (*const pkStrn2) a Dato No Constante (Reescribible)", PS );
// Sirve por ejemplo para transferir informacion y que esta no se reescriba (solo lectura)
char strn2[] = "X > -3";
char *const pKStrn2 = &( strn2[0] ); // Decl y asig de un Puntero Constante (NO Redireccionable) (*const pkStrn2)
//a Dato No Constante (Reescribible) // OJO Se requiere definirlo en la declaracion
//char *const pKStrn2;
//pKStrn2 = &( strn2[0] );
//Descomentar las 2 lineas anterior para verificar QUE NO SE PUEDE primero declarar y luego asignar la dir.
prtStr1And2( "->pKStrn2= ", pKStrn2, NL ); // => "Solution is := X > -3"
//pKStrn2 = &( strn2[2] ); // No se puede redireccionar un ptr Constante.
//prtStr1And2( "->pKStrn2=", pKStrn2, NL ); // => "Equation:"
// Descomentar las 2 lineas anterior para verificar QUE NO SE PUEDE redireccionar
//char y = '9';
//pKStrn2 = &( y ); // No debe dejar redireccionar
//Descomentar las 2 lineas anteriores para verificar QUE NO SE PUEDE redireccionar
*pKStrn2 = 'Y'; // SI SE PUEDE modificar el contenido de la direccion apuntada por ser un dato No constante
prtStr1And2( "->pKStrn2= ", pKStrn2, NL ); // => "Enter equation:"
printStr( "Caso IV: Puntero Constante (*const pkArray1) a Dato Constante (const char)", PS );
prtStr1And2( "", "", NL );
char array1[] = { 'A', 9, '9' };
const char *const pKArray1 = &( array1[0] ); // Decl y asig de un Puntero Constante (NO Redireccionable) (*const pkStrn2)
//a Dato Constante (No Reescribible) // OJO Se requiere definirlo en la declaracion
//const char *const pKArray1;
//pKArray1 = &( array1[0] );
//Descomentar las 2 lineas anterior para verificar QUE NO SE PUEDE primero declarar y luego asignar la dir.
prtStrAndChr("->pStr= ", pKArray1[0], NO ); // => 'A'
prtStrAndVal("->pStr= ", pKArray1[1], NO ); // => 9
prtStrAndChr("->pStr= ", pKArray1[2], NO ); // => '9'
//pKArray1 = &( array1[1] ); // No se puede redireccionar
//prtStrAndChr("->pStr= ", pKArray1[1], NO );
//Descomentar las 2 lineas anteriores para verificar QUE NO SE PUEDE redireccionar
//pKArray1 = 'e'; // o se puede redireccionar
//prtStrAndChr("->pStr= ", pKArray1[1], NO );
//Descomentar las 2 lineas anteriores para verificar QUE NO SE PUEDE redireccionar
printStr( " ", PS );
fnt1_str( "Hello", 5 ); // Imprime caracter por caracter
printStr( " ", NL );
printStr( "Valor referencia", NL );
// Escribiendo ...
return 0;
}
void fnt1_val( char *p1_fnt1_val ){ // *p1_fnt1_val = &( num[0] );
prtStrAndVal( "->p1_fnt1_val=", *p1_fnt1_val, NO ); // Imprime valor
};
void fnt1_str( const char *p1_fnt1_str, char SizeFlag ){ // *p1_fnt1_str = "...";
for( char CounterPtr = 0; CounterPtr <= SizeFlag-1; CounterPtr++ ){
prtStrAndChr( "->p1_fnt1_str=", *( p1_fnt1_str+CounterPtr ), PS ); // Imprime caracter * caracter
//PAUSAR;
}
};
// Funciones para Imprimir
void printStr( const char kStr[], char TypePrint){ // Impresion de una cadena
cout << kStr << endl;
if( TypePrint == NL ){
cout<<"\n";
}
else
if( TypePrint == PS && Flag_Pausar == 1 ){
cout<<"\n"; PAUSAR; cout<<"\n";
}
else
if( TypePrint == NO ){
}
//ifend
//ifend
//ifend
}
void prtStrAndVal( const char kStr[], char Value, char TypePrint){ // Impresion de una cadena y de un valor numerico
cout << kStr << Value+0 << endl;
if( TypePrint == NL ){
cout<<"\n";
}
else
if( TypePrint == PS && Flag_Pausar == 1 ){
cout<<"\n"; PAUSAR; cout<<"\n";
}
else
if( TypePrint == NO ){
}
//ifend
//ifend
//ifend
}
void prtStrAndChr( const char kStr[], char Value, char TypePrint){ // Impresion de una cadena y de 1 caracter
cout << kStr << Value << endl;
if( TypePrint == NL ){
cout<<"\n";
}
else
if( TypePrint == PS && Flag_Pausar == 1 ){
cout<<"\n"; PAUSAR; cout<<"\n";
}
else
if( TypePrint == NO ){
}
//ifend
//ifend
//ifend
}
void prtStr1And2( const char kStr[], const char k2Str[], char TypePrint){ // Impresion de 2 cadenas
cout << kStr << k2Str << endl;
if( TypePrint == NL ){
cout<<"\n";
}
else
if( TypePrint == PS && Flag_Pausar == 1 ){
cout<<"\n"; PAUSAR; cout<<"\n";
}
else
if( TypePrint == NO ){
}
//ifend
//ifend
//ifend
}
void printStrVal3( strc1_3elements X, char TypePrint){
//cout << X << endl;
if( TypePrint== NL ){
cout<<"\n";
}
else
if( TypePrint == PS && Flag_Pausar == 1 ){
cout<<"\n"; PAUSAR; cout<<"\n";
}
else
if( TypePrint== NO ){
}
//ifend
//ifend
//ifend
}
//struct strc1_3elements{
// char SubElm1_Byte; // SubElemento1 tipo char
// int SubElm2_Int; // SubElemento2 tipo Integer
// char *SubElm3_Array4Elm[ 2 ]; // SubElemento3 tipo char de 2 subelementos (Array)
//};
