Discussion :

[o2pubcy9]

Bonjour, je m'initie à la programmation de tableaux en C et je rencontre un problème. Je sais que mon problème vient soit de:
1) j'essaye d'accéder à un indice de tableau plus grand que la taille du tableau.
2) j'ai un mauvais pointeur (un pointeur qui ne pointe pas sur un objet valide) et j'essaye d'utiliser une méthode ou accéder aux données de cet objet via le pointeur (ou simplement le déréférencer)
Le programme me renvoie erreur mémoire savez-vous ou ce trouve mon erreur svp ?
Voici le programme en question :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
typedef int tabint[100];
 
#include <stdio.h>
int main(tab[])
{
    int i=0;
    for (i=0; i<99; i++){
        tab[i]=0;
    }
    printf("Tableau répertoriant les différentes températures de la journée!,aujourd'hui je suis très fatigué, par ailleurs je suis très malade ISSSSOOOOUUUUUUUUU\n");
    printf("%s", tab[i]);
    return 0;
}

Merci d'avance

[gerald3d]

Bonjour.

Houla , ça fait peur !!!

• Le typedef apparement tu ne comprends pas son principe. Tu viens de définir un synonyme pour le mot int qui par ailleurs est réservé.
• Le prototype de la fonction main(); est int main (int argc, char *argv[]);.

Revois la définition d’un tableau.

[o2pubcy9]

bonjour et merci de votre attention: et si je modifie le code de la manière suivante:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
typedef tabint[100] //tableau de 100 CASES
#include <stdio.h>
int main(int i, char*tab[])
{
    for (i=0; i<99; i++){
        tab[i]=0;
    }
    printf("Tableau répertoriant les différentes températures de la journée!,aujourd'hui je suis très fatigué, par ailleurs je suis très malade ISSSSOOOOUUUUUUUUU\n");
    printf("%s", tab[i]);
    return 0;
}

[Proteiforme]

Code :

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
 
/* 
Tableau de 100 cases de quoi ? int, double, char ?
De plus tu ne sais pas à quoi sert typedef je suppose ? Car là il ne sert à rien
*/
typedef tabint[100] 
 
#include <stdio.h>
 
int main(int i, char*tab[]) // Tout est à revoir concernant le main et le passage d'argument dans celui ci
{
  for (i=0; i<99; i++){ // Tu veux un tableau de 100 cases hors i < 99 donne seulement 99 cases initialisé à zéro et non 100
  tab[i]=0;
 
  }
 
  printf("Tableau répertoriant les différentes températures de la journée!,aujourd'hui je suis très fatigué, par ailleurs je suis très malade ISSSSOOOOUUUUUUUUU\n");
  /*
  Ton i t’amène dans une case du tableau non initialisé à cause de ton erreur du dessus
  Le %s c'est pourquoi au juste ? Si c'est du int c'est %d
  Mais comme je l'ai dis tu auras une valeur non initialisé de ton tableau a cause de ton erreur du dessus
  */
  printf("%s", tab[i]); // Est ici ton i vaudra toujours plus que le nombre de cases du tableau, c'est [i - 1] qu'il faudra indiquer, si je suis ta logique de codes
 
  return 0;
}

Au faite mieux vaut utiliser les balises représenter par # car là c'est pas terrible à la lecture, surtout que ton code est pas très lisible, heureusement qu'il y a peu de lignes
Pour finir tout ton code est faux et est à revoir

[gerald3d]

Commence par lire la faq sur le mot réservé typedef.

Ça te permettra de comprendre la première grosse erreur de ton code.

[o2pubcy9]

en suivant les instruction de la FAQ:

le int n'est pas à utiliser ici

du coup typedef X tabint[100] que puis-je mettre à la place du int pour définir tabint[100] comme un tableau svp ?( en Python ce serait np.array...)

[o2pubcy9]

du coup mon typedef ne sert a rien car je ne l'utilise pas dans la fonction principale...
il s'agit d'un tableau de 100 cases avec des entiers à l'intérieur

[gerald3d]

Il suffit simplement de déclarer ton tableau avec le type souhaité.

Code :

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

int tabint [100];

[o2pubcy9]

Code :

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

1
2
3
4
5
6
7
8
9
10
#include <stdio.h>
int main(tab[])
{
    for (i=0; i<100; i++){
        tab[i]=0;
    } //cases avec seulement des 0
    printf("Tableau répertoriant les différentes températures de la journée!,aujourd'hui je suis très fatigué, par ailleurs je suis très malade ISSSSOOOOUUUUUUUUU\n");
    printf("%d", tab[i]);
    return 0;
}

