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. 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
  2. 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