variable dynamique

Bonsoir,
Voila, je voudrai faire une fonction qui créé une variable de type et de nom dynamique. Pour cela je fais:

// Création d'une variable
boolean creat(void* pointeur, char type, char nom)
{
  int size;
  switch (type) {
    case 'char':
        size = 1;
      break;
    case 'String':
        size = 6;
      break;
    case 'int':
        size = 2;
      break;
  }


  void* nom = NULL;         // Créé une variable de type et de nom vide            ======>>> declaration of 'void* nom' shadows a parameter
  nom = malloc(size);       // Aloue de la mémoire pour ma variable
  if (nom == NULL) return false;
  return true;
}

Mais j'ai une erreur: declaration of 'void* nom' shadows a parameter

vous vous mélangez les pinceaux entre nom (que vous redéfinissez en plus en portée locale) et pointeur... et votre case ne va pas marcher comme vous le pensez...

et bien sûr le nom d'une variable en C ou C++ ça ne veut absolument rien dire... il n'y a que des pointeurs vers de la mémoire allouée à votre variable

faut revoir ce que vous essayez de faire

Je viens de revoir, mais j’y suis pas encore:

#include <stdio.h>
#include <string.h>

char buffer[120];
enum {typeChar = 1, typeString = 6, typeInt = 2};

void setup() {
  Serial.begin(9600);                                     // Initialise le port série
  Serial.println("Pret...");

Serial.println("\n\nnombre d'octets que prendle diferants type de variables en mémoire:\n");
  sprintf(buffer, "char   : %d octets", sizeof(char));
  Serial.println(buffer);
  sprintf(buffer, "String : %d octets", sizeof(String));
  Serial.println(buffer);
  sprintf(buffer, "int    : %d octets", sizeof(int));
  Serial.println(buffer);
void* maVariable;
int varType = typeChar;
Serial.print("type de variable: ");
Serial.println(varType);

creat(maVariable, varType);

maVariable = 'a';
Serial.print("Ma variable: ");
//Serial.println(maVariable);          <===== call of overloaded 'println(void*&)' is ambiguous
}
// Création d'une variable
boolean creat(void* pointeur, int type)    // Pointeur = pointeur sur variable typée
{
Serial.println("Fonction creat: ");

  int size;
  switch (type) {
    case typeChar:
        size = 1;
      break;
    case typeString:
        size = 6;
      break;
    case typeInt:
        size = 2;
      break;
  }
  pointeur = NULL;               // Créé une variable de type et de nom vide
  pointeur = malloc(size);       // Aloue de la mémoire pour ma variable
  if (pointeur == NULL) return (false);
  return (true);
}

c'est mieux comme ça:

  sprintf(buffer, "maVariable= %s", maVariable);
  Serial.println(buffer);

Salut

Ce code est bourré de problèmes.
La fonction creat reçoit comme paramètre la valeur d'un pointeur auquel elle affecte un espace alloué.
Pour l'appelant maVariable ne changera jamais de valeur.

Pour corriger cela il faudrait faire :

boolean creat(void** pointeur, int type)    // Pointeur = pointeur sur variable typée
{
  Serial.println("Fonction creat: ");

  int size;
  switch (type) {
    case typeChar:
      size = 1;
      break;
    case typeString:
      size = 6;
      break;
    case typeInt:
      size = 2;
      break;
  }
  *pointeur = malloc(size);       // Aloue de la mémoire pour ma variable
  if (*pointeur == NULL) return (false);
  return (true);
}

Et appeler comme ceci :

  creat(&maVariable, varType);

Plus généralement, je ne vois pas l'utilité de cette fonction qui ne fait qu'appeler malloc(). Autant utiliser directement malloc().

Deuxièmement dans la suite du programme je ne vois pas comment tu vas utiliser cette variable sans connaître son type.
Impossible d'appeler la moindre fonction de librairie(s) en passant ce machin en paramètre. C'est tout simplement inutilisable.
Ce que tu cherches à faire est réinventer les variants.
Or un variant est une structure contenant une information 'type'.

Si tu commençais par expliquer pourquoi tu as besoin de ce genre de chose ...

@+