Pointeurs et les fonctions propres en C - Applications résolues


1)Exemple en déclarant et en utilisant des variables de pointeur. Le transfert est effectué entre des adresses d'emplacements de mémoire, avec maintien simultané et les valeurs retenues.
#include<stdio.h>
void main()
{
int a=1;	/* a est un emplacement de mémoire pour les éléments de type int sur 
		deux octets, qu’on a initialisé avec la valeur 1 */
 
int* b;     	/* b variable pointeur vers le type int, capable de retenir 
		des addresses des autres variables de type spécifié */
		// déclarer un pointeur

b=&a;		/* dans l’adresse b on retien l’adresse de location de    
		memoire (de la variable) a, donc b devient l’adresse de la location de la memoire a */
	
	printf("Val a= %d\t Val b= %d\n\n", a,*b);
	printf("l’adresse a= %p\t l’adresse b= %p", &a, b);
	
	getchar();
	int k;
	scanf("&d", k);
}

2) Exemple en déclarant et en utilisant des variables de pointeur. Le transfert se fera uniquement entre les valeurs retenues à certains emplacements de mémoire.
#include<stdio.h>s
void main()
{
int a=1;	/*a est un emplacement de mémoire pour les éléments de type int sur deux octets,
		initialisé avec la valeur 1 */
 
int x=55;
 
int *b;		/* b est une variable pointeur vers le type int, capable de retenir des adresses d’autres 
		variables du type spécifié */
		// déclarer un pointeur
	
b=&x;		// initialiser le pointeur
		/* dans l’adresse b conserver emplacement d'adresse mémoire (de la  variable) x,  
		donc b devient emplacement d'adresse mémoire x */
 
*b = a;		/* transfert est effectué entre des valeurs; 
		Pour l’adresse retenue de la valaur b on attribute la valeur retenue in a */
	
printf("Val a= %d\t Val b= %d\n\n", a,*b);
printf("l’adresse a= %p\t l’adresse b= %p", &a, b);
 
getchar();
int k;
scanf("&d", k);
}

3) Transmission d'informations par le biais des adresses. Échange sera entre les adresses des emplacements de mémoire et d'échange d'éléments auxiliaires est également une adresse.
#include<stdio.h>
void main()
{
	int *a, *b, *c;
	int x=55;
	int y=66;
 
	a=&x;	// initialiser a
	b=&y;	// initialiser b
	
	printf("Input a: ",a);
	scanf("%d", a);
	printf("Input b: ",b);
	scanf("%d", b);
 
	printf("\nAvant d'échange: \n");
	
	printf("\tVal a= %d\tVal b= %d\n\n", *a,*b);
	printf("\tl’adresse a= %p\tl’adresse b= %p\n", a, b);
 
	// l’échange
	c=a;
	a=b;
	b=c;
 
	printf("\nApres l’echange: \n");
	
	printf("\tVal a= %d\tVal b= %d\n\n", *a,*b);
	printf("\tl’adresse a= %p\tl’adresse b= %p\n", a, b);
 
	getchar();
	int k;
	scanf("&d", k);
}

4) Transmission d'informations par le biais des adresses. Échange sera entre les adresses des emplacements de mémoire et l'élément auxiliaire de l'échange n'est pas une adresse (un pointeur).
#include<stdio.h>
void main()
{
	int *a, *b, c;
	int x=2, y=5;
 
	a=&x;	//initialser a
	b=&y;	//initialiser b

	printf("Entrer a: ",a);
	scanf("%d", a);
	printf("Entrer b: ",b);
	scanf("%d", b);
 
	printf("\nAvant d’echange: \n");
	
	printf("\tVal a= %d\tVal b= %d\n\n", *a,*b);
	printf("\tl’adresse a= %p\tl’adresse b= %p\n", a, b);
	
	//l’echange

	c=*a;	// transfert entre des valeurs, car l’expression &c=a; ne serait pas valide
	a=b;
	b=&c;
 
	printf("\nApres l’echange: \n");
	
	printf("\tVal a= %d\tVal b= %d\n\n", *a,*b);
	printf("\tl’adresse a= %p\tl’adresse b= %p\n", a, b);
 
	getchar();
	int k;
	scanf("&d", k);
}

