Estructuras y Clases en C/C++ (Nuevo Tutorial)

[CompSystems]

Un pequeño ejemplo en el uso de estructuras de datos en C++,  les parece interesante?
Mientras voy avanzando en el auto-aprendizaje de este tema, iré mejorando los ejemplos

El poder del lenguaje C inicia con las estructuras de datos y en C++ con  su evolución (clases)

La siguiente estructura es una lista de objetos la siguiente manera

strc_type = { Miembro1: Caracter,    Miembro2: NumeroEntero,   Miembro3: Arreglo { subMiembro3_0: Caracter, subMiembro3_1: Caracter }, Miembro4: NumeroEntero, Miembro5: Arreglo { subMiembro5_0: Cadena, subMiembro5_1: Cadena, , subMiembro5_2: Cadena },  }

Código: C++

1. #include <iostream>
2. using namespace std;
3. // Version 0.2 mayo 12 2013 By: CompSystems
4.  
5. // Declaracion de la estructura y sus miembros
6. struct strc_NewTypeData{
7.         char member_1;
8.         int  member_2;
9.         char member_3[ 2 ]; // dos submiembros member_3[0] y member_3[1]
10.         int  member_4;
11.         // Arreglo dinamico de elementos, requeire const char *
12.         const char *member_5[ 3 ]; // tres submiembros member_5[0], member_5[1], member_5[2]
13. }
14. // idA;          // Declaracion de un idName dentro de la estructura
15. ; // fin de la estructura
16.  
17. int main( int argc, char *argv[] ){
18.        
19.         struct strc_NewTypeData idA; // Declaracion de idA por fuera de la estructura
20.        
21.         idA.member_1 = '1';    // Asignacion para el miembro #1
22.         idA.member_2 = 2;      // Asignacion para el miembro #2
23.         idA.member_3[0] = 'a'; // Asignacion para el miembro #3 primer elemento
24.         idA.member_3[1] = 'b'; // Asignacion para el miembro #3 segundo elemento
25.         idA.member_4 = 4;      // Asignacion para el miembro #4
26.         // Arreglo dinamico de datos o elementos, miembro#5
27.         idA.member_5[0] = "Hello "; // Asignacion para el miembro #5_0 (6 caracteres + nulo)
28.         idA.member_5[1] = "world";  // Asignacion para el miembro #5_1 (5 caracteres + nulo)
29.         idA.member_5[2] = "!";      // Asignacion para el miembro #5_1 (1 caracter + nulo)
30.        
31.         struct strc_NewTypeData *pIdA= &idA; // Declaracion y Asignacion de pIdA // el Identificador puntero pIdA apunta a IdA
32.        
33.         //Llamada de datos
34.         cout << "Despliegue en pantalla, utilizando\n el identificador normal idA y el operador (.)\n" << endl;
35.         cout << "idA.member_1 = "        << idA.member_1    << endl; // '1'
36.         cout << "idA.member_2 = "        << idA.member_2    << endl; //  2
37.         cout << "idA.member_3[0] = "     << idA.member_3[0] << endl; // 'a'
38.         cout << "idA.member_3[1] = "     << idA.member_3[1] << endl; // 'b'
39.         cout << "idA.member_4 = "        << idA.member_4    << endl; //  4
40.         cout << "idA.member_5[0:1:2] = " << idA.member_5[0]; // "Hello "
41.         cout << idA.member_5[1]; // "world"
42.         cout << idA.member_5[2]; // "!"
43.         cout << "\n" << endl;
44.        
45.         cout << "Despliegue en pantalla, utilizando\n el identificador puntero pIdA y el operador (.)\n" << endl;
46.         cout << (*pIdA).member_1    << endl; // '1' // Nota *pIdA es equivalente a rclData(pIdA)
47.         cout << (*pIdA).member_2    << endl; // 2
48.         cout << (*pIdA).member_3[0] << endl; // 'a'
49.         cout << (*pIdA).member_3[1] << endl; // 'b
50.         cout << (*pIdA).member_4    << endl; // 4
51.         cout << (*pIdA).member_5[0]; // "Hello "
52.         cout << (*pIdA).member_5[1]; // "world"
53.         cout << (*pIdA).member_5[2]; // "!"
54.         cout << "\n" << endl;
55.        
56.         cout << "Otra forma de llamar a los miembros,\nutilizando el identificador puntero y el operador (->)\n" << endl;
57.         cout << pIdA->member_1    << endl; // '1'
58.         cout << pIdA->member_2    << endl; // 2
59.         cout << pIdA->member_3[0] << endl; // 'a'
60.         cout << pIdA->member_3[1] << endl; // 'b
61.         cout << pIdA->member_4    << endl; // 4
62.         cout << pIdA->member_5[0]; // "Hello"
63.         cout << pIdA->member_5[1]; // "world"
64.         cout << pIdA->member_5[2]; // "!"
65.         cout << "\n" << endl;
66.        
67.         cout << "Re-asignacion de los datos de la estructura\n" << endl;  
68.         cout << "utilizando lista de objetos" << endl;
69.  
70.         idA = { '9', 8, { 'c', 'd' }, 7, { "C", "+", "+" } }; // Verificar compatibilidad con otrs compiladores
71.         // Despliegue en pantalla, utilizando el identificador normal
72.         cout << idA.member_1    << endl; // '9'  
73.         cout << idA.member_2    << endl; // 8  
74.         cout << idA.member_3[0] << endl; // 'c'  
75.         cout << idA.member_3[1] << endl; // 'd'  
76.         cout << idA.member_4    << endl; // 7  
77.         cout << idA.member_5[0]; // "C"  
78.         cout << idA.member_5[1]; // "+"  
79.         cout << idA.member_5[2]; // "+"  
80.         cout << "\n" << endl;
81.        
82. }

SALIDA

Despliegue en pantalla, utilizando
 el identificador normal idA y el operador (.)

idA.member_1 = 1
idA.member_2 = 2
idA.member_3[0] = a
idA.member_3[1] = b
idA.member_4 = 4
idA.member_5[0:1:2] = Hello world!

Despliegue en pantalla, utilizando
 el identificador puntero pIdA y el operador (.)

1
2
a
b
4
Hello world!

Otra forma de llamar a los miembros,
utilizando el identificador puntero y el operador (->)

1
2
a
b
4
Hello world!

Re-asignacion de los datos de la estructura

utilizando lista de objetos
9
8
c
d
7
C++

Structuras en QT C++

[migsantiago]

Hola, buen ejemplo. Una pregunta, ¿qué compilador de C++ usaste?

Intenté compilar con Dev C++ y no me permitió el inicializador de la estructura ya a media función.

Voy a probar con Visual C++.

Edito: Tampoco lo permite C++ del .Net framework 4.0.

[CompSystems]

Utilizo los siguientes IDEs y compila OK (pero como salida en consola, no GUI u otro)

ZinjaI  http://zinjai.sourceforge.net/
Code::Blocks
DEV-C++
QT creator



Que mensaje de error, reporta su compilador?

 

[CompSystems]

// Version 0.3a de Estructuras en C/C++, incluye 3 métodos de transferencia de datos por llamada de una funcion con argumentos tipo identificador referencia,  identificador puntero y por valor, para diferenciar ventajas y desventajas de cada uno

Código: C++

