C Pointer Pointer Question

struct instruction {
   int value;
};

int n; // Number of instructions

struct instruction **instructions; //Required to use ** and dynamic array

Say I want to store n number of instructions and store a value in each instructions. How would I do that with the **instructions?? So I want to be able to call a value from a specific instruction later.

Many Thanks

So far I tried these, a few scanfs and dynamic array creating. So it takes number of counters, then takes number of thread (pthreads), then takes number of instructions within each thread. I am trying to find a way to store the instructions in each thread. ** structure is given

int
main(void) {

        scanf(" %d", &ncounters); //Ask for number of counters

        int i;

        if(counters = malloc(sizeof(struct counter)*ncounters)){
          for( i=0; i < ncounters ;i++){
            counters[i].counter = 0;
          }
        }

        scanf(" %d", &nthreads); //Ask for number of threads

        if(ninstructions = (int*) malloc(nthreads*sizeof(int))){
          for( i=0; i < nthreads ;i++){
            ninstructions[i] = 0;
          }
        }

        for(i=0; i < nthreads ;i++){

          scanf(" %d", &ninstructions[i]);  //Ask for number of instructions within threads[i]
         // Things got messy from here ...  
          instruct开发者_如何学JAVAions = malloc(sizeof(struct instruction*)*ninstructions[i]);

          for(int j=0; j < ninstructions[j] ;j++){
            instructions[j] = malloc(sizeof(struct instruction));
            int x;
            printf("Enter rep for thread %d inst %d.\n",i+1 ,j+1);
            scanf(" %d", &x);
            instructions[i][j].repetitions = x;
          }

        }

        printf(" Instruction x: %d.\n", instructions[0][0].repetitions);

//=============================================================================
// Just testing with printf
        printf("Number of counters: %d.\n", ncounters);
        printf("Number of threads: %d.\n", nthreads);

        for(i=0; i < nthreads; i++){
          printf("Thread %d has %d instructions.\n", i+1, ninstructions[i]);
        }

//=============================================================================

        free(instructions);
        free(ninstructions);
        free(counters);
    return 0;
}

I finally got some progress, but getting segmentation fault at the instruction storing part.

struct counter *counters;

struct instruction{
  struct counter *counter;
  int repetitions;
  void (*work_fn)(long long*);
};

for(i=0; i < nthreads ;i++){

  scanf(" %d", &ninstructions[i]);  //Ask for number of instructions within threads[i]

  instructions = malloc(nthreads*sizeof(struct instruction *));

  instructions[i] = malloc(ninstructions[i]*sizeof(struct instruction));
  for(int j=0;j < ninstructions[i] ;j++){
    int Srepetition;
    char Sfunction;
    int Scounter;

    scanf(" %d %c %d", &Scounter, &Sfunction, &Srepetition);

    //Problem seems to be here "Segmentation fault" ..............

    instructions[i][j].repetitions = Srepetition;
    instructions[i][j].counter = (counters+Scounter);

    if(Sfunction == 'I'){
      instructions[i][j].work_fn(&increment);
    }else if(Sfunction == 'D'){
      instructions[i][j].work_fn(&decrement);
    }else if(Sfunction == '2'){
      instructions[i][j].work_fn(&mult2);
    }else{
      printf("error\n");
    }

    printf("Thread: %d Instruction: %d.\n", i+1, j+1);
    }
}

With just one * is enough to create a dynamic array, with ** you would be creating a matrix.

struct instruction *instructions = malloc(n * sizeof(struct instruction));

/* setting some random values */
for (int i=0;i<n;i++)
     instructions[i]->value = i;

/* accessing values */
for (int i=0;i<n;i++)
     printf("instruction %d value %d\n",i,instructions[i]->value);

/* don't forget to free */
free(instructions);

Please look for references about dynamic arrays in C to investigate more. For instance this one

edit

... if you really need matrix this is the equivalent code:

int n,z; // for number cols and rows

struct instruction **instructions = malloc(n * sizeof(struct instruction *));

/* setting some random values */
for (int i=0;i<n;i++) {
     instructions[i] = malloc(z * sizeof(struct instruction));
     for (int j=0;j<z;j++) 
         instructions[i][j]->value = i * j;
}
/* accessing values */
for (int i=0;i<n;i++) {
     for (int j=0;j<z;j++) 
          printf("instruction %d,%d value %d\n",i,j,instructions[i][j]->value);
}

/* don't forget to free */ 
for (int i=0;i<n;i++)
     free(instructions[i]);
free(instructions);