Arrays 将列表转换为老式的双精度数组_Arrays_Memory_C++ Cli_New Operator

Arrays 将列表转换为老式的双精度数组

arrays memory c++-cli

Arrays 将列表转换为老式的双精度数组,arrays,memory,c++-cli,new-operator,Arrays,Memory,C++ Cli,New Operator,我正在为一些需要老式数组作为参数的硬件使用DLL。我使用Visual C++快件2010。例如，它可能有 bool-dll函数（双*array1，双*array2，int-array1length，int-array2length）我试图将所有这些都隔离在一个单例类中，以便在单例类之外的所有东西都使用列表和数组。这意味着我有一堆包装函数，它们接受列表，然后将它们转换为double[]以传递给DLL 因此，我使用下面的helper函数将列表转换为double[]。问题是指向double的指针以

我正在为一些需要老式数组作为参数的硬件使用DLL。我使用Visual C++快件2010。例如，它可能有

bool-dll函数（双*array1，双*array2，int-array1length，int-array2length）
我试图将所有这些都隔离在一个单例类中，以便在单例类之外的所有东西都使用列表和数组。这意味着我有一堆包装函数，它们接受列表，然后将它们转换为double[]以传递给DLL
因此，我使用下面的helper函数将列表转换为double[]。问题是指向double的指针以未定义的形式从函数中出来
bool MySingleton::AdaptList(List<double> ^myList, double *myDouble) {

if(myDouble)
    delete(myDouble);

myDouble = new double[myList->Count];

for(int k=0; k<myList->Count; k++) {
    myDouble[k] = myList[k];
}
return true;
} // AdaptList from List to Double*

bool MySingleton:：adaptelist（List^myList，double*myDouble）{
如果（myDouble）
删除（myDouble）；
myDouble=新的双精度[myList->Count]；
for（int k=0；kCount；k++）{
myDouble[k]=myList[k]；
}
返回true；
}//将列表从列表调整为双精度*

在我的代码中，我执行以下操作：
double *oldschool;
List<double>^ myList;
myList = gcnew List<double>;
// a bunch of myList.Add( ) calls to add the data

bool success = AdaptList(myList, oldschool);

// eventually, delete oldschool

double*oldschool；
列表^myList；
myList=gcnewlist；
//一组myList.Add（）调用来添加数据
bool success=adapterlist（myList，oldschool）；
//最终，删除旧学校

使用调试器，在adapterlist函数中，oldschool
准确地保存它所需要的内容。当AdapterList返回控件时，oldschool
显示未定义
bool MySingleton::AdaptList(List<double> ^myList, double *myDouble) {

if(myDouble)
    delete(myDouble);

myDouble = new double[myList->Count];

for(int k=0; k<myList->Count; k++) {
    myDouble[k] = myList[k];
}
return true;
} // AdaptList from List to Double*

为什么它超出了范围
谢谢
 您需要将双指针传递给MySingleton:：adapterlist
成员函数：
bool MySingleton::AdaptList(List<double> ^myList, double **myDouble) {
  if(*myDouble) delete(*myDouble);
  *myDouble = new double[myList->Count];
  for(int k = 0; k < myList->Count; ++k) (*myDouble)[k] = myList[k];
  return true;
} // AdaptList from List to Double*

bool MySingleton:：adaptelist（List^myList，double**myDouble）{
如果（*myDouble）删除（*myDouble）；
*myDouble=新的双精度[myList->Count]；
对于（int k=0；kCount；++k）（*myDouble）[k]=myList[k]；
返回true；
}//将列表从列表调整为双精度*

或对指针的引用：
bool MySingleton::AdaptList(List<double> ^myList, double *&myDouble) {
  if(myDouble) delete myDouble;
  myDouble = new double[myList->Count];
  for(int k = 0; k < myList->Count; ++k) myDouble[k] = myList[k];
  return true;
} // AdaptList from List to Double*

bool MySingleton:：adaptelist（List^myList，double*&myDouble）{
如果（myDouble）删除myDouble；
myDouble=新的双精度[myList->Count]；
对于（int k=0；kCount；++k）myDouble[k]=myList[k]；
返回true；
}//将列表从列表调整为双精度*

原因：您在成员函数bool MySingleton:：adapterlist
中通过值而不是引用传递“myDouble”指针。您需要向MySingleton:：adapterlist
成员函数传递双指针：
bool MySingleton::AdaptList(List<double> ^myList, double **myDouble) {
  if(*myDouble) delete(*myDouble);
  *myDouble = new double[myList->Count];
  for(int k = 0; k < myList->Count; ++k) (*myDouble)[k] = myList[k];
  return true;
} // AdaptList from List to Double*

bool MySingleton:：adaptelist（List^myList，double**myDouble）{
如果（*myDouble）删除（*myDouble）；
*myDouble=新的双精度[myList->Count]；
对于（int k=0；kCount；++k）（*myDouble）[k]=myList[k]；
返回true；
}//将列表从列表调整为双精度*