5) Transmission d'informations par le biais des adresses. L'Échange sera entre les valeurs conservées dans les emplacements de mémoire de ces adresses et l'élément auxiliaire d'échange sera une adresse (un pointeur).
#include<stdio.h> 
void main()
{
	int *a, *b, *c;
	int x=2, y=5, z=7;
 
	a=&x;	//initialiser a
	b=&y;	//initialiser b
	c=&z;	//initialiser c

	printf("Entrer a: ",a);
	scanf("%d", a);
	printf("Entrer b: ",b);
	scanf("%d", b);
 
	printf("\nAvant l’echange: \n");
	
	printf("\tVal a= %d\tVal b= %d\n\n", *a,*b);
	printf("\tl’adresse a= %p\tl’adresse b= %p\n", a, b);
	
	//L’echange

	*c=*a;	// transfert entre des valeurs
	*a=*b;
	*b=*c;
 
	printf("\nApres l’echange: \n");
	
	printf("\tVal a= %d\tVal b= %d\n\n", *a,*b);
	printf("\tl’adresse a= %p\tl’adresse b= %p\n", a, b);
 
	getchar();
	int k;
	scanf("&d", k);
}

6) Transmission d'informations par le biais des adresses. L'Échange sera entre les valeurs conservées dans les emplacements de mémoire de ces adresses et l'élément auxiliaire d'échange ne sera pas une adresse (un pointeur).
#include<stdio.h>
void main()
{
	int *a, *b, c;
	int x=2, y=5;
 
	a=&x;	//initialiser a
	b=&y;	//initialiser b
	
 
	printf("Entrer a: ",a);
	scanf("%d", a);
	printf("Entrer b: ",b);
	scanf("%d", b);
 
	printf("\nAvant l’echange: \n");
	
	printf("\tVal a= %d\tVal b= %d\n\n", *a,*b);
	printf("\tl’adresse a= %p\tl’adresse b= %p\n", a, b);
	
	//l’echange

	c=*a;		// transfert entre les valeurs
	*a=*b;
	*b=c;
 
	printf("\nApres l’echange: \n");
	
	printf("\tVal a= %d\tVal b= %d\n\n", *a,*b);
	printf("\tl’adresse a= %p\tl’adresse b= %p\n", a, b);
 
	getchar();
	int k;
	scanf("&d", k);
}

7) L'arithmétique des pointeurs. Va écrire une routine en C pour des exemples arithmétiques pointeur, cas illustrent l'opération d'incrémentation / décrémentation, ou de montage / diminution des valeurs.
#include<stdio.h>
void main()
{
 
	int a[]={10,20,30,40,50}; /* j'ai declaré une chaine d'elements de type int, 
					initialisée avec les valeurs du lot */
	int* b;			// b est pointeur de type int
	b=a;			//dans l’adresse b on reticent la chaine a
/* on fait comme ça le transfert, car c'est une adresse par son nom, l'adresse du premier élément de la chaine */
 
	for(int i=1; i<=5; i++)
	{
	printf("%d\n", *b);	/* b-par transfer test l’adresse du premier element,
				le resultat de cette expression sera le premier element de la chaine, 10*/
	b++;			//on fait le passage au suivant element de la chaine
	}
 
		// on retourne avec le pointeur curseur de la chaine dans la premiere position
		b-=5;	//sau b=b-5
		printf("Premier element de la chaine: %d\n", *b);
 
		/* on garde la position de pointeur dans la chaine, 
		si on veut afficher le troisieme element de la chaine*/
		printf("Le trosieme element de la chaine: %d\n", *(b+2));
 
 
	getchar();
	int k;
	scanf("&d", k);
}

8) L'arithmétique des pointeurs. Va écrire une routine en C pour des exemples arithmétiques pointeur là où, 0cas illustrent l'opération d'incrémentation / décrémentation, respectivement Addition / soustraction sur une chaîne en sous-chaînes de son usinage.
#include<stdio.h>void main()
{
	char a[]="ABCDE"; //la chaine a reticent une chaine de 5 caractheres
	char* b;
	b=a;
 
	for(int i=1;i<=5;i++)
	{
		printf("%s\n",b); /* une chaine est une adresse, et ce message va afficher la sous-chene, 
					en commencant avec la premiere position, "ABCDE" */
		b++;
	}
 
	b-=5;
	printf("la sous-chene, commencant avec la premiere position: %s\n",b);
	printf("la sous-chene, en commencant avec la troisieme position: %s",b+2);
 
 
	getchar();
	int k;
	scanf("&d", k);
}

