|
ProtocoloProgra
Protocolos de Programación.
Protocolo de ProgramaciónGlobal1. Cualquier nombre asignado a una variable, clase, método, etc. el inicio de la segunda palabra en adelante tiene que ser mayúscula. Ejemplo void SetMetodo()
{
...
}
int miContador;
class CMiClase
{
...
};2. Si se está asignando un numero float o se va a pasar por parámetro, siempre poner f al final del número. Ejemplo float pi = 3.14f; CVector3* vect3 = new CVector3(10.0f, 0.0f, 1.5f); 3. Declarar las variables en líneas individuales. (Es mas facil para leer y encontrar) Ejemplo Correcto int x; int y; int z; Incorrecto int x, y, z; 4. Todas las funciones deben llevar una pequeña descripción donde se definen (Normalmente en el .h) Tienen que utilizar la siguiente estructura:
Ejemplo /*<summary> * Calcula la suma de dos números. * </summary> *<param name=”a”>Primer número a sumar</param> *<param name=”b”>Segundo número a sumar</param> *<returns>Retorna un int con la suma de los números</returns> *</summary> */ int Suma(int a, int b); Excepciones:
5. Para todas las variables que se modifican dentro de un método (Parámetros de salida) se les agrega un al final. Ejemplo void SetNewTime(const CTime& oldTime, CTime& newTime_)
{
…
}6. Dejar un espacio después de ( y antes de ) Ejemplo if ( i == 0 )
{
…
}
for ( int i = 0; i < 10; i++ )
{
…
}Nombres de Objetos1. Nombre de Clases: CNombreClase (Se agrega una C al principio del nombre) Ejemplo class CProtocolo
{
}2. Nombre de Estructura: SNombreEstructura (Se agrega una S al principio del nombre) Ejemplo struct SVector3
{
}3. Nombre de Enumerador: ENombreEnumerador (Se agrega una E al principio del nombre) Ejemplo enum ETipo
{
};Nombres de Variables1. Variable miembra de clase: m_MiVariable (Se agrega un prefijo m para indicar que es miembra de la clase) Ejemplo class CMiClase
{
private:
int m_Contador;
public:
...
};2. Variables Globales: g_VariableGlobal (Se agrega un prefijo g para indicar que es una variable global) Ejemplo #include <vector>
vector<int> g_MiVector;
void main()
{
...
}3. Variables Constantes: MI_CONSTANTE (Todo en mayúscula y se separan las palabras con guion bajo) Ejemplo const float MI_PI = 3.14f; Estructura de Código1. Se tiene que usar tab para indentar (Por Default Visual Studio tiene esta opción) 2. Todos los if y else tiene que tener {} Ejemplo Correcto if(1)
{
...
}
else
{
...
}Incorrecto if(1) x++ else y-- 3. Todos los corchetes { tienen que ir abajo de la declaración Ejemplo Correcto if(1)
{
}
void MiFuncion()
{
}
class CMiClase
{
};Incorrecto if(1) {
}
void MiFuncion(){
}
|
Me parece ok! Yo ya seguia esta nomenclatura pero después de leer varios libros me he dado cuenta que si metemos espacios queda aun más entendedor. Parece una chorrada pero realmente cuando llevas mucho código funciona. Es decir:
if ( i = 0 ) {
}o bien
for ( i = 1; i < Total; ++i )
// Fijaos en que dejo espacio entre parentesis i los valores. Esto es mucho más leible sobretodo cuando tienes muchas lineas de código juntas. Es más rápido de leer al menos para mi y también parece que para los expertos
Otro detalle que Marc no le gusta pero a mi si y solo es por un tema de lectura.
// métodos con void y espacios. Se que quizás parezca una xorrada pero uno ve más ràpido un void que un (). Es más fácil de leer. También deberíamos meter las directivas de compilación en cada classe.
#pragma once
#ifndef CLASS_RENDERMANAGER_H #define CLASS_RENDERMANAGER_H
class CRenderManager { public:
};
#endif CLASS_RENDERMANAGER_H
Otro punto es usar "const" para mètodos Get
virtual CRenderManager GetRenderManager? ( ) const;
También utilizo cabezeras y regiones así és fácil de plegar código que no quieres ver y acceder más rápido donde uno quiera ir. Una classe como esta:
#pragma region Constructors/Destructors
// // CONSTRUCTOR/DESTRUCTOR // CCore::CCore(void) { }
CCore::~CCore(void) { }
#pragma endregion Constructors/Destructors
#pragma region Mètodes
// // MÈTODES //
void CCore::Init ( ) {
}void CCore::Update ( float TimeElapsed? ) { }
void CCore::Render ( void ) { }
#pragma endregion Mètodes
#pragma region Propietats
// // PROPIETATS // CRenderManager CCore::GetRenderManager? ( ) const { }
void CCore::SetRenderManager? ( CRenderManager RenderManager? ) { }
#pragma endregion
Aunque cualquier sugerencia de estilo al respecto será bienvenida como:
// ----------------------------------- // MÉTODOS // -----------------------------------
otra cosilla, con punteros meter la "p" delante. En .NET yo también metia que las variables que iban como paràmetros le añadia una "v" de prefijo. Pero bueno, esto tampoco es una cosas chunga.
int DevolverValor? ( vector<string> vVect, int vPosicion)
Más que nada era porqué me facilita saber dentro de funciones largas que vVector i vPosicion son parámetros de función. Creo recordar que es nomenclatura de Microsoft.
Todas las variables "m_pepe" siempre seran privadas. Habría que implementar su GetVariable? y SetVariable?.
Y mucho más pero... quizás sean mania...
veo que el comentario anterior no muestra las cabezeras de mis comentarios. Bueno, ya lo mostraré hoy en clase.
1. Me parece bueno lo de los espacios en los ( i == 0 ) 2. Los region me parece buena idea usar 3. Como explique en el correo #ifdef MICLASE_H ..... se resuelve con #pragma once
Voy agregar lo que hemos estado de acuerdo y el resto mando un correo para votar
Creo que tambien podriamos meter
static int s_Total;
es decir, la "s" para las estáticas.