Uso de __FILE__, __LINE__ e __FUNCTION__ em C ++

Presumindo que o seu compilador C ++ apoia-los, há alguma razão em particular não para uso __FILE__, __LINE__e __FUNCTION__para fins de depuração registro e?

Estou preocupado principalmente em fornecer ao usuário dados enganosos - por exemplo, relatar o número ou a função da linha incorreta como resultado da otimização - ou sofrer um impacto no desempenho como resultado.

Basicamente, eu posso confiar __FILE__, __LINE__e __FUNCTION__para sempre fazer a coisa certa?

__FUNCTION__não é padrão, __func__existe no C99 / C ++ 11. Os outros ( __LINE__e __FILE__) estão bem.

Ele sempre reportará o arquivo e a linha corretos (e funcionará se você optar por usar __FUNCTION__/ __func__). A otimização não é um fator, pois é uma expansão da macro de tempo de compilação; isso nunca afetará o desempenho de nenhuma maneira.

Em casos raros, pode ser útil alterar a linha fornecida por __LINE__outra coisa. Eu já vi o GNU configurar fazer isso para que alguns testes relatem números de linhas apropriados após a inserção de um vodu entre linhas que não aparecem nos arquivos originais. Por exemplo:

#line 100

Inicia as linhas a seguir com __LINE__100. Como opção, você pode adicionar um novo nome de arquivo

#line 100 "file.c"

Isso raramente é útil. Mas se for necessário, não há alternativas que conheço. Na verdade, em vez da linha, uma macro também pode ser usada, o que deve resultar em qualquer uma das duas formas acima. Usando a biblioteca de pré-processador boost, você pode incrementar a linha atual em 50:

#line BOOST_PP_ADD(__LINE__, 50)

Eu pensei que era útil mencioná-lo, uma vez que você perguntou sobre o uso de __LINE__e __FILE__. Nunca se obtém surpresas suficientes em C ++ :)

Edit: @ Jonathan Leffler fornece mais alguns casos de uso bons nos comentários:

Brincar com #line é muito útil para pré-processadores que desejam manter os erros relatados no código C do usuário alinhados com o arquivo de origem do usuário. Yacc, Lex e (mais em casa para mim) os pré-processadores ESQL / C fazem isso.

FYI: g ++ oferece a macro __PRETTY_FUNCTION__ não padrão. Até agora eu não sabia sobre o C99 __func__ (obrigado Evan!). Acho que ainda prefiro __PRETTY_FUNCTION__ quando estiver disponível para o escopo de classe extra.

PS:

static string  getScopedClassMethod( string thePrettyFunction )
{
  size_t index = thePrettyFunction . find( "(" );
  if ( index == string::npos )
    return thePrettyFunction;  /* Degenerate case */

  thePrettyFunction . erase( index );

  index = thePrettyFunction . rfind( " " );
  if ( index == string::npos )
    return thePrettyFunction;  /* Degenerate case */

  thePrettyFunction . erase( 0, index + 1 );

  return thePrettyFunction;   /* The scoped class name. */
}

Pessoalmente, estou relutante em usá-los para qualquer coisa, exceto mensagens de depuração. Eu fiz isso, mas tento não mostrar esse tipo de informação aos clientes ou usuários finais. Meus clientes não são engenheiros e, às vezes, não são conhecedores de computadores. Posso registrar essas informações no console, mas, como disse, com relutância, exceto pelas compilações de depuração ou por ferramentas internas. Suponho que isso dependa da base de clientes que você possui.

C ++ 20 std::source_location

O C ++ finalmente adicionou uma opção não macro e provavelmente dominará em algum momento no futuro quando o C ++ 20 se espalhar:

• https://en.cppreference.com/w/cpp/utility/source_location
• http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1208r5.pdf

A documentação diz:

constexpr const char * nome_da_função () const noexcept;

6 Retorna: se este objeto representa uma posição no corpo de uma função, retorna um NTBS definido pela implementação que deve corresponder ao nome da função. Caso contrário, retorna uma string vazia.

onde NTBS significa "Cadeia de bytes nulos terminados".

Vou tentar quando o suporte chegar ao GCC, o GCC 9.1.0 com g++-9 -std=c++2aainda não o suporta.

https://en.cppreference.com/w/cpp/utility/source_location afirma que o uso será como:

#include <iostream>
#include <string_view>
#include <source_location>

void log(std::string_view message,
         const std::source_location& location std::source_location::current()
) {
    std::cout << "info:"
              << location.file_name() << ":"
              << location.line() << ":"
              << location.function_name() << " "
              << message << '\n';
}

int main() {
    log("Hello world!");
}

Saída possível:

info:main.cpp:16:main Hello world!

__PRETTY_FUNCTION__vs __FUNCTION__vs __func__vsstd::source_location::function_name

Respondida em: Qual é a diferença entre __PRETTY_FUNCTION__, __FUNCTION__, __func__?

Eu os uso o tempo todo. A única coisa com que me preocupo é ceder o IP nos arquivos de log. Se os nomes das suas funções forem realmente bons, você poderá facilitar a descoberta de um segredo comercial. É como enviar com símbolos de depuração, mas é mais difícil encontrar coisas. Em 99,999% dos casos, nada de ruim resultará disso.