concernant le s j'avais mis un d: pour les valeurs entières mais dans un exemple vu sur internet j'avais vu un s...

[Proteiforme]

Ton tableau n'a toujours pas de type défini.
Ici j'indique juste quelques correction de ton code plus haut, sans typedef et en utilisant la boucle que tu avais écrite.
Mais faut revoir quelques bases je pense.

Pour ce que tu veux faire, plus haut "gerald3d" ta donner le prototype de main pour récupérer des valeurs : Le prototype de la fonction main(); est int main (int argc, char *argv[]);
Mais il y a du boulot je pense avant de voir ça

Code :

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
 
#include <stdio.h>
 
int main(void)
{
  int tab[100];
  int i = 0;
 
  for (i = 0 ; i < 100 ; i++) // Ici la boucle s’arrêtera quand i vaudra 100, en C l'indice d'un tableau commence à 0 est donc la dernière case de ton tableau est 99
  {
    tab[i] = 0;
  }
 
  printf("Tableau répertoriant les différentes températures de la journée!,aujourd'hui je suis très fatigué, par ailleurs je suis très malade ISSSSOOOOUUUUUUUUU\n");
  printf("%d\n", i);
  printf("%d\n", tab[i - 1]);
 
  return 0;
}

[o2pubcy9]

Bonjour, de cette façon je peux avoir un tableau avec que des zéros (avec tab[100]={0})

Code :

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

1
2
3
4
5
6
7
8
9
10
11
#include <stdio.h>
int main(void)
{
    int tab[100] = {0};
    printf("Tableau répertoriant les différentes températures de la journée!,aujourd'hui je suis très fatigué, par ailleurs je suis trèsb malade ISSSSOOOOUUUUUUUUU\n");
    int i;
    for (i=0; i<100; i++)
	printf("[%d]",tab[i]);
 
    return 0;
}

[Sve@r]

Bonjour

Bonjour, de cette façon je peux avoir un tableau avec que des zéros (avec tab[100]={0}

Oui, c'est ce que dit le cours pour un tableau initialisé partiellement. Le reste est alors initialisé à 0. Mais je n'ai pas encore compris quel était ton but. Avoir un tableau tout à 0 ???

en Python ce serait np.array...)

Ca c'est pas du Python. Ca pourrait être éventuellement un import de numpy renommé "np" à l'import mais c'est pas natif Python.

[o2pubcy9]

Bonjour, mon but était en effet d'avoir des tableaux rempli de 0 pour ensuite affecter à chaque valeur de tableau une température provenant d'un fichier texte..C'est la rraisonpour laquelle je voulais constuire un tel tableau.
Concernant le python je voulais dire qu'en important la bibliothque numpy tel que import numpy as np je peux concevoir des tableaux voir des matrice...

[Sve@r]

Bonjour, mon but était en effet d'avoir des tableaux rempli de 0 pour ensuite affecter à chaque valeur de tableau une température provenant d'un fichier texte.

