fonction fusion et passe par référence le tableau résultat

bonjour, j'ai réalisé une fonction de fusion de deux tableaux. Lorsque je retourne le tableau résultat de la fonction ça fonctionne mais lorsque je veux passer le tableau résultat par référence il y a une erreur pendant la compilation. Pouvez vous m'aider?

voici le code ou je retourne le tableau

main

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <stdio.h>
#include "fonctions.h"
 
int main(int argc, const char * argv[]) {
 
    int tTab1[5] = {1,3,5,7,8};
    int tTab2[4] = {2,3,4,9};
    int *pTab = NULL;
    int dTaille1 = 5;
    int dTaille2 = 4;
    int dI;
 
    pTab = tabFusion(tTab1, tTab2, dTaille1, dTaille2);
 
    for (dI = 0; dI < dTaille1+dTaille2; dI++) {
        printf("%d", pTab[dI]);
    }
    return 0;
}

fonction

Code:

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
47
48
49
#include "fonctions.h"
#include "stdlib.h"
 
int * tabFusion (int tTab1[], int tTab2[], int dTaille1, int dTaille2)
{
    int dPosTab1 = 0;
    int dPosTab2 = 0;
    int dPosTab3 = 0;
    int *pTab;
 
    pTab = malloc(10 * sizeof(int));
 
    if (pTab == NULL)
    {
        puts("erreur allocation");
        exit(EXIT_FAILURE);
    }
 
    while ((dPosTab1 < dTaille1) && (dPosTab2 < dTaille2))
    {
        if (tTab1[dPosTab1] < tTab2[dPosTab2])
        {
            pTab[dPosTab3] = tTab1[dPosTab1];
            dPosTab3++;
            dPosTab1++;
        }
        else
        {
            pTab[dPosTab3] = tTab2[dPosTab2];
            dPosTab3++;
            dPosTab2++;
        }
    }
 
    // Si un tab n'est pas terminé
 
    while (dPosTab1 < dTaille1)
    {
        pTab[dPosTab3] = tTab1[dPosTab1];
        dPosTab1++;
        dPosTab3++;
    }
    while (dPosTab2 < dTaille2) {
        pTab[dPosTab3] = tTab2[dPosTab2];
        dPosTab2++;
        dPosTab3++;
    }
    return pTab;
}

Voici le code ou je passe par référence le tableau et ou j'ai une erreur

main

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <stdio.h>
#include "fonctions.h"
 
int main(int argc, const char * argv[]) {
 
    int tTab1[5] = {1,3,5,7,8};
    int tTab2[4] = {2,3,4,9};
    int *pTab = NULL;
    int dTaille1 = 5;
    int dTaille2 = 4;
    int dI;
 
    tabFusion(tTab1, tTab2, &pTab, dTaille1, dTaille2);
 
    for (dI = 0; dI < dTaille1+dTaille2; dI++) {
        printf("%d ", pTab[dI]);
    }
    return 0;
}

fonction

Code:

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
47
48
#include "fonctions.h"
#include "stdlib.h"
 
void tabFusion (int tTab1[], int tTab2[], int **pTab, int dTaille1, int dTaille2)
{
    int dPosTab1 = 0;
    int dPosTab2 = 0;
    int dPosTab3 = 0;
 
    *pTab = malloc(10 * sizeof(int));
 
    if (*pTab == NULL)
    {
        puts("erreur allocation");
        exit(EXIT_FAILURE);
    }
 
    while ((dPosTab1 < dTaille1) && (dPosTab2 < dTaille2))
    {
        if (tTab1[dPosTab1] < tTab2[dPosTab2])
        {
            *pTab[dPosTab3] = tTab1[dPosTab1];
            dPosTab3++;
            dPosTab1++;
        }
        else
        {
            *pTab[dPosTab3] = tTab2[dPosTab2];
            dPosTab3++;
            dPosTab2++;
        }
    }
 
    // Si un tab n'est pas terminé
 
    while (dPosTab1 < dTaille1)
    {
        *pTab[dPosTab3] = tTab1[dPosTab1];
        dPosTab1++;
        dPosTab3++;
    }
    while (dPosTab2 < dTaille2)
    {
        *pTab[dPosTab3] = tTab2[dPosTab2];
        dPosTab2++;
        dPosTab3++;
    }
}

j'ai le message d'erreur suivant:

thread1:EXC_BAD_ACCESS(code=1,address=0x1) à la ligne 28 de la fonction.

Le problème vient de la priorité de l'opérateur "*" sur l'opérateur "[]". L'opérateur "[]" est prioritaire sur "*". Lorsque tu fais "*pTab[indice]", cela signifie d'aller à l'adresse pointée par "pTab[indice]".
Dans ce genre de cas, pour simplifier la syntaxe, je fais :
Code:

1 2 3 4 5 6 7 8 ma_fonction( int ** p_p_tab ) { ... int * pTab = * p_p_tab; pTab[ indice ] = ... ... }

Sinon, c'est (*ptab)[i]