Création de Tableau Dynamique d'Objets Dynamiques en C++

Je sais comment créer un tableau d'objets dynamiques.

Par exemple, le nom de la classe est en Stock.

Stock *stockArray[4];
for(int i = 0 ; i < 4;i++)
{
   stockArray[i] = new Stock();
}

Comment avez-vous changer de ce tableau dynamique d'objets dynamiques?

Ce que j'ai essayé:

Stock stockArrayPointer = nouveau Stock stock[4];

Il ne fonctionne pas et le message d'erreur est "La valeur du Stock** ne peut être utilisé pour initalize une entité de type Stock.

Deuxième question est la suivante, après la création de tableau dynamique d'objets dynamiques, quelle est la syntaxe pour accéder à l'pointeurs dans le tableau.

Maintenant, j'utilise stockArray[i] = new Stock(); Comment ce changement?

Besoin de conseils à ce sujet...

pourquoi ne pas u utiliser des vecteurs?
Qu'entendez-vous par tableau dynamique d'objets dynamiques? Pouvez-vous développer?
un tableau qui est dans le tas et les choses, dans le tableau, sont également dans le tas...
Pourquoi ne pas simplement de Stock *stockArray = nouveau Stock[4];

OriginalL'auteur lakesh | 2013-11-30

arrays c++dynamic-memory-allocation

6

Si vous êtes à l'aide de c++, alors vous ne devriez pas réinventer la roue, il suffit d'utiliser vecteurs:
```
#include <vector>

std::vector< std::vector< Stock > > StockVector;

//do this as many times as you wish
StockVector.push_back( std::vector< Stock >() );

//Now you are adding a stock to the i-th stockarray
StockVector[i].push_back( Stock() );
```
Edit:

Je n'ai pas compris votre question, si vous voulez juste avoir et tableau de tableaux alloués sur le tas juste utiliser:
```
Stock** StockArrayArray = new Stock*[n]; //where n is number of arrays to create
for( int  i = 0; i < n; ++i )
{
    StockArrayArray[i] = new Stock[25];
}

//for freeing
for( int i = 0; i < n; ++i )
{
    delete[] StockArrayArray[i];
}
delete[] StockArrayArray;
```
juste tableaux. voulez juste utiliser des tableaux.
Tout simplement parce que a[i] est équivalent à *(a+i) ne signifie pas que ces deux types de données sont étroitement liées, ni qu'ils peuvent être appelés "sucre syntaxique". Veuillez observer les C FAQ sur les tableaux et les pointeurs : c-faq.com/aryptr, en particulier c-faq.com/aryptr/practdiff.html
c'est l'exigence dans mon programme. c'est pourquoi. hope u comprendre..
Alors je ne peut que se sentir triste pour votre travail et votre professeur.
Je crois que vous avez mal interprété votre affectation. Un tableau alloué avec new sont déjà stockées sur le tas, et sa taille peut être ajustée au moment de l'exécution( par opposition à statiquement déclaré tableaux, qui ont une compilation de taille fixe, et sont stockés dans la pile ).

OriginalL'auteur akaltar
4

Le type d'une variable à une dynamique de tableau est un pointeur vers le premier objet de la matrice. Vous voulez un tableau de alloués dynamiquement des objets, donc un tableau de pointeurs de Stock, de sorte que votre variable est un pointeur vers un pointeur de Stock:
```
int n = 4; //dynamic size of the array;
Stock** stockArray = new Stock*[n];
for (int i = 0; i != n; ++i)
{
    stockArray[i] = new Stock();
}
```
et en la libérant:
```
for (int i = 0; i != n; ++i)
{
    delete stockArray[i];
}
delete[] stockArray;
```
OriginalL'auteur Frederic Lachasse
2
```
Stock* stockArrayPointer = new Stock [4];
```
ne fonctionne que si les Actions de la classe a un zéro argument du constructeur
si elle n'a pas de zéro argument constructeur vous ne pouvez pas créer un tableau d'objets dynamiques dynamiquement

vous pouvez comme l'a dit de créer un tableau d'objet dynamique avec un tableau statique comme
```
Stock stockArrayPointer[4]={Stock(args),Stock (args)};
```
mais la syntaxe
```
Stock* stockArrayPointer=new Stock[4]{Stock(args),Stock (args)}; does not hold
```
ou comme le dit

utiliser des vecteurs...

les vecteurs sont la mémoire allouée sur le tas

si le vecteur est une allocation dynamique
```
vector<Stock> V;
V.push_back(Stock(args));
```
ou
```
V.push_back(new Stock(args));
```
La raison pour laquelle
```
Stock* stockArrayPointer=new Stock[4]{Stock(args),Stock (args)};
```
ne tient pas
est parce que
cela signifie
vous êtes à l'aide de l'opérateur new incorrectement

OriginalL'auteur mono

J'ai fait quelque chose qui a fonctionné parfaitement:

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

class student {
    string name;
    int age;
    int roll;
    public:
        student() {
            name="";
            age=0;
            roll=0;
        }
        student (string n, int a, int r) {
            name=n;
            age=a;
            roll=r;
        }
        void show_details (); 
};
void student::show_details() {
    cout << "Name: " << name << "\n";
    cout << "Age: " << age << "\n";
    cout << "Roll No: " << roll << "\n";
}
int main() {
    string a; int b, c, n;
    cin >> n;
    student **obj;
    obj=(student**)malloc(n*sizeof(student*));
    for (int i=0; i<n; i++) {
        cin >> a;
        cin >> b;
        cin >> c;
        obj[i]=new student(a,b,c);
    }
    for (int i=0; i<n; i++) {
        obj[i]->show_details();
    }
    for (int i=0; i<n; i++) free (obj[i]);
    free (obj);
}

Oui... j'ai utilisé pointeur de pointeur pour le tableau de la partie, et cela a fonctionné parfaitement pour une taille variable tableaux.

OriginalL'auteur Soumyadeep Thakur

Vous devez vous connecter pour publier un commentaire.