dynamically allocate array variable of type LPWSTR

[Trups]

HI,

I want to dynamically allocate array variable of type LPWSTR.
Code looks like this...
main() {
LPWSTR *wstr;
int count = Foo (wstr);
for (int i = 0; i < count; i++)
//print each element;

}
int Foo(LPWSTR *wstr)
{
int count = 0;
while (!done){
//Here I need to allocate "wstr" one element by one element.
How
to do that?
// I don't know the count
count ++;
}

Where should I do delete?
Thanks
Trupti

[Ulrich Eckhardt]

Trups wrote:

I want to dynamically allocate array variable of type LPWSTR.

Two things here:
1. LPWSTR is not a standard type but part of the win32 API.
2. LPWSTR is a pointer type, hence the 'P'. In fact it's a typedef for
wchar_t*.

Code looks like this...
main() {

Well, check the FAQ on this one.

LPWSTR *wstr;
int count = Foo (wstr);

You are passing the value of an uninitialised variable to a function. If you
want the function to init the variable, you need to pass its address.

int Foo(LPWSTR *wstr)
{
int count = 0;
while (!done){
//Here I need to allocate "wstr" one element by one element.
How
to do that?
// I don't know the count
count ++;
}

This looks as if you wanted to allocate an array of wchar_t strings.
However, I have actually no clue what it is that you really want.

Where should I do delete?

'delete' is a C++ thing, in C you would use malloc() and free().

Sorry, but there is too little to start with. I would suggest you get a good
book or some other tutorial that introduces you step by step to C. If
you're not familiar with programming at all, I would further suggest using
a language with less pitfalls, like e.g. Python.

Uli

[Malcolm McLean]

"Trups" <Sa***********@ gmail.comwrote in message news:

>
I want to dynamically allocate array variable of type LPWSTR.
Code looks like this...
main() {
LPWSTR *wstr;
int count = Foo (wstr);
for (int i = 0; i < count; i++)
//print each element;

}
int Foo(LPWSTR *wstr)
{
int count = 0;
while (!done){
//Here I need to allocate "wstr" one element by one element.
How
to do that?
// I don't know the count
count ++;
}

Where should I do delete?

Make sure you genuinely want a pointer to an LPWSTR. The LP is Microsoft's
way of indicating that the type is already a pointer.
However pointers to pointers are often useful. You use them for a list of
strings, for example.

In C arrays decay into pointers when you pass them to functions. Pointers
contain no size information. So you need to pass the buffer size separately.

There is no point passing an uninitialised pointer to a fucntion. C is call
by value, so you are just passing garbage.

I can't determine exactly what you want to do from your code. However it
looks like

int Foo(LPWSTR *ptr, int N)
{
int i;

for(i=0;i<N;i++ )
ptr[i]= malloc(M * sizeof(WSTR));
}

where WSTR is whatever an LPWSTR points to, M is the number of them you want
in your array.

--
Free games and programming goodies.
http://www.personal.leeds.ac.uk/~bgy1mm

[blargg]

Malcolm McLean wrote:
[...]

int Foo(LPWSTR *ptr, int N)
{
int i;

for(i=0;i<N;i++ )
ptr[i]= malloc(M * sizeof(WSTR));
}

where WSTR is whatever an LPWSTR points to, M is the number of them you want
in your array.

Here's how you allocate without having to know the type of the object
pointed to:

ptr[i] = malloc(M * sizeof *ptr[i]);

It's a good practice to make a habit of, because it removes a point of
redundancy and thus a point of possible inconsistency.

[Richard Heathfield]

blargg said:

Malcolm McLean wrote:
[...]

>int Foo(LPWSTR *ptr, int N)
{
int i;

for(i=0;i<N;i++ )
ptr[i]= malloc(M * sizeof(WSTR));
}

where WSTR is whatever an LPWSTR points to, M is the number of them you
want in your array.

Here's how you allocate without having to know the type of the object
pointed to:

ptr[i] = malloc(M * sizeof *ptr[i]);

It's a good practice to make a habit of, because it removes a point of
redundancy and thus a point of possible inconsistency.

You are, of course, correct; in general, for p of any object type, the
template p = malloc(n * sizeof *p) is superior. But Malcolm has been
posting here for several years at least. The probability that he does not
already know this is vanishingly small. I conclude that he disagrees with
the rationale. I have no idea why he would disagree, but Malcolm often has
rather off-the-wall ideas about programming, so it wouldn't surprise me in
the slightest if his views on malloc are strange too.
--
Richard Heathfield <http://www.cpax.org.uk >
Email: -http://www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999

[Richard Heathfield]

blargg said:

Malcolm McLean wrote:
[...]

>int Foo(LPWSTR *ptr, int N)
{
int i;

for(i=0;i<N;i++ )
ptr[i]= malloc(M * sizeof(WSTR));
}

where WSTR is whatever an LPWSTR points to, M is the number of them you
want in your array.

Here's how you allocate without having to know the type of the object
pointed to:

ptr[i] = malloc(M * sizeof *ptr[i]);

It's a good practice to make a habit of, because it removes a point of
redundancy and thus a point of possible inconsistency.

You are, of course, correct; in general, for p of any object type, the
template p = malloc(n * sizeof *p) is superior. But Malcolm has been
posting here for several years at least. The probability that he does not
already know this is vanishingly small. I conclude that he disagrees with
the rationale. I have no idea why he would disagree, but Malcolm often has
rather off-the-wall ideas about programming, so it wouldn't surprise me in
the slightest if his views on malloc are strange too.
--
Richard Heathfield <http://www.cpax.org.uk >
Email: -http://www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999

[John Bode]

On Oct 31, 9:07 am, Trups <Samant.Tru...@ gmail.comwrote:

HI,

I want to dynamically allocate array variable of type LPWSTR.
Code looks like this...

main() {
LPWSTR *wstr;
int count = Foo (wstr);
for (int i = 0; i < count; i++)
//print each element;

}

int Foo(LPWSTR *wstr)
{
int count = 0;
while (!done){
//Here I need to allocate "wstr" one element by one element.
How
to do that?
// I don't know the count
count ++;
}

Where should I do delete?

Thanks
Trupti

The general procedure for dynamically allocating an N-element array of
any type T is

T *array = malloc(sizeof *array * numberOfElement s);

That's if you know the number of elements to allocate ahead of time.
If you're allocating the array one element at a time, the procedure is
a little more complicated:

T *array = NULL, *tmp;
size_t arraySize = 0;
int done = 0;

/*
** Continue allocating elements until some condition is true
*/
while (!done)
{
/*
** if realloc cannot extend the array, it will return NULL
*/
tmp = realloc(array, sizeof *array * arraySize + 1);
if (!tmp)
{
/* realloc failed, handle error */
}
else
{
array = tmp;
arraySize++;
}

/* check if done */
}

[Malcolm McLean]

"Richard Heathfield" <rj*@see.sig.in validwrote in message news

blargg said:

>Malcolm McLean wrote:
[...]

>>int Foo(LPWSTR *ptr, int N)
{
int i;

for(i=0;i<N;i++ )
ptr[i]= malloc(M * sizeof(WSTR));
}

where WSTR is whatever an LPWSTR points to, M is the number of them you
want in your array.

Here's how you allocate without having to know the type of the object
pointed to:

ptr[i] = malloc(M * sizeof *ptr[i]);

It's a good practice to make a habit of, because it removes a point of
redundancy and thus a point of possible inconsistency.

You are, of course, correct; in general, for p of any object type, the
template p = malloc(n * sizeof *p) is superior. But Malcolm has been
posting here for several years at least. The probability that he does not
already know this is vanishingly small. I conclude that he disagrees with
the rationale. I have no idea why he would disagree, but Malcolm often has
rather off-the-wall ideas about programming, so it wouldn't surprise me in
the slightest if his views on malloc are strange too.

Firstly, for pedagogical reasons I think the pointer dereference that isn't
really is a source of confusion. It is easier to think of sizeof() being
applied to a type.

My other objection is that the pointer in which the return address of
malloc() is stored can have a rather long identifier. Here it is only
ptr[i], but it can easily by

employees->bonuslist[employees->Nlists];
--
Free games and programming goodies.
http://www.personal.leeds.ac.uk/~bgy1mm

[blargg]

In article <9f************ *************** ***@bt.com>,
"Malcolm McLean" <re*******@btin ternet.comwrote :

"Richard Heathfield" <rj*@see.sig.in validwrote in message news

blargg said:

Malcolm McLean wrote:
[...]
int Foo(LPWSTR *ptr, int N)
{
int i;

for(i=0;i<N;i++ )
ptr[i]= malloc(M * sizeof(WSTR));
}

where WSTR is whatever an LPWSTR points to, M is the number of them you
want in your array.

Here's how you allocate without having to know the type of the object
pointed to:

ptr[i] = malloc(M * sizeof *ptr[i]);

It's a good practice to make a habit of, because it removes a point of
redundancy and thus a point of possible inconsistency.

You are, of course, correct; in general, for p of any object type, the
template p = malloc(n * sizeof *p) is superior. But Malcolm has been
posting here for several years at least. The probability that he does not
already know this is vanishingly small. I conclude that he disagrees with
the rationale. I have no idea why he would disagree, but Malcolm often has
rather off-the-wall ideas about programming, so it wouldn't surprise me in
the slightest if his views on malloc are strange too.

Firstly, for pedagogical reasons I think the pointer dereference that isn't
really is a source of confusion. It is easier to think of sizeof() being
applied to a type.

I somewhat agree. On the other hand, by avoiding using sizeof object
early on, the student isn't given an opportunity to become familiar.

My other objection is that the pointer in which the return address of
malloc() is stored can have a rather long identifier. Here it is only
ptr[i], but it can easily by

employees->bonuslist[employees->Nlists];

employees->bonuslist[employees->Nlists] =
malloc( sizeof *employees->bonuslist[0] );

[Malcolm McLean]

"blargg" <bl********@gis hpuppy.comwrote in message news:

In article <9f************ *************** ***@bt.com>,
"Malcolm McLean" <re*******@btin ternet.comwrote :

>"Richard Heathfield" <rj*@see.sig.in validwrote in message news

blargg said:

Malcolm McLean wrote:
[...]
int Foo(LPWSTR *ptr, int N)
{
int i;

for(i=0;i<N;i++ )
ptr[i]= malloc(M * sizeof(WSTR));
}

where WSTR is whatever an LPWSTR points to, M is the number of them
you
want in your array.

Here's how you allocate without having to know the type of the object
pointed to:

ptr[i] = malloc(M * sizeof *ptr[i]);

It's a good practice to make a habit of, because it removes a point of
redundancy and thus a point of possible inconsistency.

You are, of course, correct; in general, for p of any object type, the
template p = malloc(n * sizeof *p) is superior. But Malcolm has been
posting here for several years at least. The probability that he does
not
already know this is vanishingly small. I conclude that he disagrees
with
the rationale. I have no idea why he would disagree, but Malcolm often
has
rather off-the-wall ideas about programming, so it wouldn't surprise me
in
the slightest if his views on malloc are strange too.

Firstly, for pedagogical reasons I think the pointer dereference that
isn't
really is a source of confusion. It is easier to think of sizeof() being
applied to a type.

I somewhat agree. On the other hand, by avoiding using sizeof object
early on, the student isn't given an opportunity to become familiar.

>My other objection is that the pointer in which the return address of
malloc() is stored can have a rather long identifier. Here it is only
ptr[i], but it can easily by

employees->bonuslist[employees->Nlists];

employees->bonuslist[employees->Nlists] =
malloc( sizeof *employees->bonuslist[0] );

That's not a bad idea.
Now you're breaking the symmetry that the sizeof the object that is pointed
to by the return of malloc() is taken.
In fact you'd need more than one of them. So make that

malloc(employee s->Nbonuses * sizeof *employees->bonuslist[0]);

and of course the asterisk is being used in two different contexts.

--
Free games and programming goodies.
http://www.personal.leeds.ac.uk/~bgy1mm