Inutile. A quoi sert de mettre "0" dans une variable (ou dans un élément d'un tableau ou dans tous ses éléments) si 3 secondes plus tard tu lui mets une autre valeur ???
Les règles de la programmation C

• ne jamais lire une variable sans l'avoir remplie auparavant
• ne jamais remplir deux fois une variable sans la lire entre temps

[Médinoc]

Ces deux règles ne sont pas du tout sur le même plan!
La première est une règle de sécurité, indispensable.
La seconde est seulement une règle de performance, et franchement il vaut mieux initialiser deux fois une variable que prendre le risque de ne pas l'initialiser du tout (programmation défensive).

Un code qui lit jusqu'à cent entiers d'un fichier ressemblera à ça:

Code :

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
#include <stdio.h>
 
#define NB_ENTIERS 100
 
int main(void)
{
	int tab[NB_ENTIERS] = {0}; //Oui, je l'initialise. Je me moque de la performance ici.
	FILE* pFichier = fopen("c:\\repertoire\\monfichier.txt", "r");
	if(pFichier != NULL)
	{
		int entier_lu;
		size_t index = 0;
		while(index<NB_ENTIERS && fscanf(pFichier, "%d", &entier_lu) == 1)
		{
			tab[index] = entier_lu;
			index++;
		}
		if(index == NB_ENTIERS)
			printf("%zu entiers ont été lus, le tableau est plein.", index);
		else if(feof(pFichier))
			printf("La fin du fichier a été atteinte après avoir lu %zu entiers.\n", index);
		else
			printf("La lecture du fichier a été échoué après avoir lu %zu entiers.\n", index);
 
		fclose(pFichier);
	}
 
	//Traiter/afficher les entiers lus
}

[Sve@r]

La seconde est seulement une règle de performance, et franchement il vaut mieux initialiser deux fois une variable que prendre le risque de ne pas l'initialiser du tout (programmation défensive).

Ben j'ai beau chercher, je ne vois pas où il peut y avoir risque de ne pas l'initialiser du tout (programmation rigoureuse). Et le C a justement été écrit pour ceux qui veulent de la performance.

Le souci de la programmation défensive, c'est qu'on ne sait pas où l'arrêter. Si on initialise deux fois alors pourquoi pas 3 fois, 5 fois, 10 fois.
Donc non. Le C a été créé dans une philosophie "le programmeur sait ce qu'il fait" donc faisons pleinement en sachant pleinement ce qu'on fait.

Un code qui lit jusqu'à cent entiers d'un fichier ressemblera à ça:

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
#include <stdio.h>
 
#define NB_ENTIERS 100
 
int main(void)
{
	int tab[NB_ENTIERS] = {0}; //Oui, je l'initialise. Je me moque de la performance ici.
	FILE* pFichier = fopen("c:\\repertoire\\monfichier.txt", "r");
	if(pFichier != NULL)
	{
		int entier_lu;
		size_t index = 0;
		while(index<NB_ENTIERS && fscanf(pFichier, "%d", &entier_lu) == 1)
		{
			tab[index] = entier_lu;
			index++;
		}
		if(index == NB_ENTIERS)
			printf("%zu entiers ont été lus, le tableau est plein.", index);
		else if(feof(pFichier))
			printf("La fin du fichier a été atteinte après avoir lu %zu entiers.\n", index);
		else
			printf("La lecture du fichier a été échoué après avoir lu %zu entiers.\n", index);
 
		fclose(pFichier);
	}
 
	//Traiter/afficher les entiers lus
}

Je présume que le traitement du tableau en ligne 28 est une erreur de frappe de ton exemple. Parce que sinon ça voudrait dire que tu traites un tableau qui n'a pas forcément été rempli depuis le fichier (cf erreur d'ouverture) ce qui entrainerait une initialisation alors obligatoire (cf règle 2) qui détuit alors toute ton argumentation
D'autant plus que si le fichier n'a pas été ouvert tu n'as pas d'index !!!

Ceci dit, moi, conformément avec ma vision des choses, je l'écrirais plutôt ainsi:

Code :

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
#include <stdio.h>
 
#define NB_ENTIERS 100
 
int main(void) {
	int tab[NB_ENTIERS];	// Oui, je ne l'initialise pas car je sais ce que je fais et je sais gérer mon tableau
 
	FILE* pFichier = fopen("c:\\repertoire\\monfichier.txt", "r");
	if (pFichier == NULL) {
		// Gérer le cas (probablement quitter)
	}
 
	int *entier_lu;
	size_t index;
	for (entier_lu=tab, index=0; index < NB_ENTIERS && fscanf(pFichier, "%d", entier_lu) == 1; entier_lu++, index++);		// En plus j'évite 1) une indirection et 2) une recopie
 
	if (index == NB_ENTIERS)
		printf("%zu entiers ont été lus, le tableau est plein.", index);
	else if (feof(pFichier))
		printf("La fin du fichier a été atteinte après avoir lu %zu entiers.\n", index);
	else
		printf("La lecture du fichier a été échoué après avoir lu %zu entiers.\n", index);
 
	fclose(pFichier);
 
	//Traiter/afficher les "index" entiers lus
}

[Médinoc]

Je présume que le traitement du tableau en ligne 28 est une erreur de frappe de ton exemple. Parce que sinon ça voudrait dire que tu traites un tableau qui n'a pas forcément été rempli depuis le fichier (cf erreur d'ouverture) ce qui entrainerait une initialisation alors obligatoire (cf règle 2) qui détuit alors toute ton argumentation
D'autant plus que si le fichier n'a pas été ouvert tu n'as pas d'index !!!

C'est une erreur, non de frappe mais de programmation, et une vraie erreur, ce qui ne fait que renforcer mon argument!