或对指针的引用：
bool MySingleton::AdaptList(List<double> ^myList, double *&myDouble) {
  if(myDouble) delete myDouble;
  myDouble = new double[myList->Count];
  for(int k = 0; k < myList->Count; ++k) myDouble[k] = myList[k];
  return true;
} // AdaptList from List to Double*

bool MySingleton:：adaptelist（List^myList，double*&myDouble）{
如果（myDouble）删除myDouble；
myDouble=新的双精度[myList->Count]；
对于（int k=0；kCount；++k）myDouble[k]=myList[k]；
返回true；
}//将列表从列表调整为双精度*

原因：您在成员函数bool MySingleton:：adapterlist
中通过值而不是引用传递“myDouble”指针。您需要向MySingleton:：adapterlist
成员函数传递双指针：
bool MySingleton::AdaptList(List<double> ^myList, double **myDouble) {
  if(*myDouble) delete(*myDouble);
  *myDouble = new double[myList->Count];
  for(int k = 0; k < myList->Count; ++k) (*myDouble)[k] = myList[k];
  return true;
} // AdaptList from List to Double*

bool MySingleton:：adaptelist（List^myList，double**myDouble）{
如果（*myDouble）删除（*myDouble）；
*myDouble=新的双精度[myList->Count]；
对于（int k=0；kCount；++k）（*myDouble）[k]=myList[k]；
返回true；
}//将列表从列表调整为双精度*

或对指针的引用：
bool MySingleton::AdaptList(List<double> ^myList, double *&myDouble) {
  if(myDouble) delete myDouble;
  myDouble = new double[myList->Count];
  for(int k = 0; k < myList->Count; ++k) myDouble[k] = myList[k];
  return true;
} // AdaptList from List to Double*

bool MySingleton:：adaptelist（List^myList，double*&myDouble）{
如果（myDouble）删除myDouble；
myDouble=新的双精度[myList->Count]；
对于（int k=0；kCount；++k）myDouble[k]=myList[k]；
返回true；
}//将列表从列表调整为双精度*

原因：您在成员函数bool MySingleton:：adapterlist
中通过值而不是引用传递“myDouble”指针。您需要向MySingleton:：adapterlist
成员函数传递双指针：
bool MySingleton::AdaptList(List<double> ^myList, double **myDouble) {
  if(*myDouble) delete(*myDouble);
  *myDouble = new double[myList->Count];
  for(int k = 0; k < myList->Count; ++k) (*myDouble)[k] = myList[k];
  return true;
} // AdaptList from List to Double*

bool MySingleton:：adaptelist（List^myList，double**myDouble）{
如果（*myDouble）删除（*myDouble）；
*myDouble=新的双精度[myList->Count]；
对于（int k=0；kCount；++k）（*myDouble）[k]=myList[k]；
返回true；
}//将列表从列表调整为双精度*

或对指针的引用：
bool MySingleton::AdaptList(List<double> ^myList, double *&myDouble) {
  if(myDouble) delete myDouble;
  myDouble = new double[myList->Count];
  for(int k = 0; k < myList->Count; ++k) myDouble[k] = myList[k];
  return true;
} // AdaptList from List to Double*

bool MySingleton:：adaptelist（List^myList，double*&myDouble）{
如果（myDouble）删除myDouble；
myDouble=新的双精度[myList->Count]；
对于（int k=0；kCount；++k）myDouble[k]=myList[k]；
返回true；
}//将列表从列表调整为双精度*

原因：您在成员函数bool MySingleton:：adapterlist
中通过值而不是引用传递“myDouble”指针，每当您需要指向数组的非托管指针时，如果您可以从中获取，则始终值得考虑。它将临时将数组固定在内存中，以便在本机代码使用它时无法移动它。大概是这样的：
  List<double>^ list = gcnew List<double>;
  //...
  pin_ptr<double> p = &list->ToArray()[0];
  NativeFunctionTakesDoublePointer(p);

List^List=gcnewlist；
//...
pin_ptr p=&list->ToArray（）[0]；
NativeFunctionTakesDoublePointer（p）；

如果NativeFunction（）存储指针，则无法使用它，因为当p
变量超出范围时，数组将被取消固定。
每当需要指向数组的非托管指针时，如果可以从中获取，则始终值得考虑。它将临时将数组固定在内存中，以便在本机代码使用它时无法移动它。大概是这样的：
  List<double>^ list = gcnew List<double>;
  //...
  pin_ptr<double> p = &list->ToArray()[0];
  NativeFunctionTakesDoublePointer(p);

List^List=gcnewlist；
//...
pin_ptr p=&list->ToArray（）[0]；
NativeFunctionTakesDoublePointer（p）；

如果NativeFunction（）存储指针，则无法使用它，因为当p
变量超出范围时，数组将被取消固定。
每当需要指向数组的非托管指针时，如果可以从中获取，则始终值得考虑。它将临时将数组固定在内存中，以便在本机代码运行时无法移动该数组