Почему javac жалуется на не инициализированная переменная?

Мне понравился ответ Клайма, поэтому я написал это очень быстро. Я не утверждаю идеальной правоты, но это выглядит довольно хорошо для меня. (то есть единственным испытанием является образец основной ниже)

Это универсальный ленивый инициализатор. Пространство для объекта выделяется один раз, и объект начинается с нуля. Затем можно создать , перезаписав предыдущие объекты без новых выделений памяти.

Реализует все необходимые конструкторы, деструктор, копирование/присвоение, своп, ядда-ядда. Вот вам:

#include <cassert>
#include <new>

template <typename T>
class lazy_object
{
public:
    // types
    typedef T value_type;
    typedef const T const_value_type;
    typedef value_type& reference;
    typedef const_value_type& const_reference;
    typedef value_type* pointer;
    typedef const_value_type* const_pointer;

    // creation
    lazy_object(void) :
    mObject(0),
    mBuffer(::operator new(sizeof(T)))
    {
    }

    lazy_object(const lazy_object& pRhs) :
    mObject(0),
    mBuffer(::operator new(sizeof(T)))
    {
        if (pRhs.exists())
        {
            mObject = new (buffer()) T(pRhs.get());
        }
    }

    lazy_object& operator=(lazy_object pRhs)
    {
        pRhs.swap(*this);

        return *this;
    }

    ~lazy_object(void)
    {
        destroy();
        ::operator delete(mBuffer);
    }

    // need to make multiple versions of this.
    // variadic templates/Boost.PreProccesor
    // would help immensely. For now, I give
    // two, but it's easy to make more.
    void create(void)
    {
        destroy();
        mObject = new (buffer()) T();
    }

    template <typename A1>
    void create(const A1 pA1)
    {
        destroy();
        mObject = new (buffer()) T(pA1);
    }

    void destroy(void)
    {
        if (exists())
        {
            mObject->~T();
            mObject = 0;
        }
    }

    void swap(lazy_object& pRhs)
    {
        std::swap(mObject, pRhs.mObject);
        std::swap(mBuffer, pRhs.mBuffer);
    }

    // access
    reference get(void)
    {
        return *get_ptr();
    }

    const_reference get(void) const
    {
        return *get_ptr();
    }

    pointer get_ptr(void)
    {
        assert(exists());
        return mObject;
    }

    const_pointer get_ptr(void) const
    {
        assert(exists());
        return mObject;
    }

    void* buffer(void)
    {
        return mBuffer;
    }

    // query
    const bool exists(void) const
    {
        return mObject != 0;
    }

private:
    // members
    pointer mObject;
    void* mBuffer;
};

// explicit swaps for generality
template <typename T>
void swap(lazy_object<T>& pLhs, lazy_object<T>& pRhs)
{
    pLhs.swap(pRhs);
}

// if the above code is in a namespace, don't put this in it!
// specializations in global namespace std are allowed.
namespace std
{
    template <typename T>
    void swap(lazy_object<T>& pLhs, lazy_object<T>& pRhs)
    {
        pLhs.swap(pRhs);
    }
}

// test use
#include <iostream>

int main(void)
{
    // basic usage
    lazy_object<int> i;
    i.create();
    i.get() = 5;

    std::cout << i.get() << std::endl;

    // asserts (not created yet)
    lazy_object<double> d;
    std::cout << d.get() << std::endl;
}

В вашем случае, просто создайте члена в вашем классе: leny _ object < B > и вы закончили. Нет ручных выпусков или создания конструкторов копий, деструкторов и т.д. Все берется в вашем хорошем, маленьком повторно используемом классе.:)

EDIT

Устранена потребность в векторе, должен сэкономить немного места, а что-нет.

EDIT ²

Для использования стека вместо кучи используется aligned _ storage и alignment _ of . Я использовал boost , но эта функциональность существует как в TR1, так и в C++ 0x. Мы теряем возможность копирования, а значит, и обмена.

#include <boost/type_traits/aligned_storage.hpp>
#include <cassert>
#include <new>

template <typename T>
class lazy_object_stack
{
public:
    // types
    typedef T value_type;
    typedef const T const_value_type;
    typedef value_type& reference;
    typedef const_value_type& const_reference;
    typedef value_type* pointer;
    typedef const_value_type* const_pointer;

    // creation
    lazy_object_stack(void) :
    mObject(0)
    {
    }

    ~lazy_object_stack(void)
    {
        destroy();
    }

    // need to make multiple versions of this.
    // variadic templates/Boost.PreProccesor
    // would help immensely. For now, I give
    // two, but it's easy to make more.
    void create(void)
    {
        destroy();
        mObject = new (buffer()) T();
    }

    template <typename A1>
    void create(const A1 pA1)
    {
        destroy();
        mObject = new (buffer()) T(pA1);
    }

    void destroy(void)
    {
        if (exists())
        {
            mObject->~T();
            mObject = 0;
        }
    }

    // access
    reference get(void)
    {
        return *get_ptr();
    }

    const_reference get(void) const
    {
        return *get_ptr();
    }

    pointer get_ptr(void)
    {
        assert(exists());
        return mObject;
    }

    const_pointer get_ptr(void) const
    {
        assert(exists());
        return mObject;
    }

    void* buffer(void)
    {
        return mBuffer.address();
    }

    // query
    const bool exists(void) const
    {
        return mObject != 0;
    }

private:
    // types
    typedef boost::aligned_storage<sizeof(T),
                boost::alignment_of<T>::value> storage_type;

    // members
    pointer mObject;
    storage_type mBuffer;

    // non-copyable
    lazy_object_stack(const lazy_object_stack& pRhs);
    lazy_object_stack& operator=(lazy_object_stack pRhs);
};

// test use
#include <iostream>

int main(void)
{
    // basic usage
    lazy_object_stack<int> i;
    i.create();
    i.get() = 5;

    std::cout << i.get() << std::endl;

    // asserts (not created yet)
    lazy_object_stack<double> d;
    std::cout << d.get() << std::endl;
}

И вот мы идем.

Вы устанавливаете идентификатор, но это идентификатор. Вы не должны устанавливать его, SQL делает это для вас.

Вместо создания нового сеанса используйте тот же самый сеанс и извлекайте его с помощью команды Get вместо Load.

О разнице между загрузкой и получением: http://ayende.com/Blog/archive/2009/04/30/nhibernate-ndash-the-difference-between-get-load-and-querying-by.aspx

Переменные экземпляра и класса инициализируются как null (или 0), но локальные переменные не являются.

См. § 4,12,5 в JLS для очень подробного объяснения, которое говорит в основном то же самое:

Каждая переменная в программе должна иметь значение до использования ее значения:

• При создании каждой переменной класса, переменной экземпляра или компонента массива инициализируется значение по умолчанию:
  • [вырезанный список всех значений по умолчанию]
• Каждый параметр метода инициализируется соответствующим значением аргумента, предоставленным инициатором метода.
• Каждый параметр конструктора инициализируется соответствующим значением аргумента, предоставленным выражением создания экземпляра класса или явным вызовом конструктора.
• Параметр обработчика исключений инициализируется инициируемым объектом, представляющим исключение.
• Локальной переменной должно быть явно присвоено значение, прежде чем она будет использована путем инициализации или назначения способом, который может быть проверен компилятором с помощью правил для определенного назначения.