9) Allocation de mémoire dynamique à travailler avec des variables de pointeur. Pour élaborer un programme qui échangé deux valeurs réelles en utilisant des variables de pointeur.
#include<stdio.h>
#include<stdlib.h> //sau, #include<alloc.h>
void main()
	{
	double *a,*b,*c;
 
	/* Nous créons des dynamiques variables, les variables qui garderont 
		la mémoire étendue dans une zone  HEAP */
 
	a=(double*)malloc(sizeof(double));	/* dans la zone HEAP beaucoup d’espace pour memoire 
							d’une variable de type double */
	printf("Entrer a: "); scanf("%lf",a);
 
	b=(double*)malloc(sizeof(double));
	printf("Entrer b: "); scanf("%lf",b);
	c=a;					/* car il n'est pas nécessaire d'allouer de la mémoire dynamique, 
						car c recoit par transfert de a */
	a=b;
	b=c;
	printf("Apres l’echange: a= %.2lf\tb= %.2lf",*a,*b);
 
	/* meme si dans ce cas il n’est pas necessaire, car une variable dynamique
	N’est plus variable a la fin de l’execution de la function, pourtant, 
	on peut choisir les variables créées désallocation explicite dinamic */
 
	free(a);
	free(b);
 
	getchar();
	int k;
	scanf("&d", k);
}

10) Le transfert des parametres par la valeur.
#include<stdio.h>
void modifica(int x, int y, int z)
{
	printf("Valeurs initiales en fonction: %d %d %d\n",x,y,z);	//1 2 3
	x+=10;
	y+=10;
	z+=10;
	printf("Valeurs initiales en fonction: %d %d %d\n",x,y,z); 	//11 12 13
}
 
void main()
{
	int a=1,b=2,c=3;
	printf("Valeurs initiales dans programme: %d %d %d\n",a,b,c);	//1 2 3
	modifique(a,b,c);
	printf("Valeurs finales dans programme: %d %d %d\n",a,b,c); 	//1 2 3

	getchar();
	int k;
	scanf("&d", k);
}

11) La transfert des parametres par valeur.
#include<stdio.h>
int somme (int s)
{
	for(int i=0; i<=10; i++)
	s=s+i;
	return s;
}
 
void main()
{
	int s=0;
	somme(s);
	printf("La somme est: %d", s);	//La somme est 0

	getchar();
	int k;
	scanf("%d",k);
}

12) Le transfert des parametres par adresse.
#include<stdio.h>
void modifique(int* x, int* y, int* z)
{
	printf("Valeurs initiales dans fonction: %d %d %d\n",*x,*y,*z);	//1 2 3
	*x+=10;
	*y+=10;
	*z+=10;
	printf("Valeurs finales dans fonction: %d %d %d\n",*x,*y,*z);	//11 12 13
}
void main()
{
	int a=1,b=2,c=3;
	printf("Valeurs initiales dans programme: %d %d %d\n",a,b,c);	//1 2 3 changer(&a,&b,&c);
	printf("Valeurs finales dans programme: %d %d %d\n",a,b,c);	//11 12 13

	getchar();
	int k;
	scanf("%d",k);
}

13) Le transfert des parametres pas l’adresse.
#include<stdio.h>void somme(int* s)
{
	for(int i=0; i<=10; i++)
		*s=*s+i;
}
void main()
{
	int s=0;
	somme(&s);
	printf("Somme est: %d\n", s);		//Somme est 55 

 
	getchar();
	int k;
	scanf("%d",k);
}

14) Ecrire un programme pour échanger le contenu de deux variables qui peuvent retenir des valeurs réelles. Le programme va définir des fonctions de lecture et d'affichage d'un nombre réel et d'une fonction propre pour l'échanger du contenu des variables, avec le résultat restant dans aussi à l'extérieur de l'exécution de la fonction.
#include<stdio.h>
// lire une variable réelle
void lire(float* x, char c)
{
	printf("Entrer %c: ", c); 
	scanf("%f", x);
} 
//affichage d’un contenu d’une variable reelle
void affichage(float x, char c)
{
	printf("La valeur du %c est: %.2f\n", c,x); 
} 
//la fonction d’echange du contenu des deux variables reelles
void echange(float *x, float *y)
{ 
	float z;
	z=*x;
	*x=*y;
	*y=z;
} 
void main()
{
	float a, b;
	lire(&a,'a');
	lire(&b,'b');
 
	printf("\nINITIAL:\n");
	affichage(a,'a');
	affichage(b,'b');
 
	printf("\napres l’echange:\n");
	echange(&a,&b);
	affichage(a,'a');
	affichage(b,'b');
 
	getchar();
	int k;
	scanf("%d",k);
}

