Thread: Typedef, Structs, Reusability without OO

I know C is not an OO language, but I'm modelling my code of those concepts and I want to essentially make multiple "struct instances", here's my goals:

1) Create a struct with a dynamic array
2) Use multiple instances of the struct, all seperate and unique
3) less code, more reusability

Code:

typedef enum
{
    false,
    true,

}bool;

typedef struct table
{

        int *array = NULL;
        int *count = 0; 
        int *size;

        bool new( int length, int fill )
        {
                int i;

                *size = length;                         
                *count = (length*fill);
                array = (int*)malloc(length * sizeof (int)); /*Allocate memroy*/

                if (array == NULL) 
                {
                        printf("ERROR! Could not allocate memory for array\n");
                        return false; /*Memory allocation failure*/
                }

                for(i=0;i<length;i++)
                        array[i] = fill;

                return true; 
        }

        /*Destructor - Free allocated memory and set pointer to null*/
        int delete()
        {
                free(array);
                array = NULL;
        }

}table;

int main()
{
  //not sure how to go about this....
}

So basically I want this "table" variable I can create many instances of (each unique and seperate). Then I want to add more inline functions and variables. I am not sure if the above is correct or how I would go about it in C.

I was thinking, I would have to allocate memory for each instance of a "table" variable, but since the array within it is dynamic the memory I allocate for the "table" variable might not be enough....so I may have to reallocate memory.

Any ideas, or tips on how to proceed would be great and I would really appreciate it. First attempt at C!

Making the structs you want is not a big deal, but trying to make your C program like an OO program, is unwise, imo.

If you make your functions robust, there's no reason they can't be reused. I believe the C standard library has many excellent examples of that.

I would suggest focusing on what you want your program to do, and then working out a good top-down design for it.

Hiking in the Sahara Desert is entirely different from hiking in the high Andes mtns. Trying to make them the same will undoubtedly be difficult, and prone to failure.

As you make each struct dynamically, you also malloc (or calloc), the memory for the dynamic array in each struct. Nothing needs to be reallocated.

Thanks for all the insight, i'm still not sure if I can accomplish what I want by but here's some code. Basically, two seperate table variables, im not sure if I set it up right or if im modifieing variables accordingly.

Code:

int main()
{

        table *t1;
        table *t2;

        t1 = new(4, 1);
        t2 = new(2, 3);

        delete( t1 );
        delete( t2 );

typedef struct table
{
        /*Innitialize all values incase we use accidentally*/
        int *array = NULL; /*Default for pointers (points to nothing)*/
        int count = 0;    /*Default for counter (empty array)*/
        int size;
};


/*Constructor - Innitialize variables and dynamically create integer array*/
table *new( int length, int fill )
{
        int i;
        table mytable;

        /*Innitialize variables*/
        mytable.size  = length;                               /*Size of the array (used for rfl function call)*/
        mytable.rem  = (length*fill);                        /*Remaining count of rfl table*/
        mytable->array = (int*)malloc(length * sizeof (int)); /*Allocate memroy*/

        if (mytable->array == NULL) /*Check progress of memory allocation*/
                printf("ERROR! Could not allocate memory for table\n");

        for(i=0;i<length;i++)
                mytable->array[i] = fill;

        return mytable; /*All is well*/
}

 /*Remove the specified index, adjusting the count accordingly*/
 int remove( table *mytable, int index )
 {
         mytable.count -= table->array[index];
         mytable->array[index] = 0;
 }

/*Increment existing values in array, increasing the count accordingly*/
 int increment( table *mytable )
 {
        int i;

        for(i=0;i<(mytable.size);i++)
        {
                if(mytable->array[i])
                        mytable->array[i] += 1;
         }
 }

  /*Destructor - Free allocated memory and set pointer to null*/
  void delete( table *mytable )
  {
          free(mytable->array);  /*Free allocated memory*/
          mytable->array = NULL; /*Assign pointer to null*/

          mytable.count = 0;
          mytable.size = -1;

          if( mytable->array != NULL )
               printf("ERROR! Could not de-allocate memory for table\n");
  }

}

If I want some other function to modify the contents of the structs "count" variable, can I just pass it like so: "&(mytable.count)", than have the function im passing it to modify it?

Also, can I just use integers in the struct than modify them at will, or do I need them to be pointers and modify them another way?