Как обнаружить, что ptr все еще ссылается на действительную ссылку после того, как эта ссылка выходит из сферы действия

Ответ 1

Конкретный вопрос. Есть ли способ выяснить, все ли ptr или любой ptr по-прежнему ссылаются на действительный объект или ячейку памяти?

Нет. Нет никакого способа понять это с помощью сырых указателей. Не в стандартном С++, по крайней мере.

Вам нужно будет гарантировать, что заостренный объект остается в живых до тех пор, пока он указывает на.

Общая схема, которая используется для обеспечения гарантии, представляет собой RAII, как описано в других ответах. Другим подходом к обеспечению достоверности указателя является использование интеллектуального указателя вместо исходного. Однако они не совместимы с автоматическими переменными.

Было бы хорошо продолжать указывать на мертвые объекты, пока вы могли бы гарантировать, что указатель не будет разыменован. Что часто трудно гарантировать, потому что, как уже было сказано, нет возможности проверить, существует ли заострённый объект.

Ответ 2

Это звучит как отличный вариант для RAII.

Напишите класс, который принимает имя файла и std::ostream** как параметры для своего конструктора. В конструкторе указанного класса создайте поток (как элемент) и установите указатель на поток. В деструкторе вернитесь к stdout.

Затем замените первые две строки следующей функции объявлением нового класса.

void foo()
{
  std::ofstream fileout("test.txt", std::ofstream::out | std::ofstream::app);
  setOutput(fileout);
  writeData("message to file");
}

Ответ 3

Вы должны использовать RAII, чтобы принудительно установить поток, а затем вернуться к std:: cout, если объект был уничтожен.

class OutputStream
{
    protected:
        static std::ostream*& internalGlobalStateOfOutputStream()
        {
            static std::ostream*  out = &std::cout;
            return out;
        }
    public:
        static std::ostream& getOutputStream()
        {
            return *internalGlobalStateOfOutputStream();
        }
};
template<typename T>
class OutputStreamOwner: public OutputStream
{
    T  ownedStream;
    public:
        OutputStreamOwner(T&& obj)
            : ownedStream(std::move(obj))
        {
            internalGlobalStateOfOutputStream() = &ownedStream;
        }
        template<typename... Args>
        OutputStreamOwner(Args... args)
            : ownedStream(args...)
        {
            internalGlobalStateOfOutputStream() = &ownedStream;
        }
        ~OutputStreamOwner()
        {
            internalGlobalStateOfOutputStream() = & std::cout;
        }
        // Delete copy
        OutputStreamOwner(OutputStreamOwner const&)           = delete;
        OutputStreamOwner& operator(OutputStreamOwner const&) = delete;
};

Использование:

void foo()
{
  OutputStreamOwner<std::ofstream>  output("test.txt", std::ofstream::out | std::ofstream::app);

  writeData("message to file");
}

Ответ 4

Возможным подходом является создание класса RAII, который переносит поток, прежде чем передавать его в setOutput. Этот класс должен быть разработан так, чтобы работать как shared_ptr, так что он поддерживает общий счетчик ссылок. writeData затем проверяет, имеет ли он единственную оставшуюся ссылку, и если это так, то уничтожает ostream и по умолчанию cout.

Ответ 5

Вы можете избежать этих осложнений в целом с помощью функции, которая принимает поток в качестве входных данных.

void writeData(std::ostream& os, const std::string & msg)
{    
     os << msg << '\n';
}

Вы можете дополнительно уточнить его, возвратив поток, чтобы можно было называть его:

std::ostream& os writeLine(std::ostream& os, const std::string & msg)
{    
     os << msg << '\n';
     return os;
}

// declare stream
stream << writeLine(stream, "Foo") << writeLine(stream, "Bar");

Фактически эта функция более удобна и удобна в обслуживании, так как вам не нужно помнить, какой поток установлен в любой момент времени. Для больших программ это важное качество.

Ответ 6

Конкретный вопрос. Есть ли способ выяснить, является ли поток ptr или любой ptr по-прежнему ссылаются на действительный объект или памяти?

ps: я мог бы использовать память кучи и делать что-то с умными указателями, но честно говоря, я хотел бы сохранить это, если возможно

Нет, нет стандартного способа проверки, если необработанный указатель или ссылка все еще ссылаются на действительный объект.

RAII - это стандартное решение на С++ для такого типа проблем, поэтому, на мой взгляд, вы должны смотреть на интеллектуальные указатели. Я не знаю ни одной библиотеки, предоставляемой интеллектуальным указателем, который бы разрешил эту конкретную проблему, но решение RAII, основанное на совместной собственности, кажется лучшим решением здесь.