C＆＃x2B;＆＃x2B;等效于C＃9.0 New（）与推论类型

Question

C＃9+知道从LHS推断RHS的类型，只需使用正确的参数调用new并具有您的对象。无需重复冗长的类型，类型总是正确的，

List<int> ints = New(capacity: 10_000);

可以在C ++中完成相同的干新吗？

我使用“安全”的新和删除有类似的东西，这些新和删除将目标作为参数和使用模板推断出类型等，但是它比my_var = new（arg1，arg1，arg2，arg2）>

请注意，这是一个有关如何做a = new（1,2,3）（例如C＃）的问题; vector＆lt; toupel＆lt; int，float，car＆gt;＆gt;＆gt;＆gt;＆gt;＆gt;＆gt;＆gt;＆gt;＆gt;＆gt;＆gt;＆gt;＆lt; vector＆lt; vector＆lt; toupel＆lt; int，float，float，char＆gt;＆gt;＆gt;＆gt;＆gt;＆gt;》 '有时用shared_ptr和CO包装。

new-operator

Answer 1

首先，您应该很少在现代C ++中使用明确的内存管理。使用智能指针，例如 std :: simelor_ptr带有所有权语义。

至于您的问题，您可以以大致相同的方式执行此操作，但可以相反：声明中的类型自动划分，并指定new表达式中的类型：

auto* my_pointer = new MyClass<template_type>(arguments, to, constructor);

或使用唯一指针：

auto my_unique_pointer = std::make_unique<MyClass<template_type>>(arguments, to, constructor);

---

至于容器的主题，您几乎绝不应该向容器施加指针。如果需要容器，只需创建一个实例：

std::vector<int> v1(10000);  // Create a vector of 10000 integers

Answer 2

这是您可以写在C ++中的新（警告，测试）

  template <typename ... Args>
  struct NewHelper : public std::tuple<Args...>
  {
      using std::tuple<Args...>::tuple;

      template <typename R>
      operator R*()
      {
          return new_impl<R>(std::make_index_sequence<sizeof ... (Args)>{});
      }

      template <typename R, std::size_t... I>
      R* new_impl(std::index_sequence<I...>)
      {
          return new R(std::get<I>(static_cast<std::tuple<Args...>&>(*this))...);
      }
  };

  template <typename ... Args>
  auto New(Args&&... args)
  {
      return NewHelper<Args&&...>(std::forward<Args>(args)...);
  }

用法：

int* x;
x = New(42);

std::tuple<int&, std::string>* y;
y = New(*x, "Hello dangling reference");

请注意，我说您可以写它，而不是您应该写它。这是高度违反直觉的抗异错C ++，绝对不应让生产代码接近。尝试危险事物很有趣，但是有趣的是有趣，而且工作是工作。

Answer 3

这是我的safe_new和safe_delete variant：
哪个有效，但不像我喜欢的

template<typename T>
void safe_delete(T **p) {
    if (*p == nullptr)
        return; // do not delete twice
    delete *p;
    *p = nullptr;
}

// call new but make sure to delete previous object
template<typename T, typename... Types>
void safe_new(T **p, Types... args) {
    if (*p != nullptr)
        delete p; // do not delete twice
    *p = new std::remove_pointer<std::remove_pointer<decltype(p)>::type>::type(args...);
}

审美方式：

PagedHashMap<tuple<int, int, float>, Edge, boost::hash<tuple<int, int, float>> > *edge_map;

带有参数的新来，但没有明确的类型：

safe_new(&edge_map, 2000000));

请注意，这不是一个确切的答案 - 更好的答案将是：

edge_map = new(20000);

Answer 4

首先，C ++和C＃Sharp中新的含义不同。使用C＃，每当您尝试调用构造函数时，都需要使用new。但是，对于C ++，您只应使用new在尝试创建一个生命周期的对象时不受其创建的范围的限制。即使您确实需要手动管理对象寿命，您应该考虑使用智能指针。

因此，C＃中的该代码：

List<int> ints = new(capacity: 100);
ints = new(capacity: 1000);

要在C ++中重写，您确实不应使用new。相反，它应该像：

list<int> ints(100);
ints = list<int>(1000);

---

现在回到您的问题一样，您想知道第二行，是否可以重新分配ints而无需输入其类型。虽然此示例中的类型很短，但如果类型实际上很长，可能会很详尽。

您可以使其短的一种方法是创建一个可以创建任何对象的助手函数：

template<typename ReturnType, typename ... Args>
ReturnType create(Args&& ... args)
{
    return ReturnType(std::forward<Args>(args)...);
}

它的作用就是将所有参数转发到return typepe的构造函数。然后，您可以像以下内容一样使用它：

SOME_REALLY_REALLY_LONG_TYPE_NAME foo(100);
foo = create<decltype(foo)>(1000);

但是，exltype（foo）仍然感觉冗长且多余。要进一步缩短它，您可以创建另一个功能，以foo作为参考，然后在该函数中执行创建：

template<typename Original, typename ... Args>
void reassign(Original& original, Args&& ... args)
{
    original = create<Original>(std::forward<Args>(args)...);
}

现在您的代码将变为：

SOME_REALLY_REALLY_LONG_TYPE_NAME foo(100);
reassign(foo, 1000);