返回数组虚拟模板函数的指针

Question

我想在一个虚函数中将数组返回给指针，该虚函数是模板类的派生类的成员。详细地，我的类定义是：

Sampler.h

#ifndef SAMPLER_H
#define SAMPLER_H

template <class T>
class Sampler
{
      public:
             virtual T getnumber()=0;
             virtual T* simulation(int n)=0;
};

class UniformSampler:public Sampler<double>
{
      public:
              virtual double getnumber();
              virtual double* simulation(int n);
              UniformSampler(double a=0.0, double b=1.0);

      private:
              double low_bound;
              double up_bound;
};
#endif

类Sampler是一个模板类，以便以后可以使用向量派生其他采样器。实现是：Sampler.cpp

#include "Sampler.h"

#include<iostream>
#include<cstdlib>
#include<cmath>
using namespace std;

//Uniform
UniformSampler::UniformSampler(double a, double b)
{
    low_bound=a;
    up_bound=b;
}

double UniformSampler::getnumber()
{
       int myrand=rand();
       while((myrand==0)||(myrand==RAND_MAX)){myrand = rand(); } //We want a number in (0, RAND_MAX).

       double myuni = myrand/static_cast<double>(RAND_MAX); //Create a number in (0,1).
       return low_bound + myuni*(up_bound-low_bound);
}

double* UniformSampler::simulation(int n){
    double simulations[n];
    for(int i=0; i<n; i++){
        simulations[i] = this->getnumber();
    }
    return simulations;
}

我的问题是，当我尝试在main()中调用此程序时，指针分配似乎无效。这是我的main.cpp：

#include <iostream>
#include <math.h>
#include <cstdlib>
#include <time.h>
using namespace std;

#include "Sampler.h"

int main(){
    srand(time(0));

    int n=10;
    double *unif = new double[n];
    UniformSampler uni;
    unif = uni.simulation(n);
    for ( int i = 0; i < n; i++ ) {
      cout << "*(p + " << i << ") : ";
      cout << *(unif + i) << endl;
    }
    delete[] unif;

    return 0;

}

当我运行它时，它不会打印unif指向的任何元素。我不明白那里出了什么问题。

Answer 1

[UniformSampler::simulation是两次错误的错误：

• [double simulations[n];使用VLA扩展，因此不符合C ++标准。
• 您将指针返回到局部变量，所以悬挂了指针。

解决方案：改用std::vector。

#include <vector>

template <class T>
class Sampler
{
public:
    virtual ~Sampler() = default;
    virtual T getnumber() = 0;
    virtual std::vector<T> simulation(int n) = 0;
};

class UniformSampler:public Sampler<double>
{
public:
    explicit UniformSampler(double a=0.0, double b=1.0);

    double getnumber() overrid;
    std::vector<double> simulation(int n) override
    {
        std::vector<double> res(n);
        for (auto& val : res){
            res = getnumber();
        }
        return res;
    }
private:
    double low_bound;
    double up_bound;
};