You have several ways to report an error:
Use an error code
This can be done with #define or with enum . My personal preference would be the second option for several reasons:
- Those listed generate a different identification for each element automatically, reduces the risk of having repeated identifiers
- As of C ++ 11 (see third example), a strong typing can be provided to those listed. The great advantage of activating this feature is that we provide a more robust code.
Example with #define :
#define OK 0
#define FILE_NOT_FOUND 1
#define ANOTHER 2
// ...
int TestFunc()
{
return FILE_NOT_FOUND;
}
int main()
{
switch( TestFunc() )
{
case OK:
std::cout << "Ok\n";
break;
case FILE_NOT_FOUND:
std::cout << "Fichero no encontrado\n";
break;
// ...
}
}
Example with enum :
enum TestFuncReturn
{
OK,
FILE_NOT_FOUND,
ANOTHER,
// ...
};
TestFuncReturn TestFunc()
{
return FILE_NOT_FOUND;
}
int main()
{
switch( TestFunc() )
{
case OK:
std::cout << "Ok\n";
break;
case FILE_NOT_FOUND:
std::cout << "Fichero no encontrado\n";
break;
// ...
}
}
Example with enum in C ++ 11:
enum class TestFuncReturn
{
OK,
FILE_NOT_FOUND,
ANOTHER,
// ...
};
TestFuncReturn TestFunc()
{
return TestFuncReturn::FILE_NOT_FOUND;
}
int main()
{
switch( TestFunc() )
{
case TestFuncReturn::OK:
std::cout << "Ok\n";
break;
case TestFuncReturn::FILE_NOT_FOUND:
std::cout << "Fichero no encontrado\n";
break;
// ...
}
}
Exceptions:
Using error codes has several drawbacks:
- occupy the
return of the function, so to return additional information it is necessary to resort to artifices as parameters by reference or to use std::pair or std::tuple .
- Many times the function that receives the error message can not do anything by itself to recover the situation, it is up to it to propagate the error upwards and this causes that special care must be taken so that different error messages do not overlap .
- Returning an error code sometimes seems insufficient to, for example, inform the user about the problem (What file has failed ?, Why?, Is there anything else to be taken into account?) .
To meet these deficiencies there are exceptions. Exceptions can (and should) be objects, which allows legacy, polymorphism and encapsulation characteristics to be used to provide all the information necessary to recover from an error.
Example C ++ 98:
class FileNotFoundException : public std::exception
{
public:
FileNotFoundException(const std::string& mensaje)
: m_error(mensaje)
{ }
const char* what() const
{ return m_error.c_str(); }
private:
std::string m_error;
};
class AnotherException : public std::exception
{
public:
AnotherException (const std::string& mensaje)
: m_error(mensaje)
{ }
const char* what() const
{ return m_error.c_str(); }
private:
std::string m_error;
};
void TestFunc()
{
throw FileNotFoundException("No se pudo encontrar el fichero notas.txt");
}
int main()
{
try
{
TestFunc();
}
catch( const std::exception& exc )
{
std::cout << "Error: " << exc.what();
}
}
Example C ++ 11:
class FileNotFoundException : public std::exception
{
public:
FileNotFoundException(std::string const& mensaje) noexcept
: m_error(mensaje)
{ }
const char* what() const noexcept override
{ return m_error.c_str(); }
private:
std::string m_error;
};
class AnotherException : public std::exception
{
public:
AnotherException (std::string const& mensaje) noexcept
: m_error(mensaje)
{ }
const char* what() const noexcept override
{ return m_error.c_str(); }
private:
std::string m_error;
};
void TestFunc()
{
throw FileNotFoundException("No se pudo encontrar el fichero notas.txt");
}
int main()
{
try
{
TestFunc();
}
// Solo captura FileNotFoundException
catch( const FileNotFoundException& exc )
{
std::cout << "Error de fichero: " << exc.what();
}
// Captura cualquier excepción que herede de std::exception
// excepto FileNotFoundException, que está capturada en el catch anterior
catch( const std::exception& exc )
{
std::cout << "Error: " << exc.what();
}
}
Examples with enum or #define I will not put you because you already have other answers covering that area.
I'll give you an example incorporating exceptions. I have also tweaked the code a bit to make it more in line with what is expected of a more or less modern C ++ code (absence of raw fixes, variables declared at the time, use of the C ++ own input / output, ...) . The only thing I have not modified is the use of the file ... yes, remember to close the file before leaving the function.
class FileNotFoundException : public std::exception
{
public:
FileNotFoundException(const std::string& mensaje)
: m_error(mensaje)
{ }
const char* what() const
{ return m_error.c_str(); }
private:
std::string m_error;
};
struct Datos
{
cart;
certif;
paq;
};
typedef std::array<Datos,ANYOS> VectorDatos;
VectorDatos leer_correo ()
{
VectorDatos datos;
FILE *fe;
if((fe=fopen("correo.txt", "r"))==NULL){
throw FileNotFoundException("Error al abrir correo.txt");
}
for(int i=0 ; i<ANYOS ; i++)
{
int anyo;
Datos& item = datos[i];
fscanf(fe, "%d%d%d%d", &anyo, &item.cart, &item.certif, &item.paq);
}
fclose(fe);
return datos;
}
void main(){
std::array<Datos,ANYOS> datos;
try
{
datos = leer_correo(); // Llamar a la función leer correo
}
catch( const FileNotFoundException& exc )
{
std::cout << "Error: " << exc.what();
// Si otro programa está esperando a que éste devuelva una respuesta
// entonces el valor de este código es importante. En caso contrario
// es irrelevante.
return -1;
}
// Resto del main
// ...
}
The code should be compatible with C ++ 98. I've tried to do it on purpose because seeing your code I do not think you're compiling with C ++ 11 or C ++ 14.