小编Hel*_*irr的帖子

在我的游戏引擎中,有三个类:EntityCharacter,EntityVehicle和EntityVehicleSeat.

EntityVehicle包含具有指向EntityCharacter实例的指针的席位对象.如果seat对象的目标字符实体指针是空指针,则该特定的seat对象上不会有任何字符.EntityCharacter类实例还具有指向座位对象的指针,指示这些字符实体是否位于某些车辆中.

换句话说,EntityCharacter类实例有一个指向EntityVehicleSeat的指针,反之亦然:

EntityCharacter -> EntityVehicleSeat
EntityCharacter <- EntityVehicleSeat

这样我们就可以通过角色和车辆实体来检查这种所有权.

设置指针以指向彼此会很简单,但是有一个问题 - 如果另一个对象超出范围,我们最终在剩余对象中有一个无效指针.

如何能够很好地代表这种所有权？另一个对象如何被告知另一个对象不再存在的事实？

在C++ 11中,通常的做法是通过引用将左值传递给函数.

int& f(int& a){
    return a;
}

int main(void){
    auto a = 1;
    auto b = f(a);
    return 0;
}

但是,是否可以通过右值引用将值传递给函数并通过lvalue返回此值？

int& f(int&& a){
    return a;
}

int main(void){
    auto b = f(1);
    return 0;
}

它为什么或为什么不可能？

我有一个名为ScalarClamped的类模板.此类的实例具有用户确定的值范围,并且每当分配给它的值超出其范围时,该值将被限制在用户确定的值范围内,因此名称为"ScalarClamped":

ScalarClamped<float> scalar__(75, 0, 100); // Parameters: current value (75), minimum allowed value (0), maximum allowed value(100).
scalar__ += 50;
std::cout << scalar__.value() << std::endl; // Output: 100.
scalar -= 150;
std::cout << scalar__.value() << std::endl; // Output: 0.

在实现成员函数时operator+,我遇到了一个问题.这是operator+一个重载的实现:

template<typename T>
ScalarClamped<T> ScalarClamped<T>::operator+(ScalarClamped const& scalar_clamped_){
    return ScalarClamped<T>::ScalarClamped<T&&, T const&, T const&>(_m_tValue + scalar_clamped_._m_tValue, _m_tValueMin, _m_tValueMax);
}

如您所见,我正在尝试调用模板构造函数.这是它的实现(正在进行中,可能还包含错误):

template<typename T>
template<typename TypeValue, typename TypeMin, typename TypeMax>
ScalarClamped<T>::ScalarClamped(TypeValue value_, TypeMin min_, TypeMax max_):
    // Initialization list:
    _m_tValue((std::is_lvalue_reference<TypeValue>::value) …

我喜欢std :: unique_ptr.它帮助我防止内存泄漏,这是非常有用的.但是有一个问题:不允许复制分配和构造.

即使这种限制有助于程序员的安全,但它也是非常有限的.如果使用std :: unique_ptr作为其成员使用复制赋值和构造的类,则最终会出现问题.这就是为什么我使用复制构造和赋值创建了我自己的unique_ptr包装器.这是它的复制构造函数:

template<typename T, class Deleter>
PointerSmartSafe<T, Deleter>::PointerSmartSafe(PointerSmartSafe const& pointer_smart_safe_) noexcept : _m_opPointerUnique((_m_opPointerUnique == nullptr) ? new T(*_m_opPointerUnique.get()) : nullptr){

}

这是复制赋值运算符:

template<typename T, class Deleter>
PointerSmartSafe<T, Deleter>& PointerSmartSafe<T, Deleter>::operator=(PointerSmartSafe const& pointer_smart_safe_) noexcept{
    _m_opPointerUnique = decltype(_m_opPointerUnique)(new T(*_m_opPointerUnique.get()));
    return *this;
}

一切正常,直到我最终使用抽象基类作为类型(T).我收到如下错误消息:

error: cannot allocate an object of abstract type 'AbstractBaseClass'

这让我感到困惑.是否存在变通方法？

根据我的理解,动态内存分配可用于控制对象的生命周期.当我" 新 "一个对象时,它会在堆中保留在内存中,直到我删除它为止.

现在,有时情况并非那么简单.情况就是这种情况,我希望保留一定的内存块,直到我释放它,防止破坏该内存块中的数据.例如,我想将指向堆栈上分配的对象的指针插入到向量中.只要指向对象的指针位于该向量中,指针指向的对象就不会被销毁.这是出于安全原因.如何实现这一点,使用动态内存分配保留一块内存？