Tri sur des mêmes structures de taille différentes

Bonjour,

Je suis actuellement bloqué sur un problème de tri avec des structures.

Voilà mon problème:

J'ai une structure Image contenant plusieurs membres, l'un d'entre eux étant un tableau représentant des pixels, de taille indéfini à la compilation.

J'ai un algorithme de tri qui tourne sur le tableau d'image (donc un tableau de structure), selon un critère qui est lui même un paramètre de la structure, et je souhaiterai pouvoir faire, par exemple:

1
2
3

tmp = tableau[0];// etat 1 de tableau 0
tableau[0] = tableau[1]; //etat 2 de tableau 0
tableau[1] = tmp; // tableau 1 = etat 1 de tableau 0

Sauf que la taille des deux structures est différentes, étant donné que j'ai un tableau de pixels que j'alloue dynamiquement, et dont la taille change pour chaque image. Donc ma méthode précédente ne marche pas.

En cherchant un peu, je suis tombé sur le principe de deep copy, mais cela ne semble pas être exactement ce que je cherche..

Auriez vous une solution ?

Merci d'avance !

Si ton tableau est dynamique, tu ne mémorises que le pointeur dans ta structure, donc toutes tes structures ont la même taille. Je ne vois pas bien quel est le problème.

EDIT : Pour un peu étayer, voici un bête programme avec une structure ayant un tableau dynamique :

 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
45
46

#include <stdlib.h>
#include <stdio.h>

struct S {
    int **tab;
    int w;
    int h;
};

void allocate_s(struct S *s, int w, int h, int v) {
    s->w = w;
    s->h = h;
    s->tab = malloc(sizeof *s->tab * h);
    int i = 0;
    for(; i < h; ++i) {
        s->tab[i] = malloc(sizeof *s->tab[i] * w);
        int j = 0;
        for(; j < w; ++j)
            s->tab[i][j] = v;
    }
}

void print(const struct S *s) {
    int i = 0;
    for(; i < s->h; ++i) {
        int j = 0;
        for(; j < s->w; ++j)
            printf("%d ", s->tab[i][j]);
        printf("\n");
    }
}

int main(void) {
    struct S s1, s2, tmp;
    allocate_s(&s1, 10, 3, 0);
    allocate_s(&s2, 5, 2, 1);
    print(&s1);
    print(&s2);
    tmp = s1;
    s1 = s2;
    s2 = tmp;
    printf("-----\n");
    print(&s1);
    print(&s2);
    return 0;
}

En le compilant et le lançant (gcc -Wall -Wextra test.c && ./a.out), tu peux observer que le swap s'est fait sans broncher. C'est ça qui est beau avec les tableaux dynamiques.

Une remarque en passant, peut-être que je me plante complètement.

Tu parles de tri. Donc, cette procédure d'échange, tu vas la lancer plein de fois. Si tu tries un ensemble de 1000 structures, tu vas appeler cette procédure d'échange 20000 ou 50000 fois ou même plus.

Tu as peut-être intérêt à dupliquer ta structure, en gardant juste un pointeur vers ton image. Tu tries ta structure, qui dot donc être maintenant de taille fixe si j'ai tout suivi. Et une fois le tri fini, tu relances une étape pour récupérer tes images.