相关疑难解决方法(0)

有人可以告诉我并提供一个代码示例,说明是否可以在不使用c ++继承的情况下创建可以容纳任何类型对象的数组？我还没有编写任何代码,但是例如,如果我有两个类:RangedWeap和MeleeWeap,有没有办法将这些对象存储在同一个数组中而不使用继承？

struct A
{
  int i;
};

struct B
{
 B(){} 
 int i;
}

大家好

我知道"POD意味着普通旧数据类型,根据定义,它不能具有用户定义的构造函数".但是,当"定义具有用户定义的默认值"时,我无法理解为什么此规则有效.

它们的内存布局没有区别.为什么A类是POD,而不是B？

我是c ++ 11的新手,并编写了以下代码来了解其std::move工作原理:

#include <queue>
#include <stdio.h>

class X {
 public:
  X(int x) : x_(x) {}
  ~X() {
    printf("X(%d) has be released.\n", x_);
  }

  X(X&&) = default;
  X& operator = (X&&) = default;

  X(const X&) = delete;
  X& operator = (const X&) = delete;
 private:
  int x_;
};


int main() {
  std::queue<X> xqueue;
  for (int x = 0; x < 5; ++x) {
    xqueue.push(std::move(X(x)));
  }
  return 0;
}

但是,它会生成以下输出,表示每个的析构函数X(n)都被调用了两次:

X(0) has be released.
X(1) has be …

随着我对编码的了解越来越多,我喜欢尝试一下.我有一个程序,它只需要一个结构的单个实例来维持它的运行时间,并且想知道是否可以创建一个单例结构.我看到很多关于在互联网上制作单例类的信息,但没有关于制作单例结构的信息.可以这样做吗？如果是这样,怎么样？

提前致谢.哦,我用C++工作.

所以我有以下代码,我想做的简化版本.我有一个带有成员变量的类,我希望将其设置为潜在的各种不同的数据类型,具体取决于具体情况(我只是为此测试制作了一个随机结构).我不断在memcpy函数上遇到seg错误,我不明白为什么.

 #include <cstdlib>
 #include <iostream>
 #include <assert.h>
 #include <string>
 #include <string.h>
 #include <stdio.h>
 using namespace std;

struct product
{
        int price;
        string name;
};


class object
{
public:
        void setData(void *ptr);
        void* data;
};


void object::setData(void *ptr)
{
        assert(ptr);
        memcpy(data, ptr, sizeof(ptr));
}


int main()
{
        product* bag;
        product ba;
        bag = &ba;
        bag->price = 5;
        bag->name = "bag";

        object test;
        test.setData(bag);

        cout<<test.data->name<<endl;

        return 0;
}

我有两个不同的应用程序。我必须将信息从一个应用程序发送到另一个。在一个应用程序中，在类对象中编码，而在另一应用程序中，在具有相同数据类型的结构对象中解码。

将类对象复制到具有相同数据类型的结构是否正确实现？还是我必须更改编码/解码部分之一？

我尝试了它，似乎正确的memcpy，但我不知道它是否正确。

例如...

#include <iostream>
#include <cstring>

class capn{
    public:
    unsigned short int apn[8];
    unsigned short int a;
};

class creq{
    public:
    capn a1;
    capn a2;
    unsigned short int t;
    capn a3;
};

class cy{
    public:
    capn a1;
    capn a2;
    unsigned short int aaa[34];
    capn a3;
    unsigned short int bbb[12];
};

class cx{
    public:
    cx(){
        a=0;
        b=0;
        c=0;
        memset(d,0,8);
    }
    unsigned int a;
    unsigned int b;
    unsigned int c;
    union {
        creq requ;
        cy pasd;
    };
    unsigned short int …

假设我有一个unsigned char指针(uchar*从现在开始)到T不同类型的数组的开头uchar.知道这个数组的大小并且它是连续的(使用创建malloc),是否可以在不知道类型的情况下将其复制到另一个数组T？如何以字节为单位访问它？

谢谢

我的团队现在已经有几个星期这个问题了,我们有点难过.善意和知识将优雅地收到!

使用嵌入式系统,我们试图序列化一个对象,通过Linux套接字发送它,在另一个进程中接收它,然后将它反序列化回原始对象.我们有以下反序列化功能:

 /*! Takes a byte array and populates the object's data members */
std::shared_ptr<Foo> Foo::unmarshal(uint8_t *serialized, uint32_t size)
{
  auto msg = reinterpret_cast<Foo *>(serialized);
  return std::shared_ptr<ChildOfFoo>(
        reinterpret_cast<ChildOfFoo *>(serialized));
}

该对象已成功反序列化,可以从中读取.但是,当std::shared_ptr<Foo>调用返回的析构函数时,程序会出现段错误.Valgrind给出以下输出:

==1664== Process terminating with default action of signal 11 (SIGSEGV)
==1664==  Bad permissions for mapped region at address 0xFFFF603800003C88
==1664==    at 0xFFFF603800003C88: ???
==1664==    by 0x42C7C3: std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release() (shared_ptr_base.h:149)
==1664==    by 0x42BC00: std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count() (shared_ptr_base.h:666)
==1664==    by 0x435999: std::__shared_ptr<ChildOfFoo, (__gnu_cxx::_Lock_policy)2>::~__shared_ptr() (shared_ptr_base.h:914)
==1664==    by 0x4359B3: std::shared_ptr<ChildOfFoo>::~shared_ptr() (shared_ptr.h:93)

我们对任何建议都持开放态度!感谢您的时间 :)

我目前正在实现我自己的矢量容器，但遇到了一个非常有趣的问题（至少对我来说）。这可能是一个愚蠢的问题，但idk。

我的向量使用一个堆指针数组来堆分配未知类型 (T**) 的对象。我这样做是因为我希望对单个元素的指针和引用保持不变，即使在调整大小之后也是如此。

这是在构造和复制时以性能为代价的，因为我需要在堆上创建数组以及在堆上创建数组的每个对象。（堆分配比堆栈慢，对吧？）

T** arr = new *T[size]{nullptr};

然后对于每个元素

arr[i] = new T{data};

现在我想知道它是否安全、有益（更快）和可能，如果不是单独分配每个对象，我可以在堆上创建第二个数组并将每个对象的指针保存在第一个数组中。然后使用（并删除) 这些对象稍后就好像它们是单独分配的一样。

=> 在堆上分配数组是否比单独分配每个对象更快？

=> 在数组中分配对象并稍后忘记数组是否安全？（我觉得这听起来很愚蠢）

链接到我的 github 仓库：https : //github.com/LinuxGameGeek/personal/tree/main/c%2B%2B/vector

谢谢你的帮助 ：）

我有以下 C++ 代码。您可以看到我创建了一个带有构造函数和复制构造函数的结构。有人可以解释一下为什么为第一个赋值调用复制构造函数而不是为其他 2 个赋值调用吗？

#include <iostream>
#include <string>
#include <vector>

struct Vertex
{
    float x, y, z;
    Vertex(float x, float y, float z)
        : x(x), y(y), z(z)
    {
        std::cout << "Created Vertex!" << std::endl;
    }
    Vertex(const Vertex& v) // Copy constructor
        : x(v.x), y(v.y), z(v.z)
    {
        std::cout << "Copied!" << std::endl;
    }
};

std::ostream& operator<<(std::ostream& stream, const Vertex& _v) // Overloading operator<<
{
    stream << _v.x << ", " << _v.y << ", " << _v.z;
    return stream;
} …