incrément dans une boucle et état de conservation

Question

gcc 4.4.4 c89

J'ai le code suivant et 2 structures à remplir.

J'ai 3 fonctions qui rempliront les poignées pour chacun des dispositifs. Cependant, la structure device_type devra s'incrémenter depuis l'endroit où la dernière fonction s'est terminée.

Par exemple:

load_resources() starts at 0 and finishes at 9 
    dev_types starts at 0 and finishes at 9 

load_networks() starts at 0 and finishes at 9 
    dev_types starts at 10 and finishes at 19 

load_controls() starts at 0 and finishes at 9 
    dev_types starts at 20 and finishes at 29 

Cependant, comme je ne veux pas utiliser une variable statique ou globale est-il possible que je peux incrémenter une valeur pour cela. Donc, il va commencer là où la dernière fonction a fini.

Un grand merci pour toutes les suggestions,

#define NUMBER_OF_DEVICES 10 
#define NUMBER_OF_TYPES 3 /* resources 
          networks 
          controls */ 

int events(int evt); 

int load_resources(); 
int load_networks(); 
int load_controls(); 

static struct device_table { 
    int resource_handle; 
    int network_handle; 
    int control_handle; 
} dev_tbl[NUMBER_OF_DEVICES]; 

struct device_types { 
    size_t id; 
    int dev_handle; 
    int dev_type; 
}dev_types[NUMBER_OF_DEVICES * NUMBER_OF_TYPES]; 

enum dev_name_types {RESOURCE, NETWORK, CONTROL}; 

/* Simulates the API calls, by returning a dummy handle */ 
int get_resources(); 
int get_networks(); 
int get_controls(); 

int main(void) 
{ 
    srand(time(NULL)); 

    load_resources(); 
    load_networks(); 
    load_controls(); 

    return 0; 
} 

int load_resources() 
{ 
    size_t i = 0; 

    for(i = 0; i < NUMBER_OF_DEVICES; i++) { 
     dev_tbl[i].resource_handle = get_resources(); 
     printf("dev_tbl[i].resource_handle [ %d ]\n", dev_tbl[i].resource_handle); 
     dev_types[i].id = i; 
     dev_types[i].dev_handle = dev_tbl[i].resource_handle; 
     dev_types[i].dev_type = RESOURCE; 
    } 
} 

int load_networks() 
{ 
    size_t i = 0; 

    for(i = 0; i < NUMBER_OF_DEVICES; i++) { 
     dev_tbl[i].network_handle = get_networks(); 
     printf("dev_tbl[i].network_handle [ %d ]\n", dev_tbl[i].network_handle); 
     dev_types[i].id = i; 
     dev_types[i].dev_handle = dev_tbl[i].network_handle; 
     dev_types[i].dev_type = NETWORK; 
    } 
} 

int load_controls() 
{ 
    size_t i = 0; 

    for(i = 0; i < NUMBER_OF_DEVICES; i++) { 
     dev_tbl[i].control_handle = get_controls(); 
     printf("dev_tbl[i].control_handle [ %d ]\n", dev_tbl[i].control_handle); 
     dev_types[i].id = i; 
     dev_types[i].dev_handle = dev_tbl[i].control_handle; 
     dev_types[i].dev_type = CONTROL; 
    } 
} 

Answer 1

Pourquoi ne pas changer les prototypes à quelque chose comme:

void load_resources(int*) 

(ils ne sont pas vraiment quoi que ce soit de retour) puis, dans votre code principal, ont:

int base = 0; 
load_resources (&base); 
load_networks (&base); 
load_controls (&base); 

Chaque fonction est alors responsable pour utiliser et mettre à jour *base comme ceci:

void load_resources (int *pBase) { 
    size_t i = 0; 

    for(i = 0; i < NUMBER_OF_DEVICES; i++, (*pBase)++) { // <-- see here! 
     dev_tbl[i].resource_handle = get_resources(); 
     printf("dev_tbl[i].resource_handle [ %d ]\n", dev_tbl[i].resource_handle); 
     dev_types[*pBase].id = i; 
     dev_types[*pBase].dev_handle = dev_tbl[i].resource_handle; 
     dev_types[*pBase].dev_type = RESOURCE; 
    } 
} 

Answer 2

Une option est d'avoir chacun de vos fonctions prennent l'indice de base en tant que paramètre, et en retournant le premier index disponible:

int index = 0; 
index = load_resources(index); 
index = load_network(index); 
// and so on 

Avec cette yout fonctions ressemblerait à quelque chose comme ceci:

int load_resources(int base_index) 
{ 
    size_t i = 0; 
    size_t index; 

    for(i = 0; i < NUMBER_OF_DEVICES; i++) { 
     index = base_index + i; 
     dev_tbl[index].resource_handle = get_resources(); 
     // 
    } 

    return index + 1; 
} 

Par ailleurs, votre funct Les ions ont int types de retour, mais ne retournent rien.

Answer 3

Maintenez un pointeur ou une variable d'index dans la structure elle-même. C'est un indicateur de la façon dont la structure a été remplie en général.

Answer 4

Il y a seulement deux manières s pour conserver les données d'une portée à la suivante - sur la pile et sur le tas. Puisque vous avez déjà exclu toute variable globale ici, cela vous obligerait à utiliser des variables de pile, en passant un paramètre et en retournant une valeur, ou en passant un pointeur sur un paramètre.