calm27's questions

下面是一个非常简单的例子，说明它是如何工作的copy constructor：

class Base
{
  public:
    Base() { std::cout << "Base default constructor invoked!" << std::endl; };
    Base(const Base& copy) { std::cout << "Base copy constructor invoked!" << std::endl; };
    Base& operator=(const Base& copy) = default;
};

class Derived : public Base
{
  public:
    Derived() { std::cout << "Derived default constructor invoked!" << std::endl; }
    Derived(const Derived& copy) { std::cout << "Derived copy constuctor invoked!" << std::endl; }
};

int main(void)
{
   Derived der;
   Derived der0 = der;

   return 0;
}

如果在函数中将 ,main更改Derived der0为Derived& der0，则copy constructor不会调用它。

因此，问题出现了，为什么当我们通过引用捕获异常时：

try
{
   // throw error
} 
catch(std::exception& e) {}

然后我们将调用一个复制构造函数，并且只针对该类exception？为什么在正常情况下，我们（如上面的示例）在执行Base时不为类调用任何复制构造函数Derived& der0 = der，而是在块catch中调用它，而只是排除最顶层？

在这里找到了它如何工作的示例，但没有解释。

我想知道当我们将一些流量发送到一个地址（例如24.25.16.13:80，是还是只是协议的数据？191.168.1.14:8080IPоткрыт

输出到控制台后，我得到了结果4。

怎么会这样？

void f(int* p)
{
   int a = 47;
   p = &a;
}

int main()
{
   int* p = new int(4);

   f(p);

   std::cout << *p << std::endl;
}

第一次遇到这种构造，在class函数的参数中，看不懂是干什么用的？

virtual void SetupInputComponent(class UInputComponent* InputComponent) override;

header将文件包含在.cpp而不是包含在中的构建好处是什么.h？这如何影响构建时间以及它的优缺点是什么？

我曾经认为header，根据所有的规范，它们应该只包含在头文件中。（作为一种选择，以便.cpp文件保持干净并且可以在一个地方看到所有导入）

例子：

A.h：

inline void in_func(){}

B.h

#include "A.h" ???
class B {
public: 
  void func();
};

B.cpp：

#include "B.h"
#include "A.h" ??? 

void B::func()
{
  in_func();
}

是否可以在构造函数中调用另一个构造函数两次？

class Constructor
{
public:
Constructor()
{
    printf("Default constructor\n");
}

explicit Constructor(int _a) : Constructor("explicit")
{
    printf("Integer constructor\n");
    this->a = _a;
}

Constructor(std::string _str) : str(_str)
{
    printf("string constructor\n");
    Constructor(true);
    Constructor(1, 2);
}

Constructor(bool _flag) : flag(_flag) 
{
    printf("Bool constructor");
}

Constructor(int a, int b)
{
    printf("one more");
}

void Print()
{
    printf("a = %d\n", a);
    printf("flag = %d\n", flag);
}
private:
    int a;
    std::string str;
    bool flag = false;
};
int main()
{
    Constructor cons(1);
    cons.Print();
   return 0;
}

我希望在控制台中看到：

字符串构造函数
Bool 构造函数
再一个
Integer 构造函数 a = 1 flag = 1

相反：

bool 构造函数整数构造函数 a = 1 标志 = 1

char* /const char*如果使用 not , but ，使用字符串会有问题unsigned char*/const unsigned char*吗？如果一切都正确，例如，在 中UTF-8，每个字符在从 的范围内都有自己的索引1-255。在char*范围的情况下会有所不同。

预计a在完成时会被清理GetA()，其在方法中的引用main将无效。

class A
{
 public:
 std::string str;
 void Print()
 {
    std::cout << str << std::endl;
 }
};

A GetA()
{
  A a;
  a.str = "this is my string";
  return a;
}

int main()
{
  A a = GetA();
  a.Print();
  return 1;
}

但结果在控制台中我得到了this is my string.

视图矩阵示例说明：

glm::mat4 View       = glm::lookAt(
glm::vec3(4,3,3), // Камера находится в мировых координатах (4,3,3)
glm::vec3(0,0,0), // И направлена в начало координат
glm::vec3(0,1,0)  // "Голова" находится сверху
);

关于第三个参数的问题。向量不应该up完全指向相机上方（相机上方）的点吗？如果我们的相机在坐标中(4,3,3)，那么它up应该是(4,4,3)。或不？

为什么我要进入这个if？

bool* keys[256];
for(auto key : keys) { key = false; }
if (keys[GLFW_KEY_W]) // GLFW_KEY_W = 64
{
    std::cout << "I'm inside if" << std::endl;
    std::cout << keys[GLFW_KEY_W]; 
    position += front * velocity;
}

如果我在里面

240

如何理解keys[GLFW_KEY_W]返回我的内容，我如何理解索引并同时进入内部if？为什么我在里面？

UPD

在 C++ 中初始化类成员的顺序是什么？是先调用类构造函数，还是先初始化类成员？

class A {}
class B
{ 
public:
   B() = default;

private: 
   A a; 
   static A a0;
   int i;
   static int i0; 
}

我想创建一个指向函数的链接，因为它每次都是很长的调用链。

typedef void(*PlayerVP)(FVector&, FRotator&);
PlayerVP VP = &GetWorld()->GetFirstPlayerController()->GetPlayerViewPoint;

结果，错误：

错误 C2276：“&”：对绑定成员函数表达式的非法操作

如果你拿走＆符号，那么另一个错误：

错误 C3867：“APlayerController::GetPlayerViewPoint”：非标准语法；使用 '&' 创建指向成员的指针

函数本身的签名GetPlayerViewPoint：

