Discussion :

[ethan007]

Bonsoir à tous,
j'ai (encore) un petit problème avec une fonction qui doit lire un tableau de char* et formater avec sscanf pour stocker les bons coefficients dans une matrice. voici le code (j'ai simplifié pour faire apparaitre juste l'érreur de segmentation)

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
45
46
 
/*
*NOTE:
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define NBL 10
#define NBC 3
/*
*  Reads data from a file
*  @param nom_fichier: the file's name
*  @return the file content in a char*
*/
int** alloc_tab_2_D(int nbre_lig, int nbre_col);
int main(int argc, char *argv[]){
char *var = "10 3\n1 2 3\n4 5 6\n7 8 9\n 1 2 3\n4 5 6\n7 8 9\n1 2 3\n4 5 6\n7 8 9\n1 2 3";
 int i, j;
 int **tab_2_d = alloc_tab_2_D(NBL, NBC);
 int current_offset = 5;
    for( i = 0; i < NBL; i++)
    {
        for(j = 0; j < NBC; j++)
        {
            //La valeur à recuperer se trouve toujours à un indice paire, les indices impaires sont les espaces et les \n
            /*CONTENT EX:3 3\n1 2 3\n4 5 6\n7 8 9\0
              INDICES EX:012_3456789.............*/
 
            sscanf(&var[current_offset], "%d", &tab_2_d[i][j]);
            printf("|%d, i= %d j= %d OFF = %d\n", tab_2_d[i][j], i, j, current_offset);
 
            current_offset +=2;//skip spaces and /n
 
        }
    }
}
int** alloc_tab_2_D(int nbre_lig, int nbre_col){
    int i=0,j=0;
    int** tab_2_d = (int**)malloc(nbre_lig * sizeof(int));
    for(i = 0; i < nbre_lig; i++)
    {
        tab_2_d[i] = (int*)malloc(nbre_col * sizeof(int));	
    }
 
    return tab_2_d; 
}

Mais à chaque fois j'obtiens une erreur de segmentation quand l'indice i vaut 5 et j vaut 2 !. Quelqu'un peut -il m'aider?

[dalfab]

Bonjour,

tab_2_d c'est l'adresse de pointeurs, ce sont donc des pointeurs qu'il faut allouer d'où ligne 39
int** tab_2_d = malloc( nbre_lig * sizeof(*int) );

[ethan007]

Bonjour , merci pour la réponse, en réalité je me disait que la taille d'un pointeur est inférieure à la taille de l'entier lui même raison pour laquelle il faut les utiliser, alors que c'est tout le contraire, je viens justement d'afficher leurs tailles et la taille du pointeur fait le double (8octetcs) de la taille de l'entier! paradoxe?? les pointeurs étaient censé être moins gourmands en mémoire non?

[dalfab]

les pointeurs étaient censé être moins gourmands en mémoire non?

Moins gourmand que quoi?
La taille d'un pointeur est directement imposée par l’architecture processeur. Sur un système 64 bits un pointeur fait 8 octets (taille d'un mot d'adresse), c'est incontournable. Un entier devrait aussi faire 8 octets sur ces processeurs (taille d'un mot de donnée), mais certains compilateurs pour économiser des octets décident d'un int sur 4 et d'un long sur 8 octets.

[Sve@r]

Bonjour

en réalité je me disait que la taille d'un pointeur est inférieure à la taille de l'entier lui même raison pour laquelle il faut les utiliser...les pointeurs étaient censé être moins gourmands en mémoire non?

Fausse idée. Ou du moins, idée mal comprise à l'origine, et ensuite transformée et enfin restituée totalement à l'ouest de sa signification première.

En dehors de son utilisation permettant à une fonction F d'aller modifier une variable située hors de son espace de nom (la fonction F doit recevoir l'adresse de cette variable qu'elle stockera dans un pointeur), un pointeur est juste un raccourci permettant d'aller directement, lors de l'utilisation des tableaux, à une donnée D plus rapidement qu'un accès classique.

Exemple de base

Code c :

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

1
2
3
char *phrase="Hello World";
size_t i;
for (i=0; phrase[i] != '\0'; i++) printf("%c", phrase[i]);

Dans cet exemple, chaque accès à phrase[i] se traduira par un placement sur le début du tableau puis un calcul de décalage de "i" positions. Ici ce calcul est donc fait deux fois mais évidemment ça peut monter dans d'autres algorithmes.

Afin d'aller plus vite, on passe alors par un pointeur intermédiaire que l'on positionnera sur la bonne case à chaque itération.

Code c :

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

1
2
3
char *phrase="Hello World";
char *pt;
for (pt=phrase; *pt != '\0'; pt++) printf("%c", *pt);

Ici, le pointeur "pt" évolue avec la boucle est reste toujours positionné sur le bon caractère. Il n'y a plus besoin de calculer phrase[i] puisque "pt" est positionné sur ce caractère.

Bon, ici sur un tableau de char, la différence est minime (en réalité elle est imperceptible). Mais si tu commences à manipuler des tableaux de grosses structures dans des algorithmes un peu complexes (tris et autres conneries de ce genre), tu commenceras à sentir la différence.

Donc des pointeurs judicieusement créés permettent à ton code d'aller plus vite mais ne sont certainement pas moins gourmands en mémoire. En fait c'est même souvent plutôt le contraire car un pointeur est une seconde variable vers une donnée déjà accessible à l'origine par une première variable. Mais aujourd'hui la mémoire on en a, ce qui compte c'est plutôt c'est la rapidité...

sizeof(*int)

Ce ne serait pas plutôt sizeof(int*) ???

[Bousk]

je me disait que la taille d'un pointeur est inférieure à la taille de l'entier lui même [...] les pointeurs étaient censé être moins gourmands en mémoire non?

Même si c'était vrai, le pointeur n'a d'utilité que pour pointer sur quelque chose.
Et ce quelque chose doit bien exister quelquepart...
Ton pointeur, c'est juste un truc en plus pour accéder à la variable, donc de la mémoire en plus nécessaire.