Discussion :

[Redgard]

Bonjour,

Je suis en train de tester certaines de mes fonctions séparément, et j'ai souvent la même erreur de compilation (c4700), qui revient avec les pointeurs.
C'est une fonction permettant de déclarer un pointeur char, prenant en paramètre un pointer char et un entier.

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
30
31
32
33
34
35
#include <stdlib.h>
#include <stdio.h>
 
#pragma warning(disable : 4996)
 
// ========== FUNCTION ==========
void SizeAllocatorTxt(char *tab, int sizeTab)
{
	tab = (char *)malloc(sizeof(char) * (sizeTab + 1));
}
 
// ========== TEST ==========
void PauseApp(void);
 
int main() {
	char *word;
	int size = 5;
 
	SizeAllocatorTxt(word, size);
 
	printf("the size is %u\n", sizeof(*word));
 
	PauseApp();
 
	return 0;
}
 
// ========== SECONDARY ==========
// fonction de pause du programme - demande une validation pour continuer
void PauseApp(void) {
	do {
		fputs("\n> Appuyez sur 'Entree' pour terminer le programme. \n", stdout);
	} while (getchar() != '\n');
 
}

J'ai fait différentes recherches sur internet pour essayer de comprendre d'où vient le problème, mais ce n'est pas très concluant.
J'ai essayé de trouver si une méthode de déclaration d'un "pointer char" était recommandé, mais rien de concluant.
J'ai aussi essayé de déclaré mon pointeur NULL par défaut char *word = NULL; / char *word = nullptr;, mais je me retrouve avec d'autres erreurs, donc c'est pas très concluant.

Bref, voilà je ne sais pas trop :/

Cordialement,
Red'

[jlliagre]

Le compilateur n'est pas content car tu passes une variable non initialisée (word) à la fonction SizeAllocator.

Ce qu'il ne dit pas c'est qu'en plus, telle qu'elle est écrite, cette fonction n'a pas d'autre effet que de créer une fuite mémoire.

Le programme affiche aussi la taille d'un caractère, qui est forcément de 1 par définition.

J'imagine que ce que tu veux faire c'est:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
...
void SizeAllocatorTxt(char **tab, int sizeTab)
{
	*tab = malloc(sizeTab + 1);
}
 
...
	SizeAllocatorTxt(&word, size);
 
	printf("the size is %d\n", sizeTab+1);
...

[Redgard]

Ce que je veux faire c'est attribuer au pointeur une taille équivalent à plusieurs caractères (d'où le sizeof(char)), afin de pouvoir y stocker une string, et ensuite vérifier si l'allocation dynamique de mémoire a été faite convenablement.
Dans mes essaies, j'avais essayé d'y mettre plusieurs caractères mais ça ne marchait pas.

[jlliagre]

sizeof(char) est égal à 1 par définition, ça ne sert donc à rien d'exécuter cette instruction.

sizeof(pointeur) renvoie la taille du pointeur, 32 ou 64 bit suivant ton environnement, pas la taille de la mémoire allouée vers laquelle le pointeur pointe.

Il n'y a pas de méthode portable ou fiable pour connaitre cette taille, c'est à toi de le savoir puisque c'est toi qui a fait l'allocation.

Pour vérifier si une allocation s'est bien passée, tu compare le résultat avec NULL, si c'est le cas, l'allocation a échoué.

De plus, ton pointeur ne pointait vers rien du tout dans la fonction main puisqu'il n'était pas initialisé.

[Redgard]

sizeof(pointeur) renvoie la taille du pointeur, 32 ou 64 bit suivant ton environnement, pas la taille de la mémoire allouée vers laquelle le pointeur pointe.

Okay mais pour ce que j'en aie lu/vu sur internet, il y a une différence entre sizeof(pointeur) et sizeof(*pointeur).

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
 
#pragma warning(disable : 4996)
 
// ========== FUNCTION ==========
void SizeAllocatorTxt(char tab[], int sizeTab)
{
	tab = (char *)malloc(sizeof(char) * (sizeTab + 1));
}
 
// ========== TEST ==========
void PauseApp(void);
 
int main() {
	char* pWord = NULL;
	int size = 5;
 
	SizeAllocatorTxt(pWord, size);
 
	strcpy(pWord, "cinq");
 
	if (pWord == NULL)
	{
		puts("Echec de l'allocation de memoire.\n");
 
		PauseApp();
		return 0;
	}
 
	printf("the word is %s\n", pWord);
 
	free(pWord);
 
	PauseApp();
	return 0;
}
 
// ========== SECONDARY ==========
// fonction de pause du programme - demande une validation pour continuer
void PauseApp(void) {
	do {
		puts("\n> Appuyez sur 'Entree' pour terminer le programme. \n");
	} while (getchar() != '\n');
 
}

Quand j'essaie de déclare mon pointeur comme ceci char* pWord = NULL;, J'ai de temps à autre des erreurs de compilation
Là ça compile, mais le programme crash au lancement. Je présume que c'est lié à strcpy(pWord, "cinq");

[jlliagre]

Okay mais pour ce que j'en aie lu/vu sur internet, il y a une différence entre sizeof(pointeur) et sizeof(*pointeur).

Non, ce qui peut être différent c'est la taille d'un type et la taille d'un pointeur vers ce type, mais ce n'est pas ce que j'ai écrit.

La taille d'un pointeur (c'est à dire la taille d'une adresse) et la taille de l'adresse d'une adresse, c'est kif-kif...

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
...
	SizeAllocatorTxt(pWord, size);
 
	strcpy(pWord, "cinq");
 
	if (pWord == NULL)
	{
		puts("Echec de l'allocation de memoire.\n");
 
...

Quand j'essaie de déclare mon pointeur comme ceci char* pWord = NULL;, J'ai de temps à autre des erreurs de compilation

Hmm, tu utilises un compilateur aléatoire ?

Normalement, il y a erreur ou il n'y a pas d'erreur, pas des fois oui, des fois non.

Là ça compile, mais le programme crash au lancement. Je présume que c'est lié à strcpy(pWord, "cinq");

Tu présume bien. Tu écris dans pWord avant de vérifier que tu as droit de le faire...

Je t'ai donné la solution dans ma première réponse. Pourquoi tu ne reprend pas le code ?

Tu n'as manifestement pas compris la différence entre ce que contient une adresse et l'adresse elle-même.