1. #include <iostream>
2. using namespace std;
3. // Version 0.3a mayo 12 2013 By: CompSystems
4.  
5. // Declaracion de la estructura y sus miembros
6. struct strc_NewTypeData{
7.         char member_1;
8.         int  member_2;
9.         char member_3[ 2 ]; // dos submiembros member_3[0] y member_3[1]
10.         int  member_4;
11.         // Arreglo dinamico de elementos, requeire const char *
12.         const char *member_5[ 3 ]; // tres submiembros member_5[0], member_5[1], member_5[2]
13. }
14. // idA;          // Declaracion de un idName dentro de la estructura
15. // idA, *ptr1IdA; // Declaracion de idNames dentro de la estructura
16. ; // fin de la estructura
17.  
18. // Prototipos de funciones
19.  
20. void function_dataTransfer_val(          strc_NewTypeData valIdA ); // transferencia de datos por funcion con argumento identificador normal (por valor)
21. void function_dataTransfer_ptr( const strc_NewTypeData *ptr1IdA ); // transferencia de datos por funcion y con identificador puntero
22. void function_dataTransfer_ref( const strc_NewTypeData &refIdA ); // transferencia de datos por funcion y con identificador referencia
23.  
24. int main( int argc, char *argv[] ){
25.        
26.         struct strc_NewTypeData idA; // Declaracion de idA por fuera de la estructura
27.        
28.         idA.member_1 = '1';    // Asignacion para el miembro #1
29.         idA.member_2 = 2;      // Asignacion para el miembro #2
30.         idA.member_3[0] = 'a'; // Asignacion para el miembro #3 primer elemento
31.         idA.member_3[1] = 'b'; // Asignacion para el miembro #3 segundo elemento
32.         idA.member_4 = 4;      // Asignacion para el miembro #4
33.         // Arreglo dinamico de datos o elementos, miembro#5
34.         idA.member_5[0] = "Hello "; // Asignacion para el miembro #5_0 (6 caracteres + nulo)
35.         idA.member_5[1] = "world";  // Asignacion para el miembro #5_1 (5 caracteres + nulo)
36.         idA.member_5[2] = "!";      // Asignacion para el miembro #5_1 (1 caracter + nulo)
37.        
38.         struct strc_NewTypeData *ptrIdA= &idA; // Declaracion y Asignacion de ptrIdA // el Identificador puntero ptrIdA apunta a IdA
39.         // Se puede obviar la palabra clave struct en la sentencia anterior
40.        
41.         //Llamada de datos
42.         cout << "Despliegue en pantalla, utilizando\n el identificador normal idA y el operador (.)\n" << endl;
43.         cout << "idA.member_1 = "        << idA.member_1    << endl; // '1'
44.         cout << "idA.member_2 = "        << idA.member_2    << endl; //  2
45.         cout << "idA.member_3[0] = "     << idA.member_3[0] << endl; // 'a'
46.         cout << "idA.member_3[1] = "     << idA.member_3[1] << endl; // 'b'
47.         cout << "idA.member_4 = "        << idA.member_4    << endl; //  4
48.         cout << "idA.member_5[0:1:2] = " << idA.member_5[0]; // "Hello "
49.         cout << idA.member_5[1]; // "world"
50.         cout << idA.member_5[2]; // "!"
51.         cout << "\n" << endl;
52.        
53.         cout << "idA.member_1 = "        << idA.member_1    << endl; // '1'
54.        
55.         cout << "Despliegue en pantalla, utilizando\n el identificador puntero ptrIdA y el operador (.)\n" << endl;
56.         cout << (*ptrIdA).member_1    << endl; // '1' // Nota *ptrIdA es equivalente a rclData(ptrIdA)
57.         cout << (*ptrIdA).member_2    << endl; // 2
58.         cout << (*ptrIdA).member_3[0] << endl; // 'a'
59.         cout << (*ptrIdA).member_3[1] << endl; // 'b
60.         cout << (*ptrIdA).member_4    << endl; // 4
61.         cout << (*ptrIdA).member_5[0]; // "Hello "
62.         cout << (*ptrIdA).member_5[1]; // "world"
63.         cout << (*ptrIdA).member_5[2]; // "!"
64.         cout << "\n" << endl;
65.        
66.         cout << "Otra forma de llamar a los miembros,\nutilizando el identificador puntero y el operador (->)\n" << endl;
67.         // (*ptrIdA). => ptrIdA->
68.         cout << ptrIdA->member_1    << endl; // '1'
69.         cout << ptrIdA->member_2    << endl; // 2
70.         cout << ptrIdA->member_3[0] << endl; // 'a'
71.         cout << ptrIdA->member_3[1] << endl; // 'b
72.         cout << ptrIdA->member_4    << endl; // 4
73.         cout << ptrIdA->member_5[0]; // "Hello"
74.         cout << ptrIdA->member_5[1]; // "world"
75.         cout << ptrIdA->member_5[2]; // "!"
76.         cout << "\n" << endl;
77.        
78.         cout << "Re-asignacion del miembro_2 de la estructura\n utilizando el puntero ptrIdA" << endl;
79.         (*ptrIdA).member_2 = (*ptrIdA).member_2 * 9; // 2*9=18 
80.         cout << "idA.member_2 = "  << ptrIdA->member_2    << endl; // 18
81.         cout << "idA.member_2 = "  << idA.member_2    << endl;   // 18
82.         cout << "\n" << endl;
83.        
84.         cout << "Re-asignacion de los datos de la estructura\n" << endl;  
85.         cout << "utilizando lista de objetos" << endl;
86.  
87.         idA = { '9', 8, { 'c', 'd' }, 7, { "C", "+", "+" } }; // Verificar compatibilidad con otros compiladores
88.         // Despliegue en pantalla, utilizando el identificador normal idA
89.         cout << idA.member_1    << endl; // '9'  
90.         cout << idA.member_2    << endl; // 8  
91.         cout << idA.member_3[0] << endl; // 'c'  
92.         cout << idA.member_3[1] << endl; // 'd'  
93.         cout << idA.member_4    << endl; // 7  
94.         cout << idA.member_5[0]; // "C"  
95.         cout << idA.member_5[1]; // "+"  
96.         cout << idA.member_5[2]; // "+"  
97.         cout << "\n" << endl;
98.        
99.         cout << "Con transferencia de datos por funcion con argumento identificador puntero" << endl;
100.         // Nueva re-asignación de elementos
101.         idA = {
102.                 'x', // Miembro_1
103.                 5,   // Miembro_2
104.                 { 'y', '7' }, // Miembro_3 (3_0 Y 3_1)
105.                 6, // Miembro_4
106.                 { "A", "BC", "DEF" } // Miembro_5 (5_0, 5_1 Y 5_2)
107.         };
108.        
109.         function_dataTransfer_ptr( &idA );
110.        
111.        
112.         cout << "Con transferencia de datos por funcion con argumento identificador referencia" << endl;
113.         function_dataTransfer_ref( idA );
114.        
115.        
116.         cout << "Con transferencia de datos por funcion con argumento identificador normal (por valor)" << endl;
117.         function_dataTransfer_val( idA );
118.        
119.         return 0;
120. }
121.  
122. void function_dataTransfer_ptr( const strc_NewTypeData *ptr1IdA ){ // *ptr1IdA <- &idA
123.         // Es util que sea el argumento sea una constante para evitar sobre-escritura de informacion de los miembros
124.         cout << ptr1IdA->member_1    << endl;
125.         cout << ptr1IdA->member_2    << endl;
126.         cout << ptr1IdA->member_3[0] << endl;
127.         cout << ptr1IdA->member_3[1] << endl;
128.         cout << ptr1IdA->member_4    << endl;
129.         cout << ptr1IdA->member_5[0] << endl;
130.         cout << ptr1IdA->member_5[1] << endl;
131.         cout << ptr1IdA->member_5[2] << endl;
132.         cout << "\n" << endl;
133.         // (*ptr1IdA).member_2 = (*ptr1IdA).member_2 * 9; // no se puede reasignar el miembro_2 por que se definio como contante en la funcion
134.     // descomentar la linea anterior para comprobarlo
135.        
136. }
137.  
138. void function_dataTransfer_ref( const strc_NewTypeData &refIdA ){ // &refIdA <- idA
139.         // es util que sea el argumento de function_dataTransfer_ref como un identificicador referencia
140.         // ya que no se realiza una copia del mismo en memoria
141.         cout << refIdA.member_1    << endl;
142.         cout << refIdA.member_2    << endl;
143.         cout << refIdA.member_3[0] << endl;
144.         cout << refIdA.member_3[1] << endl;
145.         cout << refIdA.member_4    << endl;
146.         cout << refIdA.member_5[0] << endl;
147.         cout << refIdA.member_5[1] << endl;
148.         cout << refIdA.member_5[2] << endl;
149.         // cout << refIdA->member_5[2] << endl; // esta sentencia no es valida por el argumento es un identificador referencia y no puntero
150.         cout << "\n" << endl;
151. }
152.  
153. void function_dataTransfer_val( strc_NewTypeData valIdA ){
154.         // en este caso hay se hace una copia del dato (estructura) en valIdA
155.         cout << "idA.member_1 = "        << valIdA.member_1    << endl; // '1'
156.         cout << "idA.member_2 = "        << valIdA.member_2    << endl; //  2
157.         cout << "idA.member_3[0] = "     << valIdA.member_3[0] << endl; // 'a'
158.         cout << "idA.member_3[1] = "     << valIdA.member_3[1] << endl; // 'b'
159.         cout << "idA.member_4 = "        << valIdA.member_4    << endl; //  4
160.         cout << "idA.member_5[0:1:2] = " << valIdA.member_5[0]; // "Hello "
161.         cout << valIdA.member_5[1]; // "world"
162.         cout << valIdA.member_5[2]; // "!"
163.         cout << "\n" << endl;  
164.        
165.        
166. }

