Présentation:

la fonction en mathématique la plus connue est y = f (x)

f étant ici la fonction.

en C le principe est le même.

On rappel que la fonction principale (qui permet de démarrer le programme) est: 

int main (int argc, char **argv)
{
return EXIT_SUCCESS;  /* retour de la fonction */
}

c’est la fonction minimale pour faire un code C

L’idée de découper en fonction est de découper les taches en sous tache..Et de pouvoir constituer des librairies.

Ecrire une fonction

on va pour s’exercer réaliser une fonction lg_chaine() qui va nous renvoyer le nombre de caractère d’une chaîne (string), il faut se rappeler ici qu’une chaîne de caractère se termine toujours par le code NUL ou \0 ou 0.

prototype

Le prototype de la fonction lg_chaine est :

int lg_chaine(char *chaine);

qui va utiliser une boucle de comptage 

ici la fonction est vu par gcc avant de voir le main ! donc pas besoin de présenter son prototype.

/********************************
 * Projet : comptage de caractère
 * Auteur : Bogt
 * Date   : 28/11/2022
 ********************************
#include <stdlib.h>
#include <stdio.h>

/* fonction lg_chaine */
int lg_chaine(char *chaine)
{
	int nb_lettre;
	nb_lettre=0;   /* pas de lettre au départ de la fonction */
	printf ("%s \n",chaine);
	while (chaine[nb_lettre]!=0)  /* 0 ou '\0' */
 	{
		nb_lettre=nb_lettre+1; 	/* on a une lettre en plus dans la chaine */
	}
	return nb_lettre; /* retour du nombre de lettre */
}

int main (int argc, char **argv)
{	
	int letter_number;
	letter_number=lg_chaine ("Bonjour le monde");
	printf ("on a %d lettre(s) ou espace(s) dans cette chaine\n",letter_number);
	return EXIT_SUCCESS;
}

Avec Monia

le programme main (principal)

Le prototype de lg_chaine pour annoncer la couleur à gcc

/********************************
 * Projet : passage de chaine proto
 * Auteur : Bogt
 * Date   : 28/11/2022
 ********************************/
#include <stdlib.h>
#include <stdio.h>

/* prototype de  lg_chaine */
int lg_chaine(char *chaine);

/************* MAIN *****************************/
int main (int argc, char **argv)
{	
	int letter_number;
	letter_number=lg_chaine ("Bonjour le monde");
	printf ("on a %d lettre(s) ou espace(s) dans cette chaine\n",letter_number);
	return EXIT_SUCCESS;
}
/************ Ma ou Mes fonction(s) *************/
/* fonction lg_chaine */
int lg_chaine(char *chaine)
{
	int nb_lettre;
	nb_lettre=0;   /* pas de lettre au départ de la fonction */
	printf ("%s \n",chaine);
	while (chaine[nb_lettre]!=0)  /* 0 ou '\0' */
 	{
		nb_lettre=nb_lettre+1; 	/* on a une lettre en plus dans la chaine */
	}
	return nb_lettre; /* retour du nombre de lettre */
}

Ma première libraire 

 ou bibliothèque avec ma fonction

Notre projet sera dans un répertoire : monprojet

on y trouvera les fichiers suivants :

#include <stdio.h>

/* fonction lg_chaine */
int lg_chaine(char *chaine)
{
	int nb_lettre;
	nb_lettre=0;   /* pas de lettre au départ de la fonction */
	printf ("%s \n",chaine);
	while (chaine[nb_lettre]!=0)  /* 0 ou '\0' */
 	{
		nb_lettre=nb_lettre+1; 	/* on a une lettre en plus dans la chaine */
	}
	return nb_lettre; /* retour du nombre de lettre */
}

malib.c (code c de la fonction)

#ifndef __malib__
#define __malib__
/* fonction lg_chaine */
int lg_chaine(char *chaine);
#endif

malib.h (header de fichier)

/********************************
 * Projet : passage de chaine
 * Auteur : Bogt
 * Date   : 28/11/2022
 ********************************/

#include <stdlib.h>
#include <stdio.h>
#include "malib.h"

int main (int argc, char **argv)
{	
	int letter_number;
	letter_number=lg_chaine ("Bonjour le monde");
	printf ("on a %d lettre(s) ou espace(s) dans cette chaine\n",letter_number);
	return EXIT_SUCCESS;
}

cptchaine.c (main)

Compilation du projet:

le fichier objet

gcc -c  malib.c
bruno@elliott:~/Works/langage_C/cptchaine/prj$ ls -l
total 16
-rw-r--r-- 1 bruno bruno  403 29 nov.  16:41 cptchaine.c
-rw-r--r-- 1 bruno bruno  357 29 nov.  16:46 malib.c
-rw-r--r-- 1 bruno bruno   98 29 nov.  16:45 malib.h
-rw-r--r-- 1 bruno bruno 1424 29 nov.  16:46 malib.o

on obtient le fichier .o (objet) rien avoir avec la programmation objet 

c’est le code machine de ma fonction (en langage machine)

bruno@debian:~/Works/langageC/malib$ objdump -d -C malib.o

malib.o:     format de fichier elf64-x86-64


Déassemblage de la section .text :

0000000000000000 <lg_chaine>:
   0:	55                   	push   %rbp
   1:	48 89 e5             	mov    %rsp,%rbp
   4:	48 83 ec 20          	sub    $0x20,%rsp
   8:	48 89 7d e8          	mov    %rdi,-0x18(%rbp)
   c:	c7 45 fc 00 00 00 00 	movl   $0x0,-0x4(%rbp)
  13:	48 8b 45 e8          	mov    -0x18(%rbp),%rax
  17:	48 89 c6             	mov    %rax,%rsi
  1a:	48 8d 05 00 00 00 00 	lea    0x0(%rip),%rax        # 21 <lg_chaine+0x21>
  21:	48 89 c7             	mov    %rax,%rdi
  24:	b8 00 00 00 00       	mov    $0x0,%eax
  29:	e8 00 00 00 00       	call   2e <lg_chaine+0x2e>
  2e:	eb 04                	jmp    34 <lg_chaine+0x34>
  30:	83 45 fc 01          	addl   $0x1,-0x4(%rbp)
  34:	8b 45 fc             	mov    -0x4(%rbp),%eax
  37:	48 63 d0             	movslq %eax,%rdx
  3a:	48 8b 45 e8          	mov    -0x18(%rbp),%rax
  3e:	48 01 d0             	add    %rdx,%rax
  41:	0f b6 00             	movzbl (%rax),%eax
  44:	84 c0                	test   %al,%al
  46:	75 e8                	jne    30 <lg_chaine+0x30>
  48:	8b 45 fc             	mov    -0x4(%rbp),%eax
  4b:	c9                   	leave
  4c:	c3                   	ret
bruno@debian:~/Works/langageC/malib$ 

on va faire les liens entre les fichiers grâce à gcc 

gcc malib.o cptchaine.c -o cptchaine -Wall -pedantic -ansi -g

qui va générer l’exécutable

On est pas obligé de fabriquer les fichiers objets à chaque fois ! on peut obtenir l’exécutable directement. (mais les objets existeront mais pendant la phase de compilation)

gcc malib.c cptchaine.c -o cptchaine -Wall -pedantic -ansi -g

Regardons avec gdb , step ou next…