Typedef uint32_t (*CountFunction)(char *v, uint32_t size);

Bonjour,

svp qui peut m'expliquer ca
typedef uint32_t (*CountFunction)(char *v, uint32_t size);
je veux comprendre ca pour que je le traduis en assembleur x86 et merci d'avance.

2 réponses

  • Votes
  • Date
  • Date décroissante
  1. Bonjour,
    C'est la création d'un type en utilisant la nomination d'un pointeur de fonction. Donc les variables qui seront créées à l'aide du type CountFunction devront être des adresses de fonction ayant le même prototype, c'est à dire :
    retournant un uint32_t et ayant pour paramètres char * et un uint32_t.
    Exemple :
    
    #include <stdint.h>
    #include <stdio.h>
    
    typedef uint32_t (*CountFunction)(char *v,uint32_t size);
    uint32_t mafonction(char *v,uint32_t size){
    	printf("%s %d\n",v,size);
    	return 1337;
    }
    int main(void){
    	CountFunction ctf;
    	ctf=mafonction;
    	printf("%d\n",ctf("hello",100));
    	return 0;
    }
    
    1. et est ce que CountFunction est un type ???
      psq ds mon programme C que je dois traduire en assembleur y a ca :
      CountFunction function;

      CountFunction functions[] = {
      default_count_function,
      my_count_function,
      NULL
      };
      ce que j'ai compris moi est que CountFunction est un type psq le tableau functions[] est de type CountFunction
      voila aidez moi svp je suis bien paumé ds ce C et ASSEMBLEUR ;)
      1. Oui CountFunction est un type car il y a utilisation du typedef et vôtre exemple et le mien le prouve par la création de variable en utilisant ce type!
        C'est exact encore, je rajoute une modif pour le tableau :
        
        #include <stdint.h>
        #include <stdio.h>
        
        typedef uint32_t (*CountFunction)(char *v,uint32_t size);
        uint32_t mafonction1(char *v,uint32_t size){
                printf("fonction1 %s %d\n",v,size);
                return 1;
        }
        uint32_t mafonction2(char *v,uint32_t size){
                printf("fonction2 %s %d\n",v,size);
                return 2;
        }
        int main(void){
                CountFunction tab[]={mafonction1,mafonction2};
                printf("%d %d\n",tab[0]("hello",111),tab[1]("world",222));
                return 0;
        }
        
      2. merci bien c un peux claire mnt et du coup est ce que vous avez une idée sur comment on traduis ca en assembleur x86
      3. Pas vraiment non, si ça peut vous aider voici le code asm pondu par gcc en utilisant ce code :
        #include <stdint.h>
        #include <stdio.h>
        
        typedef uint32_t (*CountFunction)(char *v,uint32_t size);
        uint32_t mafonction1(char *v,uint32_t size){
        	return 1;
        }
        int main(void){
        	CountFunction var;
        	var=mafonction1;
        	var("test",1);
        	return 0;
        }
        
        

        en asm :
        	.file	"main.c"
        	.text
        .globl mafonction1
        	.type	mafonction1, @function
        mafonction1:
        	pushl	%ebp
        	movl	%esp, %ebp
        	movl	$1, %eax
        	popl	%ebp
        	ret
        	.size	mafonction1, .-mafonction1
        	.section	.rodata
        .LC0:
        	.string	"test"
        	.text
        .globl main
        	.type	main, @function
        main:
        	pushl	%ebp
        	movl	%esp, %ebp
        	andl	$-16, %esp
        	subl	$32, %esp
        	movl	$mafonction1, 28(%esp)
        	movl	$1, 4(%esp)
        	movl	$.LC0, (%esp)
        	movl	28(%esp), %eax
        	call	*%eax
        	movl	$0, %eax
        	leave
        	ret
        
      4. est ce que vous aviez faites ca avec la commande :gcc -S porogramme.C ou bien y a un logiciel qui permet de traduire un programme c en assembleur merci de votre aide ;)
      5. Exact j'ai bien utilisé l'option -S de gcc. Enfin ça ne vous aidera qu'à voir que le typedef que vous avez donné en C est fait pour simplifier le code c'est un raccourci/outils du language C, une fois en asm ça n'y figure plus.