15) Ecrire un programme qui va realiser l'échange du contenu de deux variables qui peuvent contenir des valeurs réelles. Le programme va définir des fonctions de lecture et d'affichage d'un nombre réel, et d'une fonction propre d'échange du contenbu des variables, le résultat restant dans non-exécution de la fonction. Les variables sont déclarées globales, déclarées par un type standard défini.
#include<stdio.h>
float a,b;
//la fonction de lire les deux variables 
void lire()
{
	printf("Entrer a: "); 
	scanf("%f", &a);
	printf("Entrer b: "); 
	scanf("%f", &b);
}
//fonction d’affichage
void affichage()
{
	printf("Les valeurs sont: a=%.2f, b=%.2f\n", a, b); 
}
//fonction d’echange
void echange()
{ 
	float c;
	c=a;
	a=b;
	b=c;
}
void main()
{	
	lire(); 
	affichage(); 
	printf("\n"); 
	echange(); 
	affichage(); 
	getchar();
	int k;
	scanf("%d",k);
}

16) Ecrire un programme qui va realiser l'échange du contenu de deux variables qui peuvent contenir des valeurs réelles. Le programme va définir des fonctions de lecture et d'affichage d'un nombre réel, et d'une fonction propre d'échange du contenbu des variables, le résultat restant dans non-exécution de la fonction. Les variables sont déclarées globales, déclarées par un type pointer vers un type reel.
#include<stdio.h>
#include<stdlib.h>
float*a,*b;
void allocation()
{
	a=(float*)malloc(sizeof(float));
	b=(float*)malloc(sizeof(float));
}
void lire()
{
	allocation();
	printf("dati a: ");
	scanf("%f",a);
	printf("dati b: ");
	scanf("%f",b);
}
void affichage()
{
	printf("Les valeurs sont: a=%.2f, b=%.2f\n",*a,*b);
}
void echange()
{
	float c;
	c=*a;
	*a=*b;
	*b=c;
}
void main()
{
	lire();
	affichage();
	printf("\n");
	echange();
	affichage();
 
	getchar();
	int k;
	scanf("%d",k);
}

17) Qu'est-ce qu'il va afficher, le programme ce-dessous?
#include<stdio.h> 
int a,b;
int f(int m,int n)
{
	m=n+b;
//printf("\nm=%d", m);

	n+=1;
//printf("\nn=%d", n);

	return n+b+m;
//printf("\nm=%d", n+b+m);
}
void main()
{
	a=6;
	b=5;
	printf("\n%d %d ",a,b);
	printf("\n%d ",f(a,b));
	printf("\n%d %d ",a,b);
 
	getchar();
	int k;
	scanf("%d",k);
}
 
Réponse: 6 5 21 6 5 

18) Il est demandé d'écrire une fonction qui calcule la somme des chiffres d'un numéro. Fonction écrira le prototype (le déclarative différenciée de la finale).
#include<stdio.h>
// dans ce cas, le résultat sera envoyé par type de résultat
int somme(int); // somme des chiffres d'un nombre entier

void main()
{
	int n, somme_chiffres=0, nr_invers=0;
	printf("Entrer n: ");
	scanf("%d",&n);
 
	somme_chiffres=somme(n);
	printf("\nLa somme des chiffres est: %d", somme_chiffres);
 
	getchar();
	int k;
	scanf("%d",k);
}
 
/* somme des chiffres d'un nombre entier:
Pour le nombre 523 calculez la somme des chiffres
523 : 10 = 52 rest 3
Somme intermediaire: 0+3=3
52 : 10 = 5 reste 2
Somme intermediaire: 3+2=5
5 : 10 = 0 rest 5
Somme finale: 5+5=10
*/
 
int somme(int n)
{
	int s=0;
	while (n)
		{
			s=s+n%10;
			n/=10;
		}
	return s;
}
/* L’inverse d’un nombre entier:
Pour le nombre 523 on veut connaitre l’inverse
523 : 10 = 52 reste 3
Nombre inverse intermediaire: 0*10+3=3
52 : 10 = 5 reste 2
Nombre inverse intermediaire: 3*10+2=32
5 : 10 = 0 rest 5
Nombre inverse finale: 32*10+5=325
*/

