C change pointer to structure - c

Question

I'm not that familiar with C and try to add a row to a existing matrix structure with a function. This function will be used in a iteration loop.
In my code, I use the matrix PreparedData_B4 as reference matrix. In the first step I slice 3 rows out of PreparedData_B4 and create the matrix ActData. Afterwards I call the function add_row with the arguments mat In, mat **Out and mat Out1. Maybe there is also another idea to avoid the passing of the adress of ActData (mat **Out) and the ActData (mat Out1) itself. It was my only chance to get the right dimensions of Tmp.
EDIT: In this function, I create a temporary matrix Temp with the new dimensions. After *Out = &Tmp the new address is set and works fine in my opinion. (**Out)->n = 3, (**Out)->m = 4 and (**Out)->v[][] is accessable.
So far, so good.
After the function is completed, things go wrong. ActData->n = 0 and ActData->v[][] is not accessable.
Another questions is, how to free the memory of the "old" ActData?
#include <stdio.h>
#include <stdlib.h>
#define NELEMS(x) (int)(sizeof(x) / sizeof((x)[0]))
// Raw data
double raw_T7[][3] = {
{1800, 261.753, 1032.354},
{1750, 247.46, 1028.439},
{1700, 250.385, 1003.689},
{1243, 69.92, 816.569},
{670, 67.485, 614.319},
{533, 73.591, 533.15},
{509, 73.404, 517.456},
{485, 89.233, 515.994},
{460, 110.535, 501.412},
{435, 141.864, 471.876},
{411, 195.009, 480.623},
{386, 260.166, 529.444},
{361, 375.958, 462.411}
};
// Matrix structure
typedef struct {
int m, n;
double ** v;
} mat_t, *mat;
// Create new matrix
mat mat_new(int m, int n){
int i = 0;
mat out = malloc(sizeof(mat_t));
out->v = malloc(sizeof(double*) * m);
out->v[0] = calloc(sizeof(double), m * n);
for (i = 0; i < m; i++) out->v[i] = out->v[0] + n * i;
out->m = m;
out->n = n;
return out;
}
// Show matrix
void mat_show(mat A){
int i = 0, j = 0;
for(i = 0; i < A->m; i++) {
for (j = 0; j < A->n; j++) {
printf(" %8.3f", A->v[i][j]);
}
printf("\n");
}
printf("\n");
}
void add_row(mat In, mat **Out, mat Out1){
int i = 0, j = 0;
// Create new matrix
mat Tmp = mat_new(Out1->m + 1, Out1->n);
for (i = 0 ; i < Tmp->n ; i++) {
for(j = 0 ; j < Tmp->m ; j++){
Tmp->v[j][i] = In->v[j][i];
}
}
mat_show(Tmp);
// Delete old address
//free(Out1->v[0]);
//free(Out1->v);
//free(Out1);
*Out = &Tmp;
}
int main()
{
int i = 0, j = 0;
// Assign array address to first matrix structure
mat PreparedData_B4 = mat_new(NELEMS(raw_T7), NELEMS(raw_T7[0]));
double *ptr1[PreparedData_B4->m];
free(PreparedData_B4->v[0]);
free(PreparedData_B4->v);
PreparedData_B4->v = (double **)ptr1;
for (i = 0 ; i < PreparedData_B4->m ; i++) ptr1[i] = (double *)raw_T7 + i * NELEMS(raw_T7[0]);
// Create new matrix with the first 3 rows of PreparedData_B4
mat ActData = mat_new(3, PreparedData_B4->n);
for (i = 0 ; i < ActData->n ; i++) {
for(j = 0 ; j < ActData->m ; j++){
ActData->v[j][i] = PreparedData_B4->v[j][i];
}
}
puts("PreparedData_B4");
mat_show(PreparedData_B4);
puts("ActData");
mat_show(ActData);
puts("ActData with additional row");
add_row(PreparedData_B4, &ActData, ActData);
mat_show(ActData);
free(PreparedData_B4);
return 0;
}
SOLUTION:
Due the solid foundation of David C. Rankin and all the other responses my working example. Many thanks!
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define NELEMS(x) (int)(sizeof(x) / sizeof((x)[0]))
// Raw data
double raw_T7[][3] = {
{1800, 261.753, 1032.354},
{1750, 247.46, 1028.439},
{1700, 250.385, 1003.689},
{1243, 69.92, 816.569},
{670, 67.485, 614.319},
{533, 73.591, 533.15},
{509, 73.404, 517.456},
{485, 89.233, 515.994},
{460, 110.535, 501.412},
{435, 141.864, 471.876},
{411, 195.009, 480.623},
{386, 260.166, 529.444},
{361, 375.958, 462.411}
};
// Matrix structure
typedef struct {
int m, n;
double *v;
} mat_t;
// Create new matrix
mat_t *mat_new (int m, int n)
{
mat_t *out = malloc (sizeof *out); /* allocate struct */
if (!out) {
perror ("malloc-out");
exit (EXIT_FAILURE);
}
out->v = malloc(sizeof *out->v * m * n); /* allocate for m * n doubles */
if (!out->v) {
perror ("malloc-out->v");
exit (EXIT_FAILURE);
}
out->m = m;
out->n = n;
return out;
}
// Show matrix
void mat_show(mat_t *A)
{
int i = 0, j = 0;
for(i = 0; i < A->m; i++) {
for (j = 0; j < A->n; j++)
printf(" %8.3f", (A->v)[i * A->n + j]);
putchar ('\n');
}
putchar ('\n');
}
void add_row(mat_t *In, mat_t **Out){
int i = 0, j = 0;
// Create new matrix
mat_t *Tmp = mat_new((*Out)->m + 1, (*Out)->n);
for (i = 0 ; i < Tmp->m ; i++) {
for(j = 0 ; j < Tmp->n ; j++){
(Tmp->v)[i * Tmp->n + j] = (In->v)[i * In->n + j];
}
}
// Delete old address
free((*Out)->v);
free(*Out);
// Assign new address
*Out = Tmp;
}
int main(void)
{
int rows = NELEMS(raw_T7), cols = NELEMS(raw_T7[0]);
int i = 0, j = 0;
// Assign array address to first matrix structure
mat_t *PreparedData_B4 = mat_new(rows, cols); /* allocate, set m & n */
/* copy raw_T7 to PreparedData_B4->v */
memcpy (PreparedData_B4->v, raw_T7, rows * cols * sizeof PreparedData_B4->v);
// Create new matrix with the first 3 rows of PreparedData_B4
mat_t *ActData = mat_new(3, PreparedData_B4->n);
for (i = 0 ; i < ActData->m ; i++) {
for(j = 0 ; j < ActData->n ; j++){
(ActData->v)[i * ActData->n + j] = (PreparedData_B4->v)[i * PreparedData_B4->n + j];
}
}
puts("PreparedData_B4");
mat_show(PreparedData_B4);
puts("ActData");
mat_show(ActData);
puts("ActData with additional row");
add_row(PreparedData_B4, &ActData);
mat_show(ActData);
free (PreparedData_B4->v);
free (PreparedData_B4);
return 0;
}

Answer 1

Before you can build the perfect house, you must build a solid foundation -- otherwise the house will not last.
You are confusing the use of pointers and allocated blocks of memory for storage of data. This is quite apparent in your mat_new() function. Think about it... You allocate for m pointers,
out->v = malloc(sizeof(double*) * m);
But then only use a single-pointer:
out->v[0] = calloc(sizeof(double), m * n);
(what are you using the other m - 1 pointers for??)
You look like you want to allocate a single block of memory to store your matrix values in, but then simulate a 2D array in your indexing (which is fine and is a very efficient approach) However, to do that, you do not use a double-pointer for v, you simply use a single-pointer (e.g. double *v;) This provides the benefit of a single-allocation and single-free for your stored data. (you still must free the struct itself)
Let's just take your mat_new (int m, int n) function and get that working properly and then output the data with your mat_show(mat_t *A) and finally free the memory we have allocated to that point, e.g.
// Create new matrix
mat_t *mat_new (int m, int n)
{
mat_t *out = malloc (sizeof *out); /* allocate struct */
if (!out) {
perror ("malloc-out");
exit (EXIT_FAILURE);
}
out->v = malloc(sizeof *out->v * m * n); /* allocate for m * n doubles */
if (!out->v) {
perror ("malloc-out->v");
exit (EXIT_FAILURE);
}
out->m = m;
out->n = n;
return out;
}
(note: I have removed the typedeffed pointer mat)
For your mat_show() function, you would then have:
// Show matrix
void mat_show(mat_t *A)
{
int i = 0, j = 0;
for(i = 0; i < A->m; i++) {
for (j = 0; j < A->n; j++)
printf(" %8.3f", (A->v)[i * A->n + j]);
putchar ('\n');
}
putchar ('\n');
}
(note: don't use printf to output a single-character, that is what putchar() is for -- though a good compiler will make that optimization for you)
If you put those functions together with a shortened example, you would have:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define NELEMS(x) (int)(sizeof(x) / sizeof((x)[0]))
// Raw data
double raw_T7[][3] = { {1800, 261.753, 1032.354},
{1750, 247.46, 1028.439},
{1700, 250.385, 1003.689},
{1243, 69.92, 816.569},
{670, 67.485, 614.319},
{533, 73.591, 533.15},
{509, 73.404, 517.456},
{485, 89.233, 515.994},
{460, 110.535, 501.412},
{435, 141.864, 471.876},
{411, 195.009, 480.623},
{386, 260.166, 529.444},
{361, 375.958, 462.411} };
// Matrix structure
typedef struct {
int m, n;
double *v;
} mat_t;
// Create new matrix
mat_t *mat_new (int m, int n)
{
mat_t *out = malloc (sizeof *out); /* allocate struct */
if (!out) {
perror ("malloc-out");
exit (EXIT_FAILURE);
}
out->v = malloc(sizeof *out->v * m * n); /* allocate for m * n doubles */
if (!out->v) {
perror ("malloc-out->v");
exit (EXIT_FAILURE);
}
out->m = m;
out->n = n;
return out;
}
// Show matrix
void mat_show(mat_t *A)
{
int i = 0, j = 0;
for(i = 0; i < A->m; i++) {
for (j = 0; j < A->n; j++)
printf(" %8.3f", (A->v)[i * A->n + j]);
putchar ('\n');
}
putchar ('\n');
}
int main (void)
{
int rows = NELEMS(raw_T7), cols = NELEMS(raw_T7[0]);
mat_t *PreparedData_B4 = mat_new(rows, cols); /* allocate, set m & n */
/* copy raw_T7 to PreparedData_B4->v */
memcpy (PreparedData_B4->v, raw_T7, rows * cols * sizeof PreparedData_B4->v);
mat_show (PreparedData_B4); /* output matrix */
free (PreparedData_B4->v);
free (PreparedData_B4);
}
(note: string.h was included to make the memcpy() function available to initialize out->v from raw_T7 in a single call )
Example Use/Output
$ ./bin/mat_prepare
1800.000 261.753 1032.354
1750.000 247.460 1028.439
1700.000 250.385 1003.689
1243.000 69.920 816.569
670.000 67.485 614.319
533.000 73.591 533.150
509.000 73.404 517.456
485.000 89.233 515.994
460.000 110.535 501.412
435.000 141.864 471.876
411.000 195.009 480.623
386.000 260.166 529.444
361.000 375.958 462.411
Memory Use/Error Check
$ valgrind ./bin/mat_prepare
==10301== Memcheck, a memory error detector
==10301== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==10301== Using Valgrind-3.13.0 and LibVEX; rerun with -h for copyright info
==10301== Command: ./bin/mat_prepare
==10301==
1800.000 261.753 1032.354
1750.000 247.460 1028.439
1700.000 250.385 1003.689
1243.000 69.920 816.569
670.000 67.485 614.319
533.000 73.591 533.150
509.000 73.404 517.456
485.000 89.233 515.994
460.000 110.535 501.412
435.000 141.864 471.876
411.000 195.009 480.623
386.000 260.166 529.444
361.000 375.958 462.411
==10301==
==10301== HEAP SUMMARY:
==10301== in use at exit: 0 bytes in 0 blocks
==10301== total heap usage: 3 allocs, 3 frees, 1,352 bytes allocated
==10301==
==10301== All heap blocks were freed -- no leaks are possible
==10301==
==10301== For counts of detected and suppressed errors, rerun with: -v
==10301== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
This is what it appears you were trying to accomplish. Let me know if I misinterpreted your intent or if you have further questions. Get your memory use correct first to provide a solid foundation and build from there.