Início / coding / Perguntas / 76937286
Accepted
CcmU
Asked: 2023-08-20 06:33:08 +0800 CST

Ponteiro após a inicialização em uma subclasse de exceção

  • 772

Eu estava casualmente fazendo alguns desafios no HackerRank e me deparei com "Código Herdado", que tentei resolver com isso:

class BadLengthException : public exception    {
    private:
        const char* message;
    public:
        BadLengthException(int n_)  {
            this->message = to_string(n_).c_str();
        }
        
        const char * what() const throw() {
            return this->message;
        }
};

Como não funcionou (a saída estava vazia), pesquisei no SO o motivo e encontrei esta pergunta sobre o mesmo problema. Acho que entendo a solução proposta, mas ainda estou muito confuso sobre minha tentativa:

Entendo que a string to_string(n_).c_str()pode ser vista como uma variável local, como no exemplo da pergunta mencionada, mas por que ainda é tratada como tal quando what()é chamada? Não deveria ter sido mantido messagevia inicialização, estando disponível sempre que chamar what()?

c++

3 respostas

  1. Best Answer

    const char*é um ponteiro para uma string C bruta. Não é um objeto contêiner (como std::string) que possuiria a string e gerenciaria a alocação/desalocação do buffer que contém a string.

    to_string(int)retorna um std::stringcom uma representação de string do número. Em seguida c_str(), retorna um ponteiro para essa string.

    Mas em this->message = to_string(n_).c_str();, primeiro um std::stringobjeto temporário é construído e, em seguida, messageé definido como o ponteiro para essa string. Mas depois, o temporário std::stringé excluído (o que desaloca seu buffer) e messageagora é um ponteiro pendente, que aponta para a memória que não está mais alocada.

    Uma solução seria, em vez disso, criar this->message um arquivo std::string. E faça what() o retorno this->message.c_str().

    • 3

  2. to_string(n_)é temporário . Ele expira no final da expressão. c_str()obtém um ponteiro para o buffer de dados da string temporária no curto período de tempo em que o stringestá ativo, e esse ponteiro é armazenado, deixando o programa com um ponteiro pendurado quase instantaneamente. Você está preso segurando o string, eu estou com medo.

    Uma possível solução:

    class BadLengthException : public exception    {
    private:
        std::string message;
    public:
        BadLengthException(int n_) :message(to_string(n_)) {
        }
        
        const char * what() const throw() {
            return message.c_str();
        }
};

    Nota: É um risco alocar armazenamento em uma exceção, as coisas ficam muito ruins se esse armazenamento não puder ser alocado e você acabar com um lançamento após o lançamento, mas você pode mitigar isso com uma matriz pré-alocada e evitar o uso indo std::stringpara a velha escola sprintfou similar.

    • 2

  3. messageé um ponteiro pendurado. O temporário std::stringretornado por std::to_stringé destruído no final da expressão completa.

    Você precisa armazenar a mensagem em algum lugar. O melhor lugar é provavelmente em um arquivo std::string.

    Exemplo:

    class BadLengthException : public std::exception {
private:
    std::string message;

public:
    BadLengthException(int n_) : message(std::to_string(n_)) {
    }

    const char* what() const noexcept override {
        return message.c_str();
    }
};

    Observe que const throw()é a versão anterior ao C++11. Desde C++ 11, deve ser const noexcept override.

    Uma opção mais simples é herdar de std::runtime_error, e é por isso que as pessoas costumam fazer isso ao criar exceções personalizadas. Ele fornece armazenamento, bem como uma what()substituição, então tudo que você precisa fazer é:

    class BadLengthException : public std::runtime_error {
public:
    BadLengthException(int n_) : std::runtime_error(std::to_string(n_)) {
    }
};
    • 1

relate perguntas