Question

这是发生错误的方法。这里的目标是在给定的小时间增量dt的基础上，基于模型颗粒（模型）生成一定数量的砂粒。 Grain是一个抽象类，因为它纯粹是虚方法，而且必须是这样。问题出现在

上

for(size_t a(0); a<vect.size(); ++a){
    vect[a] = new Grain(*modele);
}

没有这个初始化循环，向量返回所有相同的粒子，但我需要它们略有不同（Aleatoire类提供了必要的工具）。例如，如果我

for(size_t a(0); a<vect.size(); ++a){
    vect[a] = modele;
}

错误消失但返回的矢量包含所有相同的颗粒，它们都是来自设置循环的最后颗粒

std::vector<Grain*> Source::creation( std::vector<Grain*> grains, double dt){
vector<Grain*> vect; //vide par defaut

Aleatoire generateur(1);

//determiner nombre de grains a generer: DEBUT ALGO
double fraction = debit*dt; // fraction = debit "vrai", mais a priori non entier
int nombre(fraction);      // partie entière
fraction -= nombre;        // partie fractionnaire
// on ajoute 1 au hasard, proportionnellement à la partie fractionnaire :
if ( generateur.uniforme(0.0, 1.0) < fraction ) ++nombre;
//---FIN ALGO---
cout<<"Pour un pas de temps "<<dt<<" on genere "<<nombre<<" grains."<<endl;

double x, y, z, r;
vect.resize(nombre, nullptr);

for(size_t a(0); a<vect.size(); ++a){
    vect[a] = new Grain(*modele);
}
cout<< "APRES LA FONCTION RESIZE, la taille du tableau est : "<<vect.size()<<endl;

for(size_t i(0); i<nombre; ++i){
    (vect[i])->setPosition(position); //Le grain genere est genere a la position de la source
    x = generateur.gaussienne(vitesse_iMoyenne.getCoord_x(), ecart_typeVitesse);
//        cout<<"x = "<<setw(2)<<x<<" ";
    y = generateur.gaussienne(vitesse_iMoyenne.getCoord_y(), ecart_typeVitesse);
//        cout<<"y = "<<setw(2)<<y<<" ";
    z = generateur.gaussienne(vitesse_iMoyenne.getCoord_z(), ecart_typeVitesse);
//        cout<<"z = "<<setw(2)<<z<<" ";
    Vecteur3D v(x,y,z);
//        cout<<"Le nouveau vecteur vitesse est : "<<setw(2)<<v<<" "<<endl;
    vect[i]->setVitesse(Vecteur3D(x,y,z));
//        cout<<"Le vecteur vitesse copie est : "<<setw(2)<<vect[i]->getVitesse()<<" "<<endl;

    r = generateur.gaussienne(modele->getRayon(), ecart_typeRayon);
//        cout<<"Le nouveau rayon est : "<<setw(2)<<r<<" "<<endl;
    vect[i]->setRayon(abs(r));
//        cout<<"Le rayon copie est : "<<vect[i]->getRayon()<<" "<<endl;

//        cout<<"Affichage dans la methode, dans la boucle for : "<<endl;
//        cout<<setw(2)<<i<<" "<<*(vect[i])<<endl;
//        cout<<endl;
}

//    cout<<"Affichage dans la methode du vecteur de grains generes : "<<endl;
//    for(size_t j(0); j<vect.size(); ++j){
//        cout<<setw(2)<<j<<" "<<*(vect[j])<<endl;
//    }
//    cout<<endl;
return vect;  
}

这是Grain.hpp：

#ifndef Grain_hpp
#define Grain_hpp
#include "Vecteur3D.hpp"
#include "Dessinable.hpp"

class Grain : public Dessinable {
public:
Grain(Vecteur3D p={0.0,0.0,0.0}, Vecteur3D v={0.0,0.0,0.0}, double m =             1.0, double r = 1.0, Vecteur3D f = {0.0,0.0,0.0}, SupportADessin* support = nullptr );

virtual ~Grain();

double masse() const;

//eta_milieu est la constante de viscosite du milieu

double lambda() const; //coef de frottement fluide

void ajouteForce();

void bouger(double pas);

virtual void affiche(std::ostream& sortie) const ;

void setVitesse(Vecteur3D const& v);

void setPosition(Vecteur3D const& p);

void setRayon(double const& r);

Vecteur3D getPosition() const;

double getRayon() const;

Vecteur3D getVitesse() const;

Vecteur3D calcule_force() const;

virtual Vecteur3D* vecteurForce(Grain* grain) const =0;



//Methodes forces virtuelles

virtual void ajouteForce(Obstacle* obstacle) = 0;

virtual void ajouteForce(Grain* grain) = 0;

virtual void ajouteForce(Vecteur3D) = 0;

//Dessinable


Grain(SupportADessin* vue)
: Dessinable(vue)
{}

virtual void dessine() override;

protected:

Vecteur3D position;

Vecteur3D vitesse;

double m_volumique;

double rayon;

Vecteur3D force;

};
std::ostream& operator<<(std::ostream& sortie, Grain const& g) ;
#endif /* Grain_hpp */

Answer 1

在您的情况下，您似乎想要克隆现有对象。如果您知道要复制的此对象的类型，则使用复制构造函数。假设以下抽象基类及其具体子类：

class AbstractBase {
public:
    virtual void print() = 0;
};

class ConcreteClass : public AbstractBase {
public:
    ConcreteClass(int initVal) : testVal(initVal) {};
    virtual void print() { cout << "ConcreteClass with testVal " << testVal << endl; }
    int testVal;
};

int main() {    
    ConcreteClass *cObj = new ConcreteClass(5);
    AbstractBase* copyOfCObj = new ConcreteClass(*cObj);
    copyOfCObj->print(); // output: ConcreteClass with testVal 5
    return 0;
}

请注意，代码未指定单个复制构造函数，因此编译器将生成默认复制构造函数（实际克隆所有数据成员）。如果这还不够，请定义自己的复制构造函数;但这是一个单独的主题。

如果您不知道要克隆的对象的具体类型（例如，因为您只有一个指向它的指针，并且此指针在其他地方被分配了一个对象），则需要一些自定义代码（例如，参见，Copying a Polymorphic object in C++）。据我所知，C ++确实没有提供内置的克隆＆＃34; -functionality，除非你知道这个对象的具体类型;所以你必须提供你自己的＆＃34; clone＆＃34; -functionality，它带来了这种类型的信息：

class AbstractBase {
public:
    virtual AbstractBase* clone() = 0;
    virtual void print() = 0;
};

class ConcreteClass : public AbstractBase {
public:
    ConcreteClass(int initVal) : testVal(initVal) {};

    virtual ConcreteClass* clone() {
        return new ConcreteClass(*this);
    }

    virtual void print() { cout << "ConcreteClass with testVal " << testVal << endl; }

    int testVal;
};

int main() {
    AbstractBase* modele = new ConcreteClass(10);
    AbstractBase* copyOfModele = modele->clone();
    copyOfModele->print(); // output: ConcreteClass with testVal 10
    return 0;
}

xcode c ++错误：分配一个抽象类类型的对象＆＃39; Grain＆＃39;

1 个答案: