Così, nelle ultime settimane ho approfondito la programmazione in C ++ e ho programmato alcune cose in SDL. In questo modo, devi sempre gestire molto ( brutto ) codice C ++, che assomiglia più a C che a C ++. Una cosa che ho notato durante la programmazione con SDL rispetto alla programmazione college, è che faccio molte programmazioni procedurali. La ragione di ciò è che la maggior parte del codice SDL di esempio che guardo è strutturata in questo modo, ad esempio
bool init(…)
{
bool success = true;
thing_A = make_thing_A();
if (thing_A.is_valid() == false
{
success = false;
std::cout << "Something went wrong" << std::endl;
}
…
return success;
}
... come questo. La pulizia si verificava nel chiamante.
Tuttavia questo funziona solo con le funzioni, che non hanno bisogno di restituire altre variabili altrimenti. E questo crea un'interfaccia brutta, in cui non si può mai, se è possibile scrivere qualcosa come if (!init()) , il che rende necessario consultare la documentazione.
Non so mai se questa è una pratica corretta di programmazione. Un altro approccio potrebbe essere:
void init(…)
{
try
{
thing_A = make_thing_A();
if (thing_A.is_valid() == false
{
throw ;
}
…
catch (std::exception &e)
{
std::cout << "Something went wrong" << std::endl;
cleanup();
}
}
Ma poi ho letto, non dovrei mettere questo try-catch-routine nella funzione, ma piuttosto nel chiamante:
void init(…)
{
thing_A = make_thing_A();
if (thing_A.is_valid() == false
{
throw ;
}
}
int main(void)
{
try
{
init(…);
}
catch (std::exception &e)
{
std::cout << "Something went wrong" << std::endl;
cleanup();
}
}
Al momento questo è il mio problema numero uno, quando scrivo software, non so cosa fare. Penso che la soluzione più pulita sia la seconda, perché incapsula la logica completa nel callee e implementa DRY, perché non devi mettere la logica di pulizia in ogni chiamante. È giusto? Non ho mai sentito un'opinione assoluta su questo.
EDIT: Non sto necessariamente parlando specificamente di SDL2, ma più in generale. Per esempio. So che c'è un consenso, che dovresti preferire std::unique_ptr a std::auto_ptr , ma quando si tratta di gestione degli errori vedo molti approcci: errno , valori di ritorno, eccezioni, booleani, ma non so quale sia l'approccio go-to , che dovresti evitare, nel qual caso potrebbe essere una buona idea avvicinarti a XYZ, ecc.