19) En utilisant une fonction à faire un programme qui calcule l'expression suivante: (1+ ½ + 1/3+ ¼ +…+1/n)^n pour n nombre entier introduit du clavier.
#include<stdio.h>
#include<math.h>

float somme (int n)
{
float s=0;
float p=1;
for(int i=1; i<=n; i++)
	{
		p=1/(float)i;
		s=s+p;
	}
s=pow(s,n); 
return s;
}
void main()
{
	int n;
 
	printf("\nEntrer n: ");
	scanf("%d", &n);
	printf("\n\tLe resultat de l’expression est: %.2f", somme(n));
 
	getchar();
	int k;
	scanf("%d", k);
}

20) Realisez un programme qui calcule par l’intermede de deux fonctions Le cmmdc et le cmmmc des deux nombres introduits du clavier.
#include <stdio.h>
#include <math.h>

int cmmdc (int n, int m)
{
 while(n!=m)
	{ 
		if(n>m)
			n=n-m;
		else
			m=m-n;
	}
return n;
}
 
int cmmmc (int n, int m)
{
	int z;
	z=(n*m)/cmmdc(n,m);
	return z;
}
 
void main()
{
	int n,m;
	printf("\nEntrer n: ");
	scanf("%d", &n);
 
	printf("\nEntrer m: ");
	scanf("%d", &m);
 
printf("\nCmmdc este: %d", cmmdc(n,m));
printf("\nCmmmc este: %d", cmmmc(n,m));
 
getchar();
int k;
scanf("%d", k);
}

21) Pour effectuer l'addition et la multiplication de deux nombres réels en utilisant des variables de type pointeur.
#include<stdio.h>
void main()
{
	int a;
	printf("Entrer a: ");
	scanf("%d", &a);
 
	int b;
	printf("Entrer b: ");
	scanf("%d", &b);
 
	int* n; //declaration du pointeur
	int* m;	// declaration du pointeur
	
	n=&a;	//initializer le pointeur
	m=&b;	//initializer le pointeur

 
	printf("\nLa somme est: %d", *n+*m);
	printf("\nLe produit est: %d", *n * *m);
 
	getchar();
	int k;
	scanf("%d", k);
}

22) Écrire une fonction qui reçoit comme paramètre la longueur d'arête d'un carré et retourne sa surface et une fonction qui retourne la diagonale.
#include<stdio.h>
#include<math.h>
float longueur (int n)
{
	float surface;
	surface=n*n;
	return surface;
}
 
float diagonale (double n)
{
	double diag;
	diag=sqrt((n*n)+(n*n));	
	return diag;
}
 
void main()
{
int n;
printf("Entrer n: ");
scanf("%d", &n);
 
printf("\nLa surface du carré est: %.2f", longueur(n));
printf("\nDiagonale du carré: %.2lf", diagonale(n));
 
getchar();
int k;
scanf("%d", k);
}

23) Écrire une fonction qui reçoit 3 paramètres de type réel, la signification des longueurs de 3 segments. La fonction renvoie 1 si les trois segments peuvent former un triangle et 0, autrement.
#include<stdio.h>
#include<math.h>
int triangle (float x, float y, float z)
{
	if((x>0)&&(y>0)&&(z>0)&&(x<y+z)&&(y<x+z)&&(z<x+y))
	return 1;
		else return 0;
}
void main()
{
	float x;
	float y;
	float z;
	printf("Entrer x: ");
	scanf("%f", &x);
	printf("Entrer y: ");
	scanf("%f", &y);
	printf("Entrer z: ");
	scanf("%f", &z);
 
	printf("Resultat: %d",triangle(x,y,z)),
 
	getchar();
	int k;
	scanf("%d", k);
}

24) Écrire une fonction qui retourne le dernier chiffre d'un nombre naturel. Par exemple, pour le nombre 234, la fonction retournera 4.
#include<stdio.h>
#include<math.h>
int chiffre (int a)
{
	int b;
	b=a%10; 
	return b;
} 
void main()
{
	int a;
	
	printf("Entrer le nombre: ");
	scanf("%d", &a);
 
	printf("La derniere ciffre est: %d",chiffre(a));
 
getchar();
int k;
scanf("%d", k);
}
Cookies help us deliver our services. By using our services, you agree to our use of cookies.