小编JeJ*_*eJo的帖子

使用 new 关键字创建对象：

#include <iostream>
#include <string>

using namespace std;

class Person {
  private:
  string name;

  public:
  Person(string name) {
    setName(name);
  }

  string getName() {
    return this->name;
  }

  void setName(string name) {
    this->name = name;
  }
};

int main() {
  Person *person1 = new Person("Rajat");
  Person *person2 = person1;

  person2->setName("Karan");

  cout << person1->getName() << endl;
  cout << person2->getName() << endl;

  return 0;
}

输出：

Karan  
Karan

创建没有 new 关键字的对象：

#include <iostream>
#include <string>

using namespace std;

class Person {
  private: …

正如答案所指出的，这是我犯的一个愚蠢的错误，与多态性或智能指针无关。更正后的版本在接受的答案中。

==============原始问题==================

我正在尝试使智能指针与多态一起工作。在下面的原型代码中，纯virtual函数的实现Base::print()应该在Derived对象的内存块中。DerivedWrap可以访问指向Derived对象的指针。

为什么不能DerivedWrap::print()访问函数实现？

using namespace std;

class Base 
{
public:
    virtual void print() = 0;
};

class Derived : public Base 
{
public:
    Derived(int in) : i(in) {}

    void print() {
        cout << "int is " << i << endl;
    }

private:
    int i;
};

class DerivedWrap 
{
public:
    DerivedWrap() : DerivedWrap(make_unique<Derived>(2)) {}
    DerivedWrap(unique_ptr<Base> pBase) : _pBase(move(pBase)) {}