Vu que j'ai mal envisagé le déroulement du programme (erreur du programmeur), si je n'avais pas initialisé le tableau, je risquais en effet de traiter un tableau non-initialisé! (d'ailleurs en effet, j'ai oublié d'avoir une variable "taille remplie" pour le tableau, hors du bloc if). La programmation défensive sert justement à protéger de ce genre de situation.

Par contre, il me vient à l'esprit un contre-argument: L'accès en lecture à une variable non-initialisée est très facile à détecter et signaler pour le compilateur! Malheureusement contrairement à des langages comme C# (où le compilateur doit détecter cela et remonter une erreur), il n'y a pas de telle spécification en C, et un appel naïf de gcc monProgramme.c ne signalera rien du tout vu que gcc ne donne aucun avertissement si l'utilisateur ne le lui demande pas explicitement (Visual C++ a au moins l'obligeance de choisir "warning level 3" par défaut, du moins depuis un projet Visual Studio).
Se fier au compilateur n'est donc pas la meilleure solution pour le C (et certainement pas la plus portable).

[Sve@r]

C'est une erreur, non de frappe mais de programmation, et une vraie erreur, ce qui ne fait que renforcer mon argument!

Vu que j'ai mal envisagé le déroulement du programme (erreur du programmeur), si je n'avais pas initialisé le tableau, je risquais en effet de traiter un tableau non-initialisé! (d'ailleurs en effet, j'ai oublié d'avoir une variable "taille remplie" pour le tableau, hors du bloc if). La programmation défensive sert justement à protéger de ce genre de situation.

Mon point de vue initial part du principe que le programmeur ne fait pas d'erreur. Effectivement s'il en fait, le truc explose en vol et il ne saura pas pourquoi (voire même n'explose pas en vol et donne des résultats non vérifiables). Mais si c'est ça alors faut pas qu'il fasse du C car le C n'accepte pas la programmation non rigoureuse.
C'est comme dans karaté kid (première version). Soit on fait du bon karaté, soit on n'en fait pas. Mais si on en fait à moitié en restant au milieu de la route comme un crapaud, alors tôt ou tard "crouich" comme crapaud.

[emixam16]

Ben j'ai beau chercher, je ne vois pas où il peut y avoir risque de ne pas l'initialiser du tout (programmation rigoureuse). Et le C a justement été écrit pour ceux qui veulent de la performance.

Je comprends ton point de vue mais je pense que je vais plus être d'accord avec Medinoc ce coup-ci

En fait, on ne fais pas forcément du C uniquement pour la performance. On peut en faire aussi :

• Parce que c'est un langage qui fait tout gérer manuellement donc qui peut permettre à un débutant de comprendre comment marche un ordinateur à assez bas niveau (ça ne serait pas possible avec Python par exemple).
• Parce que je programme pour un système qui ne connait que le C (et l'assembleur mais bon...) comme un Microcontrôleur, le noyau Linux, ...
• Parce ça permet de faire des programmes (relativement) portables
• ...

Ici, l'OP est clairement un débutant, avant de penser à la performance, il doit commencer par comprendre les mécanismes du C pour faire des programmes corrects.

L'optimisation pourra être apprise par la suite de son apprentissage, mais clairement on y est pas encore.

De plus, même pour un développeur expérimenté, je pense que c'est une erreur de vouloir optimiser les performances dès le début. C'est le meilleur moyen de se retrouver avec un code complexe, buggé et vulnérable. Comme dit l'autre: "Premature optimization is the root of all evil". Il me semble que les optimisations doivent être faites une fois que le code est relativement stable.

Et puis généralement, gagner quelques cycles processeur dans une fonction appelée une ou quelque fois n'a pas spécialement d’intérêt, c'est du temps développeur mal investi. Autant prendre un peu plus de temps à optimiser les fonctions critiques, quitte à ne pas se préoccuper du reste.

[Médinoc]

Au passage, les premiers langages informatiques qui m'aient été enseignés dans un cadre scolaire (En Section de Technicien Supérieur, option Informatique Industrielle, 2001-2003) étaient, pour autant que je m'en souvienne, C (en cours de "Système") et Assembleur pour architecture Motorola 68000 (en cours d'"Architecture").
La plupart des élèves ont débuté avec ça.* La programmation défensive a été inventée pour pallier aux manquements des langages bas niveau, parce que "on sait ce qu'on fait" est optimiste. Toi, tu embrasses ces manquements en partant du principe que si on fait du C, c'est qu'on est automatiquement un expert en programmation haute-performance.

*Même si personnellement, j'avais des années de BASIC Locomotive, suivi de BASIC pour calculatrices, derrière moi