Pointer to pointers of structs.

[johnsolver]

Hi I hope I got the topic right..

that's what I'm doing:
create P(variable) polygons each having a variable numbers of vertices,
something in my mallocs is wrong... since I get weird results.

help?

#include <stdio.h>
#include <stdlib.h>

typedef struct point
{
double x, y;
} point;

typedef struct polygon
{
int n;
point *v;
} polygon;

typedef struct line
{
point p1, p2;
double A, B;
} line;

#define P 2

int main()
{
int i = 0, j = 0;

polygon *obstacles = malloc(sizeof *obstacles * P);

for(i = 0; i < P; i++)
{
obstacles[i].n = i + P * 2;
obstacles[i].v = malloc(sizeof obstacles[i].v * obstacles[i].n);

for(j = 0; j < obstacles[i].n; i++)
{
obstacles[i].v[j].x = obstacles[i].n;
obstacles[i].v[j].y = obstacles[i].n + 5;
}
}
}

[Ico]

jo********@gmai l.com wrote:

create P(variable) polygons each having a variable numbers of vertices,
something in my mallocs is wrong... since I get weird results.

Please be more specific: what do you mean by 'weird results' ?

--
:wq
^X^Cy^K^X^C^C^C ^C

[johnsolver]

>Please be more specific: what do you mean by 'weird results' ?
To make it clearer, the program doesn't finish runing. I'm quite
certain I've made a copmlete mess out of the mem-allocation...

Thanks.

[Nils O. Selåsdal]

jo********@gmai l.com wrote:

Hi I hope I got the topic right..

that's what I'm doing:
create P(variable) polygons each having a variable numbers of vertices,
something in my mallocs is wrong... since I get weird results.

help? [...]

int main()
{
int i = 0, j = 0;

polygon *obstacles = malloc(sizeof *obstacles * P);

for(i = 0; i < P; i++)
{
obstacles[i].n = i + P * 2;
obstacles[i].v = malloc(sizeof obstacles[i].v * obstacles[i].n);

for(j = 0; j < obstacles[i].n; i++) ^^
Likely you mean j++ in the above for loop.
{
obstacles[i].v[j].x = obstacles[i].n;
obstacles[i].v[j].y = obstacles[i].n + 5;
}
}
}

[Chris Torek]

In article <11************ **********@g47g 2000cwa.googleg roups.com>
<jo********@gma il.com> wrote:

polygon *obstacles = malloc(sizeof *obstacles * P);
This line is good (although I would put the numeric multiplier
first, i.e.:

polygon *obstacles = malloc(P * sizeof *obstacles);

as I just find this more readable).
for(i = 0; i < P; i++)
{
obstacles[i].n = i + P * 2;
obstacles[i].v = malloc(sizeof obstacles[i].v * obstacles[i].n);

This malloc() line is ... not good. A malloc() call should read:

var = malloc(number * sizeof *var);

or (with your multiplication order);

var = malloc(sizeof *var * number);

The last line quoted above is missing a character. Is it obvious
yet which one? :-)
--
In-Real-Life: Chris Torek, Wind River Systems
Salt Lake City, UT, USA (40°39.22'N, 111°50.29'W) [phone]
email: forget about it http://web.torek.net/torek/index.html
Reading email is like searching for food in the garbage, thanks to spammers.

[stathis gotsis]

<jo********@gma il.com> wrote in message
news:11******** **************@ g47g2000cwa.goo glegroups.com.. .

Hi I hope I got the topic right..

that's what I'm doing:
create P(variable) polygons each having a variable numbers of vertices,
something in my mallocs is wrong... since I get weird results.

help?

#include <stdio.h>
#include <stdlib.h>

typedef struct point
{
double x, y;
} point;

typedef struct polygon
{
int n;
point *v;
} polygon;

typedef struct line
{
point p1, p2;
double A, B;
} line;

#define P 2

int main()
{
int i = 0, j = 0;

polygon *obstacles = malloc(sizeof *obstacles * P);

for(i = 0; i < P; i++)
{
obstacles[i].n = i + P * 2;
obstacles[i].v = malloc(sizeof obstacles[i].v * obstacles[i].n);
You mean: sizeof *obstacles[i].v
for(j = 0; j < obstacles[i].n; i++)
You mean: j++
{
obstacles[i].v[j].x = obstacles[i].n;
obstacles[i].v[j].y = obstacles[i].n + 5;
}
}
Maybe you should consider returning 0 here. }

[Pedro Graca]

jo********@gmai l.com wrote:

that's what I'm doing:
create P(variable) polygons each having a variable numbers of vertices,
something in my mallocs is wrong... since I get weird results.

help?
<snip> #define P 2

int main()
{
int i = 0, j = 0;

polygon *obstacles = malloc(sizeof *obstacles * P);

for(i = 0; i < P; i++)
{ <snip> for(j = 0; j < obstacles[i].n; i++)

_______________ _______________ _______________ __^^^__

Don't you mean j++

--
If you're posting through Google read <http://cfaj.freeshell. org/google>

[johnsolver]

Bugger, I deserve this, mixing up i's and j's ... and forgetting the *,
many thanks. One more point on the same subject, I was wandering how do
I rewrite the above code using the (->) operator instead of the indices
[k] method I used?

Theanks.

[Chris Torek]

In article <11************ **********@o13g 2000cwo.googleg roups.com>
<jo********@gma il.com> wrote:

... One more point on the same subject, I was wandering how do
I rewrite the above code using the (->) operator instead of the indices
[k] method I used?

Well, the code is no longer "above", but an example line in question
was something like:

p[i].member[j].member2 = val;

Any time you see a[b], you can rewrite it as (*((a) + (b))) -- and
often several of the parentheses are unneeded -- so this could be
written:

(*((*(p + i)).member + j)).member2 = val;

Any time you see (*(expr)).membe r, you can rewrite it as (expr)->member,
i.e., remove the asterisk and replace the dot with "->" -- and again
you can remove various unneeded parentheses -- so the above can be
re-rewritten as:

(((p + i))->member + j)->member2 = val;

The intermediate form is *much* worse than the original array syntax,
and the final form is *still* worse than the original array syntax --
so stick with the array syntax. :-)

Note, incidentally, that since p->memb is equvalent to (*p).memb,
and *p is equivalent to p[0], p->memb can always be rewritten
as p[0].memb, too. This is mainly useful for obfuscating code. :-)
--
In-Real-Life: Chris Torek, Wind River Systems
Salt Lake City, UT, USA (40°39.22'N, 111°50.29'W) [phone]
email: forget about it http://web.torek.net/torek/index.html
Reading email is like searching for food in the garbage, thanks to spammers.

[johnsolver]

Chris Torek wrote:
so the above can be

re-rewritten as:

(((p + i))->member + j)->member2 = val;

The intermediate form is *much* worse than the original array syntax,
and the final form is *still* worse than the original array syntax --
so stick with the array syntax. :-)

Yeah I've stumbled upon it when trying to rewrite, the thing is that
I've seen in many places advices on the use of the -> operator as being
'easier' and clearer way, seems like this isn't the case.

Many thanks.