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

  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;
    }
    
    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 ;)
      0
      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;
        }
        
        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
        0
      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
        
        0
      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 ;)
        0
      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.
        0