tableau à dimension variable

**Phoenix_Blue** · 17/11/2006, 11h46

bonjour, j'essaye de faire un programme qui r'ealise la transformée d'ADAMAR,
en fait c'est l'histoire d'une matrice carrée d'ordre 2 puissance n générée à l'aide d'une matrice carée d'ordre 2 puissance n-1.

voila ma question: comment créer un tableau qui gere ça? j'ai essayé les pointeurs

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
int **TabOrdN, **TabOrd2N, ord;
for(int i=0;i<ord,i++)  for(int j=0;j<ord,j++)
{
  TabOrd2N[i][j]=TabOrdN[i][j];     TabOrd2N[i+ord][j]=TabOrdN[i][j];
  TabOrd2N[i][j+ord]=TabOrdN[i][j];     TabOrd2N[i+ord][j+ord]= -TabOrdN[i][j];
}

mais ca me donne des resultats bizzares ( ╝╝+Ê♣◘○♠♥•,♦☺Ã╚╔┼█)

**Faiche** · 17/11/2006, 11h56

t'as bien sur alloué toutes les cases de tes matrices ?

**Phoenix_Blue** · 17/11/2006, 12h00

c'est justement ça le probleme combien de cases allouer puisque la taille sera variable? je voudrais faire quelque chose de récurrent

**tintin72** · 17/11/2006, 12h05

Salut,

Je ne connais pas cet algoritme mais là déjà
les 2 boucles for cote à cote c pas trop bon, de même
que les déréférencement ??? des pointeurs.
Je suis d'ailleur étonné que ça compile!
Essaies plutôt un truc comme ça;

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
int **TabOrdN, **TabOrd2N, ord;
for(int i=0;i<ord,i++)  
{
  TabOrd2N[i][j]=TabOrdN[i][j];     
  TabOrd2N[i][j+ord]=TabOrdN[i][j];    
 
  for(int j=0;j<ord,j++)
  {
   TabOrd2N[i+ord][j]=TabOrdN[i][j];
   TabOrd2N[i+ord][j+ord]= -TabOrdN[i][j];
  }
}

je ne sais pas si c'est l'algo que tu cherche mais c plus clair.
Pour ce qui est des tableau redimensionnables je te conseillerais
d'utiliser plutôt les vector de la stl, il y aura moins de risque d'erreurs.

**Faiche** · 17/11/2006, 12h12

Envoyé par tintin72

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
int **TabOrdN, **TabOrd2N, ord;
for(int i=0;i<ord,i++)  
{
  TabOrd2N[i][j]=TabOrdN[i][j];     
  TabOrd2N[i][j+ord]=TabOrdN[i][j];    
 
  for(int j=0;j<ord,j++)
  {
   TabOrd2N[i+ord][j]=TabOrdN[i][j];
   TabOrd2N[i+ord][j+ord]= -TabOrdN[i][j];
  }
}

vous faites un concours la c'est ça ?

**Phoenix_Blue** · 17/11/2006, 12h20

je crois que ton algo fais la meme chose, c'est vrai que c'est plus clair, je vais essayer avec stl, merci..

**Faiche** · 17/11/2006, 12h36

Envoyé par akfp85

je crois que ton algo fais la meme chose, c'est vrai que c'est plus clair, je vais essayer avec stl, merci..

tu rigoles ? il n'a plus rien a voir, et surtout j est déclaré dans la deuxieme boucle.. C'est n'importe quoi ce qu'il a mis !

enfin bon, un type matrice c'est quand meme pas compliqué a réaliser si ?
si tu fais un int** TU DOIS L'ALLOUER, sinon ça saute.

je te conseille de prendre des cours sur les bases des pointeurs avant de te lancer dans tes calculs de matrice

**Luc Hermitte** · 18/11/2006, 01h19

Des réponses groupées...

Envoyé par akfp85

en fait c'est l'histoire d'une matrice carrée d'ordre 2 puissance n générée à l'aide d'une matrice carée d'ordre 2 puissance n-1.

voila ma question: comment créer un tableau qui gere ça? j

boost.uBLAS, Blitz++, MTL, newMat, ... comme d'hab quoi.

Pour les tableaux "rectangulaires" (pas matrices) -> boost.multi_array

Pour les tableaux "irréguliers" -> std::vector<std::vector<T> >

Pour les exercices -> cerveau - crayon - papier

voir faq :
http://c.developpez.com/faq/c/?page=...bleau_2D_alloc

La FAQ C (qui en plus ne gère pas les cas d'erreurs) pour gérer ces structures, c'est moyen ... en C++.

tu peux toujours réallouer avec realloc

Attention, realloc() est vicieux, si ça foire, cela retourne 0. Et il ne faut pas oublier de libérer la mémoire en passant par des temporaires...

Une fonction récursive est une fonction qui s'appelle...

@ Koala. Ton premier code à-la-C présente plusieurs problèmes
- il peut fuir si une erreur d'allocation survient en cours de redimensionnement
- Il fuit car sa libération de la structure initiale est partielle.

**koala01** · 18/11/2006, 01h44

Envoyé par Luc Hermitte

<snip>

Une fonction récursive est une fonction qui s'appelle...

Je voulais dire par là qu'elle pouvait tres facilement etre transformée en récursive si besoin était... j'aurais du le dire différemment (mea maxima culpa

)

Envoyé par Luc Hermitte

@ Koala. Ton premier code à-la-C présente plusieurs problèmes
- il peut fuir si une erreur d'allocation survient en cours de redimensionnement
- Il fuit car sa libération de la structure initiale est partielle.

De fait... Je mets correction ici, pour laisser la pertinence à ta remarque (mais où avais-je la tete

:oops )

Par contre, en relisant le code (qui n'avait pas été testé à la compilation, je viens, en plus, de remarquer quelques erreurs de syntaxe que je corrige partout

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
int** Agrandit(int** depart)
{
    try
    {
        int** tempo=new int*[taille+1];
        for(int i=0;i<taille;i++)
        {
             //allocation des colone, puis copie des éléments déjà connus
             tempo[i]=new int[taille+1]
             for(int j=0;j<taille;j++)
             {
                 tempo[i][j]=depart[i][j];
             }
             //déclaration de l'élément surnumeraire pour la ligne envisagée
             tempo[i][taille]= whatyouwant;
        }
    }
    //pour récupérer les différentes erreurs qui auraient pu survenir
    //(principalement les erreurs d'allocation)
    catch(...)
    {
         //l'affichage d'un message pourrait etre sympa, vraissemblablement
         // au travers de stc::cerr...
         // renvoie la matrice non modifiée
         return depart;
//NOTA: typiquement, new renvoie une exception de type 
// std::bad_alloc(), que l'on pourrait utiliser dans le catch 
// (sous la forme decatch(std::bad_alloc &e) ) mais il faut alors penser à 
//inclure le fichier d'entete <stdexcept>
    }
    // libération de la mémoire utilisée par la matrice de départ AVANT de
    // perdre l'adresse mémoire à laquelle elle commence
    for(int i=0;i<taille;i++)
    {
        //D'abord les colones
        int* supress=depart[i];
        delete[] suppress;
    }
    //puis les lignes
    delete[] depart;
    ++taille;
    return tempo;
}

**loufoque** · 18/11/2006, 10h04

Sauf que si c'est la première allocation qui produit une erreur, il faut pas libérer toutes les autres.
Le plus simple est de loin d'utiliser std::vector<int>.

**olive_le_malin** · 18/11/2006, 14h17

Bonjour,

et qu'est ce qu'en pense l'autur du message de toutes ces réponses ?

Au départ j'avais suggéré des réponses en utilisant des fonctions C, car le code donné laissait sous-entendre un besoin de comprendre ce qu'était l'allocation de tableaux 2D, et les pointeurs ...
avant de passer à l'utilisation des librairies C++, et des tableaux vector ...

Mais bon ... peut être me suis-je trompé ?
C'est clair que les vector seraient une bonne solution.

@+

tableau à dimension variable

C++

Vue hybride

Discussions similaires

Partager

Partager