Cualquier aporte (correciones, ampliacion etc) es bienvenido

[CompSystems]

2do ejemplo de estructuras

El usuario entra una hora, minuto y segundo y la maquina la convierte a formato estandar y universal o militar, ademas se da uso del Operador condicional ternario simbolo (?)

Código: C++

1. #include<iostream>
2. using namespace std;
3. // Version 0.2a mayo 14 2013 By: CompSystems
4. // El usuario entra una hora, minuto y segundo y la maquina la convierte a formato estandar y universal o militar,
5. // ademas se da uso del Operador condicional ternario símbolo (?)
6.  
7. #define True 1
8. #define False 0
9. #define Beep '\a'
10.  
11. struct Time_Type{
12.         int hour;
13.         int minute;
14.         int second;
15.         const char *string[ 4 ];
16. };
17.  
18. int main ( int argc, char *argv[] ) {
19.        
20.         int hour_std;
21.         int flag1 = False;
22.        
23.         struct Time_Type idTime;
24.        
25.         cout << "Entrada de Time" << endl;
26.        
27.        
28.         do{
29.                 cout << "\nEntre Hora: rango valido [ 0 , ..., 23 ]" << endl;
30.                 cout << "Hora = ";
31.                 cin >> idTime.hour;
32.                 flag1 = ( idTime.hour < 0 || idTime.hour > 23 ]?  True: False; // verifica si es un rango valido
33.                 if ( flag1 == True ) {
34.                         cout << Beep; // se emite un sonido
35.                         cout << "\nDato invalido" << endl;
36.                 }
37.         } while( flag1 == True ); // se puede simplificar a while( flag1 );
38.  
39.         do{
40.                 cout << "\nEntre Minuto: rango valido [ 0 , ..., 59 ]" << endl;  
41.                 cout << "Minuto = ";
42.                 cin >> idTime.minute;
43.                 flag1 = ( idTime.minute < 0 || idTime.minute > 59 )?  True: False;
44.                 if ( flag1 == True ) {
45.                         cout << Beep; // se emite un sonido
46.                         cout << "\nDato invalido" << endl;
47.                 }
48.         } while( flag1 == True );      
49.        
50.         do{
51.                 cout << "\nEntre Segundo: rango valido [ 0 , ..., 59 ]" << endl;  
52.                 cout << "Segundo = ";
53.                 cin >> idTime.second;
54.                 flag1 = ( idTime.second < 0 || idTime.second > 59 )?  True: False;
55.                 if ( flag1 == True ) {
56.                         cout << Beep; // se emite un sonido
57.                         cout << "\nDato invalido" << endl;
58.                 }
59.         } while( flag1 == True );      
60.        
61.                
62.         cout << "\nFormato universal o Militar: ";
63.         idTime.string[0] = ( idTime.hour < 10 )?    "0": ""; // Ajuste del prefijo "0" para valores menores de 10
64.         idTime.string[1] = ( idTime.minute < 10 )?  "0": "";
65.         idTime.string[2] = ( idTime.second < 10 )?  "0": "";
66.         idTime.string[3] = "";
67.        
68.         // Despliegue final en pantalla
69.         cout << idTime.string[0] << idTime.hour   << ":"  
70.                  << idTime.string[1] << idTime.minute << ":"  
71.                  << idTime.string[2] << idTime.second << endl; ;
72.        
73.                  
74.         cout << "\nFormato Estandar: ";
75.  
76.         // { 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 } modulo 12 =
77.         // { 0 1 2 3 4 5 6 7 8 9 10 11 0  1  2  3  4  5  6  7  8  9  10 11 }
78.        
79.         hour_std = (idTime.hour)%12;
80.         (hour_std == 0)? (hour_std=12) : (hour_std=hour_std)  ;  // si el modulo es 0 se hace un ajuste a 12 de lo contrario nada
81.         //idTime.string[0] =  ( idTime.hour == 0 || idTime.hour == 12 )?  "12": (idTime.hour)%12 ;      // Como convierto (idTime.hour)%12 a cadena?
82.        
83.         idTime.string[0] = "";
84.         idTime.string[1] = ( idTime.minute < 10 )?  "0": ""; // Ajuste del prefijo "0" para valores menores de 10
85.         idTime.string[2] = ( idTime.second < 10 )?  "0": "";
86.         idTime.string[3] = ( idTime.hour < 12 )?   "AM": "PM";
87.        
88.         // Despliegue final en pantalla
89.         cout << idTime.string[0] << hour_std     << ":"
90.                  << idTime.string[1] << idTime.minute << ":"  
91.                  << idTime.string[2] << idTime.second << " "
92.              << idTime.string[3]
93.                  << endl;
94.        
95.         return 0;
96. }

Una pequeña ayuda como se convierte una expresión (entero) en cadena de manera rápida?

12 -> "12"

[CompSystems]

Igual al ejemplo anterior pero utilizando las funciones printMilitary_ref, printStandard_ref, y con entrada y validación de datos por función

Código: C++

1. #include<iostream>
2. using namespace std;
3. // Segundo ejemplo de clases en C++
4. // Version 0.4 mayo 15 2013 By: CompSystems
5. // El usuario entra una hora, minuto y segundo y la maquina la convierte a formato estandar y universal o militar,
6. // ademas se da uso del Operador condicional ternario símbolo (?)
7.  
8. #define True 1
9. #define False 0
10. #define Beep '\a'
11.  
12. int flag1 = False;
13.  
14. struct Time_Type{
15.         int hour;   // member1
16.         int minute; // member2
17.         int second; // member3
18.         const char *string[ 4 ]; // member4
19. };
20.  
21. // prototipos de funciones
22. void getTime_ref( Time_Type &refIdTime );
23. void setTime_ref( Time_Type &refIdTime, int &idTime_memberX, int memberXPos, int LimInf, int LimSup );
24.  
25. void printMilitary_ref( Time_Type &refIdTime );
26. void printStandard_ref( Time_Type &refIdTime );
27.  
28. int main ( int argc, char *argv[] ) {
29.        
30.         struct Time_Type idTime;
31.        
32.         getTime_ref( idTime );
33.         printMilitary_ref( idTime );
34.         printStandard_ref( idTime );
35.        
36.         return 0;
37. }
38.  
39. void getTime_ref( Time_Type &refIdTime ){
40.         int input;
41.        
42.         cout << "Entrada de Time" << endl;
43.         do{
44.                 cout << "\nEntre Hora: rango valido [ 0 , ..., 23 ]" << endl;
45.                 cout << "Hora = ";  
46.                 cin >> input; // memberX  
47.                 setTime_ref( refIdTime, input, 1, 0, 23 ); // 1 = hour
48.         } while( flag1 == True ); // se puede simplificar a while( flag1 );
49.        
50.         do{
51.                 cout << "\nEntre Minuto: rango valido [ 0 , ..., 59 ]" << endl;  
52.                 cout << "Minuto = ";
53.                 cin >> input; // memberX
54.                 setTime_ref( refIdTime, input, 2, 0, 23 ); // 2 = minute
55.         } while( flag1 == True );      
56.        
57.         do{
58.                 cout << "\nEntre Segundo: rango valido [ 0 , ..., 59 ]" << endl;  
59.                 cout << "Segundo = ";
60.                 cin >> input; // memberX
61.                 setTime_ref( refIdTime, input, 3, 0, 59 ); // 3 = second
62.         } while( flag1 == True );
63.        
64. }
65.  
66. void setTime_ref( Time_Type &refIdTime, int &idTime_memberX, int memberXPos, int LimInf, int LimSup ){
67.        
68.         flag1 = ( idTime_memberX < LimInf || idTime_memberX > LimSup )?  True: False; // verifica si es un rango valido
69.         if ( flag1 == True ) {
70.                 cout << Beep; // se emite un sonido
71.                 cout << "\nDato invalido" << endl;
72.         }else{ // asigna a un miembro especifico dado por el identificador memberXPos
73.                 switch ( memberXPos ) {
74.                 case 1:
75.                         refIdTime.hour = idTime_memberX;
76.                         break;
77.                 case 2:
78.                         refIdTime.minute = idTime_memberX;
79.                         break;
80.                 case 3:
81.                         refIdTime.second = idTime_memberX;
82.                         break;
83.                         //default:
84.                 }
85.         }
86. }
87.  
88.  
89. void printMilitary_ref( Time_Type &refIdTime ){
90.        
91.         cout << "\nFormato universal o Militar: ";
92.         refIdTime.string[0] = ( refIdTime.hour < 10 )?    "0": ""; // Ajuste del prefijo "0" para valores menores de 10
93.         refIdTime.string[1] = ( refIdTime.minute < 10 )?  "0": "";
94.         refIdTime.string[2] = ( refIdTime.second < 10 )?  "0": "";
95.         refIdTime.string[3] = "";
96.        
97.         // Despliegue final en pantalla
98.         cout << refIdTime.string[0] << refIdTime.hour   << ":"  
99.                 << refIdTime.string[1]  << refIdTime.minute << ":"  
100.                 << refIdTime.string[2]  << refIdTime.second
101.                 << endl; ;
102. }
103.  
104. void printStandard_ref( Time_Type &refIdTime ){
105.        
106.         int hour_std;
107.         cout << "\nFormato Estandar: ";
108.        
109.         // { 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 } modulo 12 =
110.         // { 0 1 2 3 4 5 6 7 8 9 10 11 0  1  2  3  4  5  6  7  8  9  10 11 }
111.        
112.         hour_std = (refIdTime.hour)%12;
113.         (hour_std == 0)? (hour_std=12) : (hour_std=hour_std) ;  // si el modulo es 0 se hace un ajuste a 12 de lo contrario nada
114.         //refIdTime.string[0] =  ( refIdTime.hour == 0 || refIdTime.hour == 12 )?  "12": (refIdTime.hour)%12 ;  // Como convierto (refIdTime.hour)%12 a cadena?
115.        
116.         refIdTime.string[0] = "";
117.         refIdTime.string[1] = ( refIdTime.minute < 10 )?  "0": ""; // Ajuste del prefijo "0" para valores menores de 10
118.         refIdTime.string[2] = ( refIdTime.second < 10 )?  "0": "";
119.         refIdTime.string[3] = ( refIdTime.hour < 12 )?   "AM": "PM";
120.        
121.         // Despliegue final en pantalla
122.         cout << refIdTime.string[0] << hour_std         << ":"
123.                 << refIdTime.string[1]  << refIdTime.minute << ":"  
124.                 << refIdTime.string[2]  << refIdTime.second << " "
125.                 << refIdTime.string[3]
126.                 << endl;
127. }

[CompSystems]

comparen el ejemplo anterior utilizando estructuras de datos versus el siguiente que utiliza clases, SE SIMPLIFICA y se CODIFICA MAS amigablemente

// Primer ejemplo de clases en C++
// Version 0.1 mayo 14 2013 By: CompSystems
// El usuario entra una hora, minuto y segundo y la maquina la convierte a formato estandar y universal o militar,
// ademas se da uso del Operador condicional ternario símbolo (?)

Código: C++

1. #include<iostream>
2. using namespace std;
3. // Primer ejemplo de clases en C++
4. // Version 0.4 mayo 15 2013 By: CompSystems
5. // El usuario entra una hora, minuto y segundo y la maquina la convierte a formato estandar y universal o militar,
6. // ademas se da uso del Operador condicional ternario símbolo (?)
7.  
8. #define True 1
9. #define False 0
10. #define Beep '\a'
11.  
12. int flag1 = False;
13.  
14. class Time_Type{
15.  
16.         public: // Interfaz
17.                      Time_Type( ); // Constructor, no requiere el prefijo de tipo de dato
18.                 void getTime(  ); // funcion (get) para obtener del usuario la hora inicial por teclado
19.                 void setTime( int idTime_memberX, int memberXPos, int limInf, int limSup  ); // Funcion para extablecer el valor a cada miembro, ademas de verificar si es un dato valido
20.        
21.                 void printMilitary( );
22.                 void printStandard( );
23.  
24.         private: // Cliente
25.                 int hour;   // member1
26.                 int minute; // member2
27.                 int second; // member3
28.                 const char *string[ 4 ]; // member4
29.                 // No hay funciones auxiliares o de utileria
30. };
31.  
32.  
33. int main (int argc, char *argv[]) {
34.        
35.         class Time_Type idTime; // objeto idTime de la clase Time_Type
36.        
37.         idTime.getTime( );
38.         idTime.printMilitary( );
39.         idTime.printStandard( );
40.        
41.         //idTime.hour = 5; // No se puede asignar a una variable privada
42.                
43.         return 0;
44. }
45.  
46.  
47. Time_Type:: Time_Type( ){ // Inicializa a valores validos
48.         hour = 0;
49.         minute = 0;
50.         second = 0;
51.         string[ 0 ] = "";
52.         string[ 1 ] = "";
53.         string[ 2 ] = "";
54.         string[ 3 ] = "";
55. }  
56.  
57. void Time_Type:: getTime( ){
58.         int input;
59.        
60.         cout << "Entrada de Time" << endl;
61.         do{
62.                 cout << "\nEntre Hora: rango valido [ 0 , ..., 23 ]" << endl;
63.                 cout << "Hora = ";  
64.                 cin >> input; // memberX
65.                 setTime( input, 1, 0, 23 ); // 1 = hour
66.         } while( flag1 == True ); // se puede simplificar a: while( flag1 );
67.        
68.         do{
69.                 cout << "\nEntre Minuto: rango valido [ 0 , ..., 59 ]" << endl;  
70.                 cout << "Minuto = ";
71.                 cin >> input; // memberX
72.                 setTime( input, 2, 0, 59 );  // 2 = minute
73.         } while( flag1 == True );      
74.        
75.         do{
76.                 cout << "\nEntre Segundo: rango valido [ 0 , ..., 59 ]" << endl;  
77.                 cout << "Segundo = ";
78.                 cin >> input; // memberX
79.                 setTime( input, 3, 0, 59 ); // 3 = second
80.         } while( flag1 == True );
81.        
82. }
83.  
84.  
85. void Time_Type:: setTime( int idTime_memberX, int memberXPos, int limInf, int limSup ){
86.        
87.         flag1 = ( idTime_memberX < limInf || idTime_memberX > limSup )?  True: False; // verifica si es un rango valido
88.         if ( flag1 == True ) {
89.                 cout << Beep; // se emite un sonido
90.                 cout << "\nDato invalido" << endl;
91.         }else{ // asigna a un miembro especifico dado por el identificador memberXPos
92.                 switch ( memberXPos ) {
93.                 case 1:
94.                         hour = idTime_memberX;
95.                         break;
96.                 case 2:
97.                         minute = idTime_memberX;
98.                         break;
99.                 case 3:
100.                         second = idTime_memberX;
101.                         break;
102.                 //default:
103.                 }
104.         }
105. }
106.  
107.  
108. void Time_Type:: printMilitary( ){
109.        
110.         cout << "\nFormato universal o Militar: ";
111.         string[0] = ( hour < 10 )?    "0": ""; // Ajuste del prefijo "0" para valores menores de 10
112.         string[1] = ( minute < 10 )?  "0": "";
113.         string[2] = ( second < 10 )?  "0": "";
114.         string[3] = "";
115.        
116.         // Despliegue final en pantalla
117.         cout << string[0] << hour   << ":"  
118.                 << string[1]  << minute << ":"  
119.                 << string[2]  << second
120.                 << endl; ;
121. }
122.  
123.  
124. void Time_Type:: printStandard( ){
125.        
126.         int hour_std;
127.         cout << "\nFormato Estandar: ";
128.        
129.         // { 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 } modulo 12 =
130.         // { 0 1 2 3 4 5 6 7 8 9 10 11 0  1  2  3  4  5  6  7  8  9  10 11 }
131.        
132.         hour_std = (hour)%12;
133.         (hour_std == 0)? (hour_std=12) : (hour_std=hour_std) ;  // si el modulo es 0 se hace un ajuste a 12 de lo contrario nada
134.         // string[0] =  ( hour == 0 || hour == 12 )?  "12": (hour)%12 ; // Como convierto (hour)%12 a cadena?
135.        
136.         string[0] = "";
137.         string[1] = ( minute < 10 )?  "0": ""; // Ajuste del prefijo "0" para valores menores de 10
138.         string[2] = ( second < 10 )?  "0": "";
139.         string[3] = ( hour < 12 )?   "AM": "PM";
140.        
141.         // Despliegue final en pantalla
142.         cout << string[0] << hour_std << ":"
143.                 << string[1]  << minute   << ":"  
144.                 << string[2]  << second   << " "
145.                 << string[3]
146.                 << endl;
147. }

[CompSystems]

Introduciendo el concepto de Constructor

Código: C++

1. #include<iostream>
2. using namespace std;
3. // Primer ejemplo de clases en C++
4. // Version 0.5 mayo 20 2013 By: CompSystems
5. // El usuario entra una hora, minuto y segundo y la maquina la convierte a formato estandar y universal o militar,
6. // ademas se da uso del Operador condicional ternario símbolo (?)
7.  
8. #define True 1
9. #define False 0
10. #define Beep '\a'
11.  
12. int flag1 = False;
13.  
14. class Time_Type{ // Time_Type Es un nuevo especificador de tipo
15.  
16.         public: // Interfaz
17.                     // Metodo1: Inicializa a valores validos los datos private dados en la funcion Time_Type( )
18.                     // Time_Type( );
19.                    
20.                     // Metodo2: Inicializa a valores validos, los 3 primeros datos private,  El 4to miembro no se inicializa por ahora
21.                      Time_Type( int hour = 0, int minute = 0, int second = 0 ); // Constructor, no requiere el prefijo de tipo de dato
22.                  
23.                
24.                 void getTime(  ); // funcion (get) para obtener del usuario la hora inicial por teclado
25.                 void setTime( int idTime_memberX, int memberXPos, int limInf, int limSup  ); // Funcion para extablecer el valor a cada miembro, ademas de verificar si es un dato valido
26.                 void setTime_2( int hour_, int minute_, int second_ );
27.                
28.                 void printMilitary( );
29.                 void printStandard( );
30.  
31.         private: // Cliente
32.                 int hour;   // member1
33.                 int minute; // member2
34.                 int second; // member3
35.                 const char *string[ 4 ]; // member4
36.                  //  No hay funciones auxiliares o de utileria
37. };
38.  
39.  
40. int main (int argc, char *argv[]) {
41.        
42.         //////////////////////////////// Sin datos especificos
43.         cout << "\nDatos entrados por el usuario, por teclado" << endl;
44.         class Time_Type idTime; // Se crea un objeto de nombre idTime() y de tipo Time_Type
45.         // como idTime no tiene argumentos equivale a asignar todos los argumentos predeterminados de Time_Type( );
46.         // Time_Type( ); // Esta sentencia esta comentada por se invoca automaticamente cuando se crea un objeto idTime
47.        
48.         idTime.getTime( );
49.         idTime.printMilitary( );
50.         idTime.printStandard( );
51.        
52.         ////////////////////////////////
53.        
54.         //////////////////////////////// Con datos especificos
55.         cout << "\n\nDatos especificados dentros del algoritmo, 3 argumentos ( 7, 35, 58 )" << endl;
56.         class Time_Type idTime2( 7, 35, 58 ); // Se crea un objeto de nombre idTime2 y de tipo Time_Type
57.         // como idTime tiene 3 argumentos, equivale a asignar todos los argumentos de Time_Type( );
58.         // Time_Type(  ); // Esta sentencia esta comentada por se invoca automaticamente cuando se crea un objeto idTime3
59.         // Luego se ejecuta
60.         // Time_Type( 7, 35, 58 );; // Esta sentencia esta comentada por se invoca automaticamente cuando se crea un objeto idTime2
61.        
62.         idTime2.printMilitary( );
63.         idTime2.printStandard( );
64.         ////////////////////////////////
65.        
66.         //////////////////////////////// Con datos especificos
67.         cout << "\n\nDatos especificados dentros del algoritmo, 1 argumento ( 23 )" << endl;
68.         class Time_Type idTime3( 23 ); // Se crea un objeto de nombre idTime2 y de tipo Time_Type
69.         // como idTime tiene 1 argumento equivale a asignar solo el 1er argumento de Time_Type( );
70.         // Time_Type(  ); // Esta sentencia esta comentada por se invoca automaticamente cuando se crea un objeto idTime3
71.         // Luego se ejecuta
72.         // Time_Type( 23 ); // el 2do y 3cer elemento se definen a 0 en la sentencia anterior
73.        
74.         idTime3.printMilitary( );
75.         idTime3.printStandard( );
76.         ////////////////////////////////
77.        
78.        
79.         //////////////////////////////// Con datos especificos
80.         cout << "\n\nDatos especificados dentros del algoritmo, INVALIDOS ( 24, 60, -1 )" << endl;
81.         class Time_Type idTime4( 24, 60, -1 ); // Se crea un objeto de nombre idTime2 y de tipo Time_Type
82.         // Time_Type(  ); // Esta sentencia esta comentada por se invoca automaticamente cuando se crea un objeto idTime3
83.         // Luego se ejecuta
84.         // Time_Type( 24, 60, -1 ); // el 2do y 3cer elemento se definen a 0 en la sentencia anterior
85.        
86.         idTime4.printMilitary( ); // Salida 00:00:00, cuando es un dato invalido
87.         idTime4.printStandard( ); // Salida 12:00:00 AM
88.         ////////////////////////////////
89.        
90.         ////////////////////////////////
91.         idTime4.setTime_2( 9, 45, 2 ); // Fijando valores con la función setTime
92.         idTime4.printMilitary( ); // Salida 09:45:02  
93.         idTime4.printStandard( ); // Salida 9:45:2 AM
94.         ////////////////////////////////
95.        
96.         class Time_Type idTime5; // Creando un nuevo objeto idTime5 de tipo Time_Type con valores predeterminados por que no posee argumentos
97.         idTime5.printMilitary( ); // Salida 00:00:00 valor predeterminado del constructor
98.         idTime5.printStandard( ); // Salida 12:00:00 AM valor predeterminado del constructor
99.        
100.         idTime5 = idTime4; // Asignación por copia de los miembros de idTime4 hacia idTime5
101.         idTime4.printMilitary( ); // Salida 09:45:02  
102.         idTime4.printStandard( ); // Salida 9:45:2 AM  
103.        
104.         ////////////////////////////////       
105.                
106.         return 0;
107. }
108.  
109.  
110. Time_Type:: Time_Type( int hour_, int minute_, int second_ ){ // Constructor, ( con argumentos opcionales )
111.        
112.         // Metodo1: Inicializa a valores validos los datos private
113.         //      hour = 0;
114.         //      minute = 0;
115.         //      second = 0;
116.         //      string[ 0 ] = "";
117.         //      string[ 1 ] = "";
118.         //      string[ 2 ] = "";
119.         //      string[ 3 ] = "";
120.         setTime_2( hour_, minute_, second_ );
121.        
122. }  
123.  
124. void Time_Type:: getTime( ){
125.         int input;
126.        
127.         cout << "Entrada de Time" << endl;
128.         do{
129.                 cout << "\nEntre Hora: rango valido [ 0 , ..., 23 ]" << endl;
130.                 cout << "Hora = ";  
131.                 cin >> input; // memberX
132.                 setTime( input, 1, 0, 23 ); // 1 = hour
133.         } while( flag1 == True ); // se puede simplificar a: while( flag1 );
134.        
135.         do{
136.                 cout << "\nEntre Minuto: rango valido [ 0 , ..., 59 ]" << endl;  
137.                 cout << "Minuto = ";
138.                 cin >> input; // memberX
139.                 setTime( input, 2, 0, 59 );  // 2 = minute
140.         } while( flag1 == True );      
141.        
142.         do{
143.                 cout << "\nEntre Segundo: rango valido [ 0 , ..., 59 ]" << endl;  
144.                 cout << "Segundo = ";
145.                 cin >> input; // memberX
146.                 setTime( input, 3, 0, 59 ); // 3 = second
147.         } while( flag1 == True );
148. }
149.  
150.  
151. void Time_Type:: setTime( int idTime_memberX, int memberXPos, int limInf, int limSup ){
152.        
153.         flag1 = ( idTime_memberX < limInf || idTime_memberX > limSup )?  True: False; // verifica si es un rango valido
154.         if ( flag1 == True ) {
155.                 cout << Beep; // se emite un sonido
156.                 cout << "\nDato invalido" << endl;
157.         }else{ // asigna a un miembro especifico dado por el identificador memberXPos
158.                 switch ( memberXPos ) {
159.                 case 1:
160.                         hour = idTime_memberX;
161.                         break;
162.                 case 2:
163.                         minute = idTime_memberX;
164.                         break;
165.                 case 3:
166.                         second = idTime_memberX;
167.                         break;
168.                 //default:
169.                 }
170.         }
171. }
172.  
173. void Time_Type:: setTime_2( int hour_, int minute_, int second_ ){ // Ajuste a 00:00:00, cuando es un dato invlaido
174.         hour = ( hour_ >=0 && hour_ < 24 )? hour_: 0;
175.         minute = ( minute_ >=0 && minute_ < 60 )? minute_: 0;
176.         second = ( second_ >=0 && second_ < 60 )? second_: 0;
177. }
178.  
179. void Time_Type:: printMilitary( ){
180.        
181.         cout << "\nFormato universal o Militar: ";
182.         string[0] = ( hour < 10 )?    "0": ""; // Ajuste del prefijo "0" para valores menores de 10
183.         string[1] = ( minute < 10 )?  "0": "";
184.         string[2] = ( second < 10 )?  "0": "";
185.         string[3] = "";
186.        
187.         // Despliegue final en pantalla
188.         cout << string[0] << hour   << ":"  
189.                 << string[1]  << minute << ":"  
190.                 << string[2]  << second
191.                 << endl; ;
192. }
193.  
194.  
195. void Time_Type:: printStandard( ){
196.        
197.         int hour_std;
198.         cout << "\nFormato Estandar: ";
199.        
200.         // { 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 } modulo 12 =
201.         // { 0 1 2 3 4 5 6 7 8 9 10 11 0  1  2  3  4  5  6  7  8  9  10 11 }
202.        
203.         hour_std = (hour)%12;
204.         (hour_std == 0)? (hour_std=12) : (hour_std=hour_std) ;  // si el modulo es 0 se hace un ajuste a 12 de lo contrario nada
205.         // string[0] =  ( hour == 0 || hour == 12 )?  "12": (hour)%12 ; // Como convierto (hour)%12 a cadena?
206.        
207.         string[0] = "";
208.         string[1] = ( minute < 10 )?  "0": ""; // Ajuste del prefijo "0" para valores menores de 10
209.         string[2] = ( second < 10 )?  "0": "";
210.         string[3] = ( hour < 12 )?   "AM": "PM";
211.        
212.         // Despliegue final en pantalla
213.         cout << string[0] << hour_std << ":"
214.                 << string[1]  << minute   << ":"  
215.                 << string[2]  << second   << " "
216.                 << string[3]
217.                 << endl;
218. }

version 0.6

Código: C++

1. #include<iostream>
2. using namespace std;
3. // Primer ejemplo de clases en C++
4. // Version 26 mayo 2013 By: CompSystems www.jaimeza.org
5. // El usuario entra una hora, minuto y segundo y la maquina la convierte a formato estandar y universal o militar,
6. // ademas se da uso del Operador condicional ternario símbolo (?)
7.  
8. #define True 1
9. #define False 0
10. #define Beep '\a'
11.  
12. int flag1 = False;
13.  
14. // Definicion de un nuevo tipo de objeto de nombre Time_Type
15. class Time_Type{ // Time_Type Es un nuevo especificador de tipo
16.        
17.     friend void fr_setTime_hour( Time_Type &Time_ObjectX, int c_hour  ); // Declaracion de una funcion friend
18.         public: // Interfaz
19.                
20.                 // Constructor
21.                 // Metodo1: Inicializa a valores validos los datos private dados en el cuerpo de la funcion Time_Type( ) si esta definida dentro de main()
22.                     // Time_Type( ); // El nombre del constructor debe ser igual al nuevo tipo de dato de la clase
23.                     // Esta funcion Time_Type( ); se invocase o se llama automaticamente (por esta razon no se debe esbrirla en main) en el momento de crearse un objeto de tipo de esta clase  
24.            
25.                 // Metodo2: Inicializa a valores validos, los 3 primeros datos private,  El 4to miembro no se inicializa por ahora
26.                         Time_Type( // El constructor, no requiere el prefijo de tipo de dato
27.                                 int hour = 0,
28.                                 int minute = 0,
29.                                 int second = 0
30.                         ); // Aunque tiene
31.                 // La anterior sentencia podria esbribirse sin el nombre identificador de los miembros
32.                 // Time_Type( int = 0, int = 0, int = 0  );  // pero es menos intuitiva  
33.                
34.                 // Funciones get
35.                 void getTime_keyboard(  ); // funcion (get) para obtener del usuario la hora inicial por teclado
36.                 int getTime_hour(  ); // retorna hora
37.                 int getTime_minute(  ); // retorna minuto
38.                 int getTime_second(  ); // retorna segundo
39.                 // getTime_current(  ); // funcion (get) para obtener del la hora actual de la clase
40.                
41.                 // Funciones set
42.                 void setTime( int Time_Object_memberX, int memberXPos, int limInf, int limSup  ); // Funcion para extablecer el valor a cada miembro, ademas de verificar si es un dato valido dado por los limetes del argumento
43.                 void setTime_check( int hour_, int minute_, int second_ );
44.                 void setTime_hour( int c_hour );
45.                 void setTime_minute( int c_minute );
46.                 void setTime_second( int c_second );
47.                
48.                 // Funciones con el operador *this
49.                 Time_Type &setTime2_hour( int c_hour );  
50.                 Time_Type &setTime2_minute( int c_minute );
51.                 Time_Type &setTime2_second( int c_second );
52.                
53.                 // Funciones impresion
54.                 void printMilitary( );
55.                 void printStandard( );
56.  
57.         private: // Cliente
58.                 int hour;   // member1, rango valido [ 0 , ..., 23 ]
59.                 int minute; // member2, rango valido [ 0 , ..., 59 ]
60.                 int second; // member3, rango valido [ 0 , ..., 59 ]
61.                 const char *string[ 4 ]; // member4, cada submiembro tiene rango expandible  
62.                 //  No hay funciones private
63.                 //  No hay funciones auxiliares o de utileria
64. };
65.  
66. void incrementMinutes ( Time_Type &Time_ObjectX, const int count );
67.  
68. void fr_setTime_hour( Time_Type &Time_ObjectX, int c_hour  ){ // comparar con la funcion normal: void Time_Type:: setTime_hour( int c_hour  )
69.         Time_ObjectX.hour = ( c_hour >=0 && c_hour < 24 )? c_hour: 0; // cuerpo de la funcion normal: hour = ( c_hour >=0 && c_hour < 24 )? c_hour: 0;
70. }
71.  
72.  
73. int main ( int argc, char *argv[] ) {
74.        
75.         //////////////////////////////// Sin datos especificos
76.         cout << "\nDatos entrados por el usuario, por teclado" << endl;
77.         class Time_Type Time_Object; // Se crea un objeto de nombre Time_Object() y de tipo Time_Type
78.         // como Time_Object no tiene sufijos argumentos entre parentesis, entonces equivale a asignar todos los argumentos predeterminados de Time_Type( int hour = 0, ... ) definidos en el la clase
79.         // Time_Type( ); // Esta sentencia esta comentada por se invoca automaticamente cuando se crea un objeto Time_Object
80.        
81.         Time_Object.getTime_keyboard( );
82.         Time_Object.printMilitary( );
83.         Time_Object.printStandard( );
84.         //cout << Time_Object.hour << endl; // No se puede acceder a un dato privado
85.         ////////////////////////////////
86.        
87.         //////////////////////////////// Con datos especificos
88.         cout << "\n\nDatos especificados dentros del algoritmo, 3 argumentos ( 7, 35, 58 )" << endl;
89.         class Time_Type Time_Object2( 7, 35, 58 ); // Se crea un objeto de nombre Time_Object2 y de tipo Time_Type
90.         // como Time_Object tiene 3 argumentos, equivale a asignar todos los argumentos de Time_Type( );
91.         // Time_Type( 7, 35, 58 );; // Esta sentencia esta comentada pero se invoca automaticamente cuando se crea un objeto Time_Object2
92.        
93.         Time_Object2.printMilitary( );
94.         Time_Object2.printStandard( );
95.         ////////////////////////////////
96.        
97.         //////////////////////////////// Con datos especificos
98.         cout << "\n\nDatos especificados dentros del algoritmo, 1 argumento ( 23 )" << endl;
99.         class Time_Type Time_Object3( 23 ); // Se crea un objeto de nombre Time_Object2 y de tipo Time_Type
100.         // como Time_Object tiene 1 argumento equivale a asignar solo el 1er argumento de Time_Type( );
101.         // Time_Type( 23 ); // el 2do y 3cer elemento se definen a 0 en la sentencia anterior
102.        
103.         Time_Object3.printMilitary( );
104.         Time_Object3.printStandard( );
105.         ////////////////////////////////
106.        
107.        
108.         //////////////////////////////// Con datos especificos
109.         cout << "\n\nDatos especificados dentros del algoritmo, INVALIDOS ( 24, 60, -1 )" << endl;
110.         class Time_Type Time_Object4( 24, 60, -1 ); // Se crea un objeto de nombre Time_Object2 y de tipo Time_Type
111.         // Time_Type( 24, 60, -1 );
112.        
113.         Time_Object4.printMilitary( ); // Salida 00:00:00, cuando es un dato invalido
114.         Time_Object4.printStandard( ); // Salida 12:00:00 AM
115.         ////////////////////////////////
116.        
117.         ////////////////////////////////
118.         Time_Object4.setTime_check( 9, 45, 2 ); // Fijando valores con la funcion setTime
119.         Time_Object4.printMilitary( ); // Salida 09:45:02  
120.         Time_Object4.printStandard( ); // Salida 9:45:2 AM
121.         ////////////////////////////////
122.        
123.        
124.         ////////////////////////////////
125.         class Time_Type Time_Object5; // Creando un nuevo objeto Time_Object5 de tipo Time_Type con valores predeterminados por que no posee argumentos
126.         Time_Object5.printMilitary( ); // Salida 00:00:00 valor predeterminado del constructor
127.         Time_Object5.printStandard( ); // Salida 12:00:00 AM valor predeterminado del constructor
128.        
129.         Time_Object5 = Time_Object4; // Asigancion por copia de los miembros de Time_Object4 hacia Time_Object5
130.         Time_Object4.printMilitary( ); // Salida 09:45:02  
131.         Time_Object4.printStandard( ); // Salida 9:45:2 AM     
132.         ////////////////////////////////       
133.        
134.        
135.         ////////////////////////////////
136.         class Time_Type Time_Object6;
137.         Time_Object6.setTime_check( 11, 58, 7 ); // Fijando valores con la funcion setTime
138.         incrementMinutes( Time_Object6, 3 );  
139.         // Salida inicial 11:58:07  
140.         ////////////////////////////////
141.        
142.         // Fijando valores con la subfunciones setTime_hour/minute/second
143.         Time_Object6.setTime_hour( 14 ); Time_Object6.setTime_minute( 38 ); Time_Object6.setTime_second( 52 ); 
144.         Time_Object6.printMilitary( ); // Salida 14:38:52
145.         // la sentencias anteriores se pueden simplificar usando la version anidada de funciones operador *this
146.         Time_Object6.setTime2_hour( 14 ).setTime2_minute( 38 ).setTime_second( 52 );   
147.         Time_Object6.printMilitary( ); // Salida 14:38:52
148.        
149.         // la sentencias anteriores se pueden simplificar usando la version anidada de funciones operador *this
150.         Time_Object6.setTime2_hour( 0 ).setTime2_minute( 1 ).setTime_second( 2 );      
151.         Time_Object6.printMilitary( ); // Salida 00:01:02
152.        
153.         // Utilizando la funcion amigo
154.         fr_setTime_hour( Time_Object6, 12 );
155.         Time_Object6.printMilitary( ); // Salida 12:01:02
156.         return 0;
157. }
158.  
159.  
160. // Funcione constructor
161.  
162.  
163. // Metodo1: Inicializa a valores validos los datos private
164. //Time_Type:: Time_Type( int hour_, int minute_, int second_ ){ // Constructor, ( con argumentos opcionales )
165.        
166. //      hour = 0;
167. //      minute = 0;
168. //      second = 0;
169. //      string[ 0 ] = "";
170. //      string[ 1 ] = "";
171. //      string[ 2 ] = "";
172. //      string[ 3 ] = "";      
173. //}
174.  
175. // Metodo2:
176. Time_Type:: Time_Type( int arg1_hour, int arg2_minute, int arg3_second ){ // Constructor, ( con argumentos opcionales )
177.         setTime_check( arg1_hour, arg2_minute, arg3_second );
178. }  
179.  
180. // Funcion destructor
181.  
182. // Funciones get
183.  
184. int Time_Type:: getTime_hour(  ){ // retorna hora
185.         return hour;
186. }      
187.  
188. int Time_Type:: getTime_minute(  ){ // retorna minuto
189.         return minute;
190. }
191.  
192. int Time_Type:: getTime_second(  ){ // retorna segundo
193.         return second;
194. }
195.  
196. void Time_Type:: getTime_keyboard( )  
197. {
198.         int input;
199.        
200.         cout << "Entrada de Time" << endl;
201.         do{
202.                 cout << "\nEntre Hora: rango valido [ 0 , ..., 23 ]" << endl;
203.                 cout << "Hora = ";  
204.                 cin >> input; // memberX
205.                 setTime( input, 1, 0, 23 ); // 1 = hour
206.         } while( flag1 == True ); // se puede simplificar a: while( flag1 );
207.        
208.         do{
209.                 cout << "\nEntre Minuto: rango valido [ 0 , ..., 59 ]" << endl;  
210.                 cout << "Minuto = ";
211.                 cin >> input; // memberX
212.                 setTime( input, 2, 0, 59 );  // 2 = minute
213.         } while( flag1 == True );      
214.        
215.         do{
216.                 cout << "\nEntre Segundo: rango valido [ 0 , ..., 59 ]" << endl;  
217.                 cout << "Segundo = ";
218.                 cin >> input; // memberX
219.                 setTime( input, 3, 0, 59 ); // 3 = second
220.         } while( flag1 == True );
221. }
222.  
223. // Funciones set
224.  
225. void Time_Type:: setTime_hour( int c_hour  ){
226.         hour = ( c_hour >=0 && c_hour < 24 )? c_hour: 0;
227. }
228.  
229. void Time_Type:: setTime_minute( int c_minute ){
230.         minute = ( c_minute >=0 && c_minute < 60 )? c_minute: 0;
231. }
232.  
233. void Time_Type:: setTime_second( int c_second ){
234.         second = ( c_second >=0 && c_second < 60 )? c_second: 0;
235. }
236.  
237. void Time_Type:: setTime( int Time_Object_memberX, int memberXPos, int limInf, int limSup ){
238.        
239.         flag1 = ( Time_Object_memberX < limInf || Time_Object_memberX > limSup )?  True: False; // verifica si es un rango valido
240.         if ( flag1 == True ) {
241.                 cout << Beep; // se emite un sonido
242.                 cout << "\nDato invalido" << endl;
243.         }else{ // asigna a un miembro especifico dado por el identificador memberXPos
244.                 switch ( memberXPos ) {
245.                 case 1:
246.                         hour = Time_Object_memberX;
247.                         break;
248.                 case 2:
249.                         minute = Time_Object_memberX;
250.                         break;
251.                 case 3:
252.                         second = Time_Object_memberX;
253.                         break;
254.                 //default:
255.                 }
256.         }
257. }
258.  
259. void Time_Type:: setTime_check( int hour_, int minute_, int second_ ){ // Ajuste a 00:00:00, cuando es un dato invlaido
260.         setTime_hour( hour_ );
261.         setTime_minute( minute_ );
262.         setTime_second( second_ );
263. }
264.  
265. // Funciones set con el operador *this
266.  
267. Time_Type &Time_Type:: setTime2_hour( int c_hour  ){
268.         hour = ( c_hour >=0 && c_hour < 24 )? c_hour: 0;
269.         return *this; // Habilita la opcion de sentencias anidadas
270. }
271.  
272. Time_Type &Time_Type:: setTime2_minute( int c_minute ){
273.         minute = ( c_minute >=0 && c_minute < 60 )? c_minute: 0;
274.         return *this; // Habilita la opcion de sentencias anidadas
275. }
276.  
277. Time_Type &Time_Type:: setTime2_second( int c_second ){
278.         second = ( c_second >=0 && c_second < 60 )? c_second: 0;
279.         return *this; // Habilita la opcion de sentencias anidadas
280. }
281.  
282.  
283. // Funciones de impresion
284. void Time_Type:: printMilitary( ){
285.        
286.         cout << "\nFormato universal o Militar: ";
287.         string[0] = ( hour < 10 )?    "0": ""; // Ajuste del prefijo "0" para valores menores de 10
288.         string[1] = ( minute < 10 )?  "0": "";
289.         string[2] = ( second < 10 )?  "0": "";
290.         string[3] = "";
291.        
292.         // Despliegue final en pantalla
293.         cout
294.                 << string[0] << hour   << ":"  
295.                 << string[1]  << minute << ":"  
296.                 << string[2]  << second
297.                 << endl; ;
298. }
299.  
300.  
301. void Time_Type:: printStandard( ){
302.        
303.         int hour_std;
304.         cout << "\nFormato Estandar: ";
305.        
306.         // { 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 } modulo 12 =
307.         // { 0 1 2 3 4 5 6 7 8 9 10 11 0  1  2  3  4  5  6  7  8  9  10 11 }
308.        
309.         hour_std = (hour)%12;
310.         (hour_std == 0)? (hour_std=12) : (hour_std=hour_std) ;  // si el modulo es 0 se hace un ajuste a 12 de lo contrario nada
311.         // string[0] =  ( hour == 0 || hour == 12 )?  "12": (hour)%12 ; // Como convierto (hour)%12 a cadena?
312.        
313.         string[0] = "";
314.         string[1] = ( minute < 10 )?  "0": ""; // Ajuste del prefijo "0" para valores menores de 10
315.         string[2] = ( second < 10 )?  "0": "";
316.         string[3] = ( hour < 12 )?   "AM": "PM";
317.        
318.         // Despliegue final en pantalla
319.         cout
320.                 << string[0] << hour_std << ":"
321.                 << string[1]  << minute   << ":"  
322.                 << string[2]  << second   << " "
323.                 << string[3]
324.                 << endl;
325. }
326.  
327.  
328. void incrementMinutes ( Time_Type &Time_ObjectX, const int count ){ // &Time_ObjectX = Time_ObjectX // paso por refernacia
329.         int a_hour, a_minute; // identificadores auxiliares
330.         // setTime_check( 11, 58, 7 ) se fijaron estos valores dentro de main
331.        
332.         cout << "\nHora inicial:  ";  // 11:58:00 AM
333.         Time_ObjectX.printStandard( ); // llamada incrementMinutes( Time_Object6, 3 );
334.        
335.         for ( int i = 0; i < count;i++ ) {
336.                 a_minute = ( Time_ObjectX.getTime_minute() + 1 ) % 60;
337.                 Time_ObjectX.setTime_minute( a_minute );
338.                        
339.                 if ( Time_ObjectX.getTime_minute() == 00 ) {
340.                         a_hour = ( Time_ObjectX.getTime_hour() + 1 ) % 24;
341.                         Time_ObjectX.setTime_hour( a_hour );
342.                 }
343.                        
344.                 cout << "\nIncremento en 1 minuto:";  // 11:59:07 AM, 12:00:07 PM, 12:01:07 PM
345.                 Time_ObjectX.printStandard( );
346.         }
347.  
348. }

[CompSystems]

Vídeo 03 Clases y Objetos parte1 de 3 - En Qt_ C++

Vídeo 03 Clases y Objetos parte2 de 3 - En Qt_ C++

Código adaptado a C++ plano de los vídeos anteriores

En construcción

main.cpp

Código: C++

1. #include<iostream>
2. #include<string>
3. #include<ctime>
4.  
5. using namespace std;
6. #include "persona_type.h"
7.  
8. persona_Type:: persona_Type( string nombre_, string apellido_, string fechaNacimiento_ )
9. {
10.         nombre = nombre_;
11.         this->apellido = apellido_;
12.         this->fechaNacimiento = fechaNacimiento_;
13.        
14. }
15.  
16. int main (int argc, char *argv[]) {
17.         persona_Type persona1( "Lionel", "Messi", "19870624");
18.          
19.         cout << persona1.nombre << endl;
20.        
21.         return 0;
22. }

PERSONA_TYPE.h

Código: C++

1. #ifndef PERSONA_TYPE_H
2.         #define PERSONA_TYPE_H
3.  
4.         class persona_Type
5.         {
6.                
7.         private:
8.                 string nombre;
9.                 string apellido;
10.                 string fechaNacimiento;
11.                
12.         public:
13.                 persona_Type( string nombre_, string apellido_, string fechaNacimiento_ ); // constructor
14.                
15.                
16.                 //Edad();
17.                
18.                
19.         };
20.  
21. #endif // PERSONA_TYPE_H