void AController::GetPlayerViewPoint( FVector& out_Location, FRotator& out_Rotation ) const

返回的函数singleton：

static SingletonDatabase& get()
{
    static SingletonDatabase db;
    return db;
}

这是一种实现此模式的新方法，而不是创建一个私有字段static Singleton* instance，然后创建一个单独的函数来返回它。

我不明白它是如何工作的，它是什么意思？本地静态字段，具有默认构造函数。

为什么这个实现比以前的更好？

0x0和有什么区别0x00？0xF和有什么区别0xFFFFFFFF？这些值是否占用不同的内存量？如何学习正确阅读和理解，以及使用十六进制数字系统？我的项目中有很多使用位掩码的工作，有时我不明白人们如何选择、如何录制以及录制什么？为什么有时0xF有时0xFF。我已经阅读了足够多的材料来了解它是如何工作的，但我仍然不明白如何正确地学习如何使用位标​​志，也不明白应该选择什么以及这些选择之间有什么区别。

图书馆的例子OpenGL：

#define GL_DEPTH_BUFFER_BIT               0x00000100
#define GL_STENCIL_BUFFER_BIT             0x00000400

无法弄清楚为什么这两个标志不同？我认为这完全取决于节拍的位置。

据我了解，一个类型通常integer重 4 个字节，包括unsigned integer. 但是在某些情况下，根据处理器的位数integer，它可以同时具有 2 个字节和 8 个字节。我不明白位数如何影响整数类型的大小以及它对开发人员有什么影响，除了它可以适应更广泛的数字（或更小）？

UPD

x32将程序从 翻译为是什么意思x64？粗略地说，这些是类型的用途x64？x64如果我理解正确，那么编写的程序无法运行的原因x32是数据类型的内存开销？那为什么我们可以Visual Studio选择在什么位深度下做build呢？这将如何影响程序本身的大小以及普通数据类型的大小？

如果最初std::weak_ptr指向一个空指针std::shared_ptr：

std::shared_ptr<Ptr> ptr = nullptr;
std::weak_ptr<Ptr> weak(ptr);

但在那之后它ptr开始指向某个对象Ptr：

ptr = std::make_shared<Ptr>();

指针weak没有改变它的状态并且仍然保持expired？

weak.expired() == true?

因为下面的代码：

int main()
{
   std::shared_ptr<Ptr> ptr = nullptr;
   std::weak_ptr<Ptr> weak(ptr);

   if (weak.expired())
   {
       std::cout << "shared is nullptr" << std::endl;
   }

   ptr = std::make_shared<Ptr>();
   std::shared_ptr<Ptr> ptr1 = weak.lock();
   std::cout << "counter must be 2. Actual: " << ptr.use_count() << 
   std::endl;
   return 0;
}

在将拥有指针的数量输出到控制台时，我们有一个值1at，正如预期的那样2。

事实证明，它仅显示仅在其创建时的std::weak_ptr最新信息？std::shared_ptr如果以后这个智能指针从非空变为存在，weak指针不会改变它的状态吗？

当我们通过引用从函数中返回一个对象时，我们就会调用一个复制构造函数。

Top& GetRef()
{
   Top top(args);
   return top;
}

int main()
{
   Top top = GetRef();
   std::cout << top.property << std::endl;
   return 0;
}

问题。是否可以通过引用替换函数的返回，std::move()或者更准确地说，通过rvalue引用返回，这是否正确？这样的更改会被认为比调用复制构造函数更经济吗？

Top&& GetRef()
{
   Top top(args);
   return std::move(top);
}

int main()
{
   Top&& top = GetRef();
   return 0;
}

我有一个包含A.h以下代码的文件：

namespace Top 
 {
    namespace Inner
    {
       namespace Bottom {
          class ClassA { ... }
       }
    }
 }

在另一个文件B.h中，类似的代码：

namespace Top 
 {
    namespace Inner
    {
       namespace Bottom {
          class ClassB { ... }
       }
    }
 }

我的问题。

为什么在不同的文件中描述相同的名称namespace？或者，在编译或链接过程中，它们以某种方式合并为一个，编译器可以理解，如果我们在文件中具有相同的名称A，B那么它是否相同namespace？我有一个包含 20 多个不同文件的项目，这些文件具有相同的命名空间名称，但其中一些具有不同的类。此外，如果我想连接到我的项目dll，我将在其中ClassC拥有相同的空间名称层次结构，它会被视为相同namespace还是已经不同？为什么我们需要在不同的文件中重复空间名称？

这个选项有效吗？

#include "A.h"
#include "B.h"

void func()
{
    Top::Inner::Bottom::ClassA();
    Top::Inner::Bottom::ClassB();
}

使用十六进制来确定变量值的特殊含义是什么？

#define SPAWNFLAG_NOT_EASY          0x00000100
#define SPAWNFLAG_NOT_MEDIUM        0x00000200
#define SPAWNFLAG_NOT_HARD          0x00000400
#define SPAWNFLAG_NOT_DEATHMATCH    0x00000800
#define SPAWNFLAG_NOT_COOP          0x00001000

它是否以某种方式加快了机器级别的工作，或者它有一些优势？我经常看到这样的代码，尤其是在游戏项目中。为什么是十六进制？为什么没有其他方法？

stack没有必要解释它是什么heap，关于它是如何工作的以及函数中的变量会发生什么的材料已经绰绰有余，但是在花了一些时间之后，我注意到实际上没有足够的材料来说明程序时如何分配内存是第一次推出？当程序编译并准备构建时，此时已经计算出启动和运行所需的最小内存量，而程序本身在stack新区域中占用了一块内存？我可以有一个公开的答案或描述这个的好材料吗？
最初是如何为程序分配内存的，分配在哪一部分？