Copie de tableau

Programmation
1

Bonsoir,
tout se passe dans le code suivant comme si temp subissait les modifications du tableau d’origine.
En effet, au lieu d’avoir le tableau trié dans l’ordre inverse, je récupère une moitié dans l’ordre et l’autre étant l’image de la première (987654321 donne 123454321 au lieu de 123456789)

if (!ordreCroissant){ temp = donneesAAjouter.clone(); System.out.println("temp.length : "+temp.length); for (i=0 ; i < donneesAAjouter.length ; i++) for (j=0 ; j < nbChamps ; j++) donneesAAjouter[i][j]=temp[donneesAAjouter.length-i-1][j]; }

Au passage, .clone() paraît superflu

2

Par ailleurs, le code suivant fonctionne :

[code]if (!ordreCroissant){
temp = new String [donneesAAjouter.length][nbChamps];
for (i=0 ; i < donneesAAjouter.length ; i++)
for (j=0 ; j < nbChamps ; j++)temp[i][j] = donneesAAjouter[i][j];

				for (i=0 ; i < donneesAAjouter.length ; i++)
					for (j=0 ; j < nbChamps ; j++)
						donneesAAjouter[i][j]=temp[donneesAAjouter.length-i-1][j];
}[/code]

Mais il doit exister une méthode qui copie les valeurs et non la référence au tableau ?

3

Alors je le dis un peu au feeling, mais clone va copier ta première dimension de tableau, du coup tu va avoir 2 tableaux (donneesAAjouter et temp) qui référencent les même nbChamps. Il faut appliquer le clone sur tout les tableaux de second niveau. Tu peut aussi utiliser un tableau à une seule dimension, c’est plus performant.

4

Merci MisterFreez.

Mais c’est exact, j’avais lu ça qqpart. Il n’y aurait rien pour les tableaux de tableaux ?

Tu veux dire une ArrayList<> ? Parce que je ne vois pas comment faire tenir mes données dans une dimension …

5

Un tableau 2D c’est juste un tableau 1D avec des index recalculés… :wink:

[code]int tableau1[4][4] = { { 0, 1, 2, 3 },
{ 4, 5, 6, 7 },
{ 8, 9, 10, 11 },
{ 12, 13, 14, 15 } };
int tableau2[16] = { 0, 1, 2, 3,
4, 5, 6, 7,
8, 9, 10, 11,
12, 13, 14, 15 };

Pour tout x et y compris entre 0 et 3 inclus :
tableau1[y] == tableau2[(x * 4) + y][/code]

Après si ton tableau d’origine est pas orthogonal (si toutes les dimensions 2 sont pas de la même taille) forcément ça se complique…

6

Et pour expliquer pourquoi c’est plus performant, il y a deux choses :
[ul]
[li]dans la version à 2 dimensions, tu as 2 indirections (à partir d’un pointeur tu calcul un premier offset qui te donne un autre pointeur sur le quel tu calcul un second offset pour trouver ta donnée)[/li]
[li]dans la version à 2 dimensions, tu as pleins de tableaux qui peuvent être très dispersé en mémoire, ça contribue à la fragmentation de celle-ci, c’est nuisible pour les performances[/li][/ul]

7

Cela dit, c’est vrai en Java mais pas dans d’autres langages… Eg. en C il n’y a aucune différence, le compilo s’occupe de lisser tout ça.

Comme l’ami blaisoth n’a pas spécifié de langage (même si on est pas dupes…). :wink:

8

J’étais pas au courant. Ils le font pour autre chose que des tableaux static, genre ça ?

int *tab [10];
for (int i = 0; i < 10; ++i) {
    tab[i] = (int*)malloc(10*size(int));
}

Ça ça m’étonnerais parce qu’une partie du tableau est dans la pile et l’autre dans le tas.

et pour ce qui est des tableaux à 2 dimensions entièrement dans le tas avec :

int *tab = (int**)malloc(10*sizeof(int*));
for (int i = 0; i < 10; ++i) {
    tab[i] = (int*)malloc(10*size(int));
}

Soit dis en passant il y a assez peu de langages qui permettent d’appeler les méthodes length et clone sur les tableaux, Java et peut être C#.

9

J’ai résisté mais je ne peux pas :slightly_smiling: , tant pis

Tu veux dire carré, orthogonal n’a pas de sens ici…

Parailleurs, si ton tableau est NxP, tu fais

tab.(i).(j) ↔ tabligne.(P*i+j)

Pas plus compliqué que ça.

10

@MisterFreez : non effectivement je pensais uniquement aux tableaux statiques. Évidemment pour des tableaux alloués dynamiquement avec malloc ça fonctionne pas.

@fran.b : j’admets, “orthogonal” n’est pas forcément le bon terme. Mais je ne pensais ni à NN ni à NP, mais à Nx? (la deuxième dimension est variable selon l’index sélectionné dans la première dimension). Autrement dit, ni carré ni rectangulaire :

[0] a b c [1] a b c d e [2] a b ...