| 1 | [[TOC(heading=This section pages, WikiStart, AnalisisDominio16, IdentificacionFuncionalidades16, PropuestaDesarrollo16, EstandaresDesarrollo16, AnalisisyDiseno16, PrototipoInterfaz16, Codificacion16, Pruebas16, Liberacion16, noheading, heading=Tabla de Contenido)]] |
| 2 | |
| 3 | [[TOC(heading=This section pages, WikiStart, noheading, AnalisisDominio, PropuestaDesarrollo, PlanProyecto, EstandaresDesarrollo, IdentificacionFuncionalidades, Codificacion, PrototipoInterfaz, Liberacion, heading=Tabla de Contenido)]] |
| 4 | |
| 5 | |
| 6 | = Estándares de Desarrollo del Proyecto = |
| 7 | |
| 8 | === Sobre los archivos === |
| 9 | |
| 10 | Los nombres de los archivos de cabecera deben terminar con la extensión ".H" mientras que los archivos de fuentes deben terminar con la extensión ".C". |
| 11 | |
| 12 | Si un par de archivos (cabecera y fuente) son contenedores de una clase, éstos deben tener el mismo nombre de la clase que contienen con la extensión respectiva en letras minúsculas. |
| 13 | |
| 14 | Por cada clase deben existir un par de archivos para su definición (archivo de cabecera) y su implementación (archivo fuente). |
| 15 | |
| 16 | Cada archivo que se cree debe comenzar con un bloque de comentario multilínea que contenga el texto de la licencia, por ejemplo: |
| 17 | |
| 18 | {{{ |
| 19 | #!div style="font-size: 80%" |
| 20 | Code highlighting: |
| 21 | {{{#!C++ |
| 22 | /* |
| 23 | Texto de la licencia |
| 24 | */ |
| 25 | }}} |
| 26 | }}} |
| 27 | |
| 28 | Luego se coloca otro bloque de comentario multilínea que contenga una breve descripción del archivo, autor o autores y la fecha de creación, por ejemplo: |
| 29 | |
| 30 | {{{ |
| 31 | #!div style="font-size: 80%" |
| 32 | Code highlighting: |
| 33 | {{{#!C++ |
| 34 | /* |
| 35 | Este archivo contiene la implementación de ... |
| 36 | |
| 37 | Autor(es): José Ruiz, Julie Vera |
| 38 | |
| 39 | Fecha de Creación: 15/04/2015 |
| 40 | */ |
| 41 | }}} |
| 42 | }}} |
| 43 | |
| 44 | === Normas de Codificación === |
| 45 | |
| 46 | '''Las Variables''' |
| 47 | |
| 48 | Asignarles nombres significativos a lo que almacenan y plantearlos como |
| 49 | sustantivos. |
| 50 | |
| 51 | No todo el tiempo una variable tiene un nombre significativo por sí mismo, en |
| 52 | esos casos agregar un comentario a la derecha de la declaración que explique |
| 53 | brevemente su significado, si el comentario es multilínea, agregarlo antes de la |
| 54 | declaración de la variable. |
| 55 | |
| 56 | Escribir el nombre de las variables comenzando con una letra minúscula. Cada palabra consecutiva en un nombre de variable debe comenzar con una letra mayúscula. |
| 57 | |
| 58 | Inicializarlas al momento de declararse y si se coloca una explicación a su lado. |
| 59 | |
| 60 | Usar una línea diferente para cada declaración. |
| 61 | |
| 62 | Por ejemplo: |
| 63 | |
| 64 | {{{ |
| 65 | #!div style="font-size: 80%" |
| 66 | Code highlighting: |
| 67 | {{{#!C++ |
| 68 | int age = 18; |
| 69 | int x = 0; // Componente x de un punto |
| 70 | /* |
| 71 | Componente y de un punto |
| 72 | Ejemplo multilínea |
| 73 | */ |
| 74 | int y = 0; |
| 75 | }}} |
| 76 | }}} |
| 77 | |
| 78 | '''Las Funciones''' |
| 79 | |
| 80 | Asignarles nombres significativos a la operación que efectúen y plantearlos |
| 81 | como verbos. |
| 82 | |
| 83 | Escribir un bloque de comentario multilínea que contenga una breve explicación |
| 84 | de lo que hacen antes de su definición. Nota: Si es muy evidente la operación |
| 85 | que ésta realice, se puede ignorar este paso. |
| 86 | |
| 87 | Escribir el nombre comenzando con una letra minúscula. Cada palabra consecutiva en un nombre de función debe comenzar con una letra mayúscula. |
| 88 | |
| 89 | Para los parámetros de las funciones usar las mismas especificaciones de las |
| 90 | variables. |
| 91 | |
| 92 | Por ejemplo: |
| 93 | |
| 94 | {{{ |
| 95 | #!div style="font-size: 80%" |
| 96 | Code highlighting: |
| 97 | {{{#!C++ |
| 98 | /* |
| 99 | Efectúa la división de dos números reales (a / b), si b es igual a 0 arroja |
| 100 | excepción de error de dominio. |
| 101 | */ |
| 102 | float divideFloat(const float & a, const float & b) |
| 103 | { |
| 104 | if (b == 0) |
| 105 | throw std::domain_error("Division by 0"); |
| 106 | |
| 107 | return a / b; |
| 108 | } |
| 109 | }}} |
| 110 | }}} |
| 111 | |
| 112 | |
| 113 | '''Clases''' |
| 114 | |
| 115 | Escribir mediante un comentario multilínea una breve explicación de los que |
| 116 | representa la clase así como el autor o autores de ésta. |
| 117 | |
| 118 | Asignarles nombres significativos de lo que éstas representen y plantearlos como |
| 119 | sustantivos. |
| 120 | |
| 121 | Escribir los nombres con el estilo de nombres propios, es decir, la primera |
| 122 | letra de cada palabra que lo conforme en mayúscula y el resto en minúscula. Cada palabra consecutiva en un nombre de clase debe comenzar con una letra mayúscula. |
| 123 | |
| 124 | |
| 125 | Ejemplo de definición de una clase: |
| 126 | |
| 127 | {{{ |
| 128 | #!div style="font-size: 80%" |
| 129 | Code highlighting: |
| 130 | {{{#!C++ |
| 131 | /* Clase que representa una lista mediante arreglos |
| 132 | |
| 133 | Autor: José Ruiz |
| 134 | */ |
| 135 | class MainWindow : public QMainWindow |
| 136 | { |
| 137 | |
| 138 | }; |
| 139 | }}} |
| 140 | }}} |
| 141 | |
| 142 | A los atributos de una clase aplicarle las mismas especificaciones de una |
| 143 | variable. |
| 144 | |
| 145 | A los metodos de una clase aplicarle las mismas especificaciones que a las |
| 146 | funciones. |
| 147 | |
| 148 | '''''Consideraciones especiales sobre métodos''''' |
| 149 | |
| 150 | ''Constructores'' |
| 151 | |
| 152 | Asignarle valor inicial a todos los atributos de la clase, usar el espacio de |
| 153 | inicialización del constructor para el valor inicial y el espacio de |
| 154 | implementación para cualquier operación adicional sobre los atributos. |
| 155 | |
| 156 | Siguiendo con el ejemplo de la clase definida anteriormente: |
| 157 | |
| 158 | {{{ |
| 159 | #!div style="font-size: 80%" |
| 160 | Code highlighting: |
| 161 | {{{#!C++ |
| 162 | /* Plantilla que representa una lista mediante arreglos |
| 163 | |
| 164 | Recibe como parámetro plantilla el tipo de elemento que va a almacenar. |
| 165 | |
| 166 | Autor: José Ruiz |
| 167 | */ |
| 168 | class MainWindow : public QMainWindow |
| 169 | { |
| 170 | size_t size; // Almacena el tamaño del arreglo |
| 171 | T * array; // Arreglo de elementos de tipo T |
| 172 | |
| 173 | public: |
| 174 | MainWindow(const size_t & _size) |
| 175 | : size(_size), array(nullptr) |
| 176 | { |
| 177 | array = new T[size]; |
| 178 | } |
| 179 | }; |
| 180 | }}} |
| 181 | }}} |
| 182 | |
| 183 | ''Modificadores y Observadores'' |
| 184 | |
| 185 | A los observadores colocarles como nombre el mismo nombre del atributo al cual |
| 186 | observa con el prefijo 'get'. |
| 187 | |
| 188 | A los modificadores colocarles como nombre el mismo nombre del atributo al cual |
| 189 | observa con el prefijo 'set'. |
| 190 | |
| 191 | Por ejemplo para consultar el tamaño de la lista: |
| 192 | |
| 193 | {{{ |
| 194 | #!div style="font-size: 80%" |
| 195 | Code highlighting: |
| 196 | {{{#!C++ |
| 197 | /* Clase que representa una lista mediante arreglos |
| 198 | |
| 199 | Autor: José Ruiz |
| 200 | */ |
| 201 | class MainWindow : public QMainWindow |
| 202 | { |
| 203 | |
| 204 | // ... Otras implementaciones ... |
| 205 | |
| 206 | const size_t & getSize() const |
| 207 | { |
| 208 | return size; |
| 209 | } |
| 210 | }; |
| 211 | }}} |
| 212 | }}} |