    void print()
    {
        _pBase->print();
    }

private:
    unique_ptr<Base> …

我希望我的函数采用左值引用，而绝对不是右值或临时值或其他任何值。

这是我的功能：

template<class T>
void foo(T& value) {}

// Imagine I have a class Foo
struct Foo
{ 
   int a;
   int b;
};

当我调用 时foo(Foo{1, 2})，首先，即使我要求左值引用，它也会编译，其次，它不起作用，因为foo存储了传递值的地址，所以我稍后阅读时会得到垃圾。

如何强制foo采用左值引用？

我试图优雅地声明一个常量std::set对象，它将是另外两个常量std::set对象的合并。

#include <set>

const std::set<int> set_one = { 1,2,3 };
const std::set<int> set_two = { 11,15 };
const std::set<int> set_all = { 1,2,3,11,15 }; // this is not very elegant, duplication

以set_all这种方式声明对象不太优雅，因为它复制了前两行的信息。有没有办法在声明中使用set_one和set_two常量set_all？

像这样的东西：

const std::set<int> set_all = set_one + set_two; // this does not compile, of course!

1. 所有对象都是严格的常量。
2. 两个源集中没有重叠值，因此唯一性不会成为问题。
3. 我知道如何在运行时合并集合，这不是我要找的。
4. 我真的很想避免使用这样的宏：

#include <set>

#define SET_ONE 1, 2, 3
#define SET_TWO 11, 15

const std::set<int> set_one = { SET_ONE …

如何正确且轻松地初始化class包含std::vector某个其他类的 a 的实例，该类本身包含一些数据。

我知道用文字来解释它真的很难，所以我会写一段不起作用的代码，但它抓住了我的意图。

#include <vector>

struct Point
{
   float x, y;
};

struct Triangle
{
   Point points[3];
};

struct Geometry
{
   std::vector<Triangle> triangles;
};

int main()
{
   Geometry instance
   {
     {{0,0}, {6, 0}, {3, 3}},
     {{5,2}, {6, 6}, {7, 3}}
   };
   return 0;
}

此代码不起作用。Clang 返回错误 -

excess elements in struct initializer

我不明白为什么它给我这个错误。

我想我可以初始化

• 在std::vector的Triangle小号，
• 然后是Points的数组，
• 然后是float每个Point对象中的两个s 。

我将如何Geometry使用一些值正确初始化类的实例而不使用初始化方括号编写太多代码？

如果您有其他选择，那么我愿意考虑它们。

我想调用函数，它会更改小部件内的文本。

有一个virtual函数NativeConstruct，它会自动调用。它会更改小部件的文本，但我需要调用函数F1并向其发送我想要显示的文本。但是当我调用它时，变量Name是nullptr. 由于某种原因nullptr，当程序调用NativeConstruct.

• Name 是我的文本变量，我想改变
• dialogBottom 是具有此变量的小部件的名称

已编辑

UAccessWidgetFromCpp* AccessWidgetFromCpp 
= CreateWidget<UAccessWidgetFromCpp>(
      GetWorld()->GetFirstPlayerController(), UAccessWidgetFromCpp::StaticClass()
   );

if (AccessWidgetFromCpp)
{
   AccessWidgetFromCpp->F1("222");
   widgetDialogBottomInstance->AddToViewport();
}

UCLASS()
class HOME_API UAccessWidgetFromCpp : public UUserWidget
{
   GENERATED_BODY()

public:
   UPROPERTY(BlueprintReadOnly, meta = (BindWidget))
   class UTextBlock* Name = nullptr;

   UFUNCTION()
   void F1(FString text);
};

void UAccessWidgetFromCpp::F1(FString text)
{
   if (auto widget = dynamic_cast<UTextBlock*>(GetWidgetFromName(TEXT("Name"))))
   {
      Name = widget;
      Name->SetText(FText::FromString(text));
   }
}

我在看书时遇到了可变参数模板，并认为实现一个 python 风格的print函数会很酷。

这是代码。

#include <iostream>
#include <string>

#define None " "

template<typename T, typename... Tail>
void print(T head, Tail... tail, const char* end = "\n")
{
    std::cout << head << end;
    if constexpr (sizeof...(tail) > 0)
    {
        print(tail..., end);
    }
}

int main()
{
    // Error: no instance of function template "print" matches the argument list
    print("apple", 0, 0.0f, 'c', true);

    // Error: no instance of function template "print" matches the argument list
    print("apple", 0, …

下面的代码无法编译：

template<typename... Ts>
void CreateArr(const Ts&... args)
{
    auto arr[sizeof...(args) + 1]{ args... };
}

int main()
{
    CreateArr(1, 2, 3);
}

由于以下错误：

• 'arr'：在直接列表初始化上下文中， for 的类型'auto [6]'只能从单个初始化表达式推导
• auto [6]'：数组的元素类型不能包含'auto'
• “正在初始化”：无法从 转换'const int'为'std::initializer_list<int>'

我的问题是：

• 为什么我不能使用auto来定义数组的类型？

• 如何正确定义它以与模板一起使用？

在 python 中，我可以使用*args允许可变数量的输入到函数中。例如，以下代码段将打印出调用 f 时传递的所有参数：

def f(*args):
  for a in args:
    print(a)

我希望能够在具有以下要求的 C++11 中实现这样的模式：

函数 f 将始终接受特定类型 T 的值，然后是可变数量的输入；这可能包括 0 个额外的输入。

额外的输入不一定是相同的类型，所以使用初始化列表是行不通的。

函数 f 将被另一个函数 g 调用，该函数需要将可选参数转发给 f：

T g(const T& x, args...) {
  T output = f(x, args...);
  return output;
};

T f(const T& x, args...) {
  // do some stuff and return an object of type T
};

我该如何解决这个设计问题？我尝试过可变参数模板，但似乎无法使我的实现正常工作（编译但由于右值引用问题而无法链接）。

typename在函数的返回类型之前使用“”与在函数声明中不使用它（如下所示）有什么区别？

如果我们根本不使用它，会有什么不同呢？

template< class T > typename std::remove_reference<T>::type&& move( T&& t );
template< class T > std::remove_reference_t<T>&& move( T&& t ) ;