Question

我正在尝试创建一个指向类对象的void指针，并在函数内初始化它。不幸的是，类的数组成员无法转义函数，即初始化后无法访问它。

在下面的代码中，第一次调用打印位置（在初始化函数内）正常工作，但是，从初始化函数外部打印位置的第二次调用失败。我有一种感觉，在初始化函数中创建的数组对象被破坏而不传递，但我不确定，也不知道如何解决它。

非常感谢任何帮助。

#include <iostream>
#include <iomanip>
#include <string>


class Atoms
{
    double * positions;
    int nAtoms;

    public:
        // Standard constructor prividing a pre-existant array
        Atoms(int nAtoms, double * positionsArray)
        {
            this->nAtoms = nAtoms;
            this->positions = positionsArray;
        }

        // Print positions to screen
        void print_positions()
        {
            std::cout<< "nAtoms: " << this->nAtoms << std::endl;
            int nDim = 3;
            for (int i = 0; i < nAtoms; i++)
            {
                for (int j = 0; j < nDim; j++)
                {
                    std::cout << std::setw(6) << this->positions[i * nDim + j] << " ";
                }
                std::cout << std::endl;
            }
            std::cout << std::endl;
        }

};


void initialize_Atoms_void_pointer(void ** voidAtomsPointer)
{
    //Create a new instance of Atoms by a pointer
    int numAtoms = 5;
    int numDim = 3;
    int elemN = numAtoms * numDim;
    double data_array[elemN];

    for (int i = 0; i < numAtoms; i++)
    for (int j = 0; j < numDim; j++)
    {
        data_array[i * numDim + j] = i * numDim + j + 10;
    }
    Atoms *atoms = new Atoms(numAtoms, data_array);

    // Set the vPointer that the void pointer points to a pointer to Atoms object
    *voidAtomsPointer = static_cast<void *>(atoms);

    //Test call
    std::cout << std::endl << "Initializing atoms" << std::endl;
    static_cast<Atoms *>(*voidAtomsPointer)->print_positions();
}


void print_Atoms_pointer_positions(void * voidAtomsPointer)
{
    //Cast the pointer as an atoms pointer
    Atoms *atomsPointer = static_cast<Atoms *>(voidAtomsPointer);

    atomsPointer->print_positions();
}

int main()
{
    //Use the initializer function for getting a pointer
    void *testVoidAtomsPointer;

    initialize_Atoms_void_pointer(&testVoidAtomsPointer);
    print_Atoms_pointer_positions(testVoidAtomsPointer);
}

Answer 1

问题在于

Atoms *atoms = new Atoms(numAtoms, data_array);

data_array是一个本地数组，在initialize_Atoms_void_pointer退出时会被销毁。

不是复制原始指针，而是在Atoms的构造函数中进行新的分配并复制内容：

Atoms(int nAtoms, double * positionsArray)
{
  this->nAtoms = nAtoms;
  this->positions = new double[nAtoms];
  for (int ii = 0; ii < nAtoms; ++ii)
    this->positions[ii] = positionsArray[ii];
}

~Atoms()
{
  delete[] this->positions;
}

更安全的实现将包括使用std::unique_ptr，Pen会在Atoms被销毁时自动为您分配内存：

#include <memory>

class Atoms {
  std::unique_ptr<double[]> positions;
  // ...

public:
  Atoms(int nAtoms, double * positionsArray) :
    positions(new double[nAtoms]) {
    this->nAtoms = nAtoms;
    for (int ii = 0; ii < nAtoms; ++ii)
      this->positions[ii] = positionsArray[ii];        
  }

  // ...
};

您还需要检查nAtoms是0还是否定，如果输入数组为空等等，但我认为它不属于问题的范围。

如果您需要访问原始指针，可以使用positions.get()方法（不要尝试删除它，否则您的应用程序会因双重删除而崩溃）。

<强>更新

当然，另一个更直接的解决方案就是使用std::vector<double>代替;）

#include <vector>

class Atoms {
  std::vector<double> positions;
  // int nAtoms; -- no longer necessary

public:
  Atoms(int nAtoms, double * positionsArray) :
    positions(nAtoms) {
    for (int ii = 0; ii < nAtoms; ++ii)
      this->positions[ii] = positionsArray[ii];      
  }

  // ...
};

如果您需要访问原始指针，可以使用positions.data()方法（不要尝试删除它，否则您的应用程序会因双重删除而崩溃）。可以使用positions.size()检查原子数。

正如评论中所提到的，如果Atoms类的唯一目的是存储双精度但不添加任何其他操作，那么只需忘记它并直接使用std::vector<double>。

Void指向类对象的指针：在函数内初始化

1 个答案: