C / C++ / MFC

4-Sep-12 8:59

Rahul from Poona wrote:
as far as I know byData[1] declares a byte array of variable length

BYTE byData[1]; declares an array of BYTEs, of length 1.

C/C++ does not have variable length arrays.

Re: Structure containing byte[1] as member variable

jschell4-Sep-12 11:32

Re: Structure containing byte[1] as member variable

4-Sep-12 11:32

Chris Losinger wrote:
C/C++ does not have variable length arrays.

However that type of structure is a very common idiom in C and probably in C++ in certainly situations.

And in common usage the array size would be determined at run time - thus dynamic by most definitions.

C^hris L^osinger4-Sep-12 11:42

4-Sep-12 11:42

jschell wrote:

And in common usage the array size would be determined at run time - thus dynamic by most definitions.

well, it would be malloc'd by the programmer. that's not really a dynamic array, that's just malloc.

Re: Structure containing byte[1] as member variable

jschell5-Sep-12 11:28

Re: Structure containing byte[1] as member variable

5-Sep-12 11:28

Chris Losinger wrote:
that's not really a dynamic array, that's just malloc.

No idea what that is supposed to mean.

Perhaps you are referring to a C++ array that sizes itself (at least conceptually) according to the data in it. And of course it does that by dynamically, rather than statically, allocating memory.

C^hris L^osinger5-Sep-12 11:51

5-Sep-12 11:51

i'm saying that silly array-of-one hack doesn't do it for you. there's nothing 'dynamic' about the array of one. you still have to go and malloc the memory explicitly.

Re: Structure containing byte[1] as member variable

jschell6-Sep-12 8:31

Re: Structure containing byte[1] as member variable

6-Sep-12 8:31

Chris Losinger wrote:
there's nothing 'dynamic' about the array of one. you still have to go and
malloc the memory explicitly.

And what I am saying is that your definition of static/dynamic does not fit the norm.

Mine does.

Static allocation

http://en.wikipedia.org/wiki/Static_memory_allocation[^]

Dynamic allocation

http://en.wikipedia.org/wiki/Dynamic_memory_allocation#Dynamic_memory_allocation[^]

C^hris L^osinger6-Sep-12 9:19

6-Sep-12 9:19

guess what, words have synonyms.

you know, like when you started using the word "dynamic" to describe what i and the OP were calling "variable length"

Re: Structure containing byte[1] as member variable

jschell13-Sep-12 8:07

Re: Structure containing byte[1] as member variable

13-Sep-12 8:07

Chris Losinger wrote:
guess what, words have synonyms.

Guess what... I said "thus dynamic by most definitions".

Chris Losinger wrote:
you know, like when you started using the word "dynamic" to describe what i and
the OP were calling "variable length"

My usage of that word is a commonly known term for that. As the links that I posted demonstrate.

C^hris L^osinger13-Sep-12 8:11

13-Sep-12 8:11

you changed the subject. i didn't follow your lead. hence your confusion.

Re: Structure containing byte[1] as member variable

jschell14-Sep-12 8:41

Re: Structure containing byte[1] as member variable

14-Sep-12 8:41

Chris Losinger wrote:
you changed the subject. i didn't follow your lead. hence your confusion.

No confusion on my part.

My first post was in response to your post in which you implicitly suggested that it wasn't possible to create an array in C/C++ at run time.

And then you decided to apply a non-standard definition to the word "dynamic".

Stefan_Lang5-Sep-12 1:57

Stefan_Lang

5-Sep-12 1:57

Calling it an idiom may be misleading - it may be commonly used, but it is most certainly not a recommended practice, and technically not even supported by the standard. Moreover, while it probably works (depending on the strictness of the compiler) in C++, there are much better ways to create dynamic arrays. In fact you have to look no further than std::vector .

In any case, you have to be very careful about allocating and deallocating your structs in exactly the right way. In C++ you could write your own constructor and destructor, but in C it's easy to mess it up, and the compiler won't notice because you actively worked around it.

P.S.: you can certainly use that construct dynamically, but it's also possible to define an instance of that type on the stack instead if you know the required size at compile time. All you need is a sufficiently large char array, and then assign your struct pointer to the start of that array.

Re: Structure containing byte[1] as member variable

jschell5-Sep-12 11:26

Re: Structure containing byte[1] as member variable

5-Sep-12 11:26

Stefan_Lang wrote:
Calling it an idiom may be misleading - it may be commonly used, but it is most
certainly not a recommended practice, and technically not even supported by the
standard.

First part is an opinion but feel free to substantiate it.

Second part there is nothing in ANSI C prior to C99 that disallows it, and except for unusual uses is in specifically defined. And more than that C99 specifically allows for 'flexible array structure' to explicitly define the behavior. See the following link and search for 'flexible' (and note that that that compiler actually extends the support for the type.)

http://pic.dhe.ibm.com/infocenter/lnxpcomp/v121v141/index.jsp?topic=%2Fcom.ibm.xlcpp121.linux.doc%2Flanguage_ref%2Fstrct.html[^]

Stefan_Lang wrote:
in C++, there are much better ways to create dynamic arrays. In fact you have
to look no further than std::vector .

Yep - in C++. But not in C.

Stefan_Lang wrote:
In any case, you have to be very careful about allocating and deallocating

Yes. Just as you must be careful about anything involving pointers and memory in C/C++. But that doesn't have anything to do with what I said.

Stefan_Lang wrote:
but it's also possible to define an instance of that type on the stack instead
if you know the required size at compile time.

Except that is exactly the point - it isn't known at compile time. And moreover, if it was known at compile time they you could create it dynamically as well.

So what does any of that have to do with creating it dynamically or on the stack?

Stefan_Lang6-Sep-12 2:53

Stefan_Lang

6-Sep-12 2:53

jschell wrote:
First part is an opinion but feel free to substantiate it.

I have deliberately used "may" because it does indeed reflect an opinion. From a C++ programmers point of view it's terribad. From a C-programmers view it admittedly doesn't look bad at all. It looks like a reasonable workaround to overcome a limitation of the language. However, using such structs breaks expectations, such as
a) that a data structure is always the same size, and that size can be determined using sizeof()
b) that an instance of that data structure looks exactly like defined in the header
c) that you can create instances normally, using alloc(sizeof(mystruct))

You need to make sure that everyone seeing that data structure definition in a header understands that (a), (b), and (c) above no longer hold, and what you are supposed to do instead. This information can only be passed by comments, not via source code, and the compiler has no way of telling whether you're doing it right.

I didn't know that this stuff is actually being supported by some compilers (or at least one?) Thanks for the link - you learn something new every day...

jschell wrote:
Just as you must be careful about anything involving pointers and memory in C/C++.

That is not quite the same. See my comments above. Managing pointers and avoiding leaks is easy in comparison, and quite easily managed by a decent set of guidelines.

jschell wrote:
<layer>Except that is exactly the point - it isn't known at compile time.

Maybe it isn't. But maybe it is - and that is exactly my point.

An example would be a struct for storing string-based data fields from a database, where each column of a table may have a different size. Generally you'd query the field size before allocating the proper amount of memory for your struct. But when a function references a specific field, then you know at compile time which field that is, and how much memory you need. So you could define a sufficiently large memory block an the stack to store values within that function.

Not saying that this is a good idea: where one programmer might consider 2 characters to be "sufficient" to store a year entry, others accessing the same struct might expect 4 characters. Enter the Y2K crisis! Wink | ;)

Re: Structure containing byte[1] as member variable

jschell6-Sep-12 8:28

Re: Structure containing byte[1] as member variable

6-Sep-12 8:28

Stefan_Lang wrote:
From a C++ programmers point of view it's terribad

In general I would agree with that statement.

Stefan_Lang wrote:
However, using such structs breaks expectations...,

I would expect that at experienced C developer would be familar with the idiom and thus would adjust their expectations accordingly.

Stefan_Lang wrote:
This information can only be passed by comments

Myself I would indeed comment it. But in my experience I comment code much more than almost everyone else. I have in fact never worked with anyone that comments code as rigorously as I do.

Stefan_Lang wrote:
not via source code, and the compiler has no way of telling whether you're doing
it right.

Actually the source code, as per many other idioms, is in fact a method of learning how it works. And often the only way for many idioms regardless of how apt they are or not.

And for C there are many things that the compiler can't check.

Stefan_Lang wrote:
Managing pointers and avoiding leaks is easy in comparison, and quite easily
managed by a decent set of guidelines.

Myself I find using the idiom easy. There are far more complicated things in C such as building deep data hierarchies dynamically.

Stefan_Lang wrote:
So you could define a sufficiently large memory block an the stack to store
values within that function.

Your description is not that clear but best I can tell it is not an apt use for this idiom. Incorrect usage does not of course invalidate the idiom itself.

Richard MacCutchan4-Sep-12 9:07

Richard MacCutchan

4-Sep-12 9:07

This will just lead to program crashes, incorrect results and other strange happenings. You must not write into memory that you have not allocated in advance. If you already have the data in memory chReadData then all you need to do is set a pointer to that data which is of the structure type, like:

C++

struct MessagData
{
    DWORD dwSize;
    BYTE byData[1];
}
char chReadData[100];
// fill chReadData with the information from external source
MessagData* pMessagData = reinterpret_cast<MessagData*>(chReadData);
// The reinterpret_cast operation tells the compiler you know that
// the structure of chReadData is the same as your structure.

One of these days I'm going to think of a really clever signature.

Re: Structure containing byte[1] as member variable

Rahul from Poona4-Sep-12 20:00

Rahul from Poona

4-Sep-12 20:00

first of all I would like to mention that pointer to structure contains two variables 1. size of data and 2.Byte array to store the data. So following line is not applicable here
MessagData* pMessagData = reinterpret_cast<messagdata*>(chReadData);

Second thing i have to assign this data along with size means structure to some out pointer of same data type.that is why I have used memcpy.but after assigning it to out pointer i m trying to delete this memory(which I have assigned here as shown in code.

And i would like to add one more thing in my question
I have made a queue as shown below
std::queue<messagdata*> qDataQueue;
initially I am pushing the structure pointer in one thread after filling the data as shown below

MessagData* pdata = new MessagData;
//read data is filled in pData
qDataQueue.push(pData)
Then in other thread i am poppin out this data in a pointer of same structure type and trying to delete that pointer then it is showing the mentioned error:

MessagData* pTempdata = qDataQueue.front();
//problem occurs in following line
delete pTempdata;

Re: Structure containing byte[1] as member variable

Richard MacCutchan4-Sep-12 21:46

Richard MacCutchan

4-Sep-12 21:46

Rahul from Poona wrote:
So following line is not applicable here

I had mis-read your question, and assumed that the data was presented in that format. In your original question you do not specify how you get the value of dwSize, but assuming you have some way of finding it then you need to do something like:

C++

struct MessagData
{
    DWORD dwSize;
    BYTE byData[1];
}
char chReadData[100];
int dwNumberRead;
// fill chReadData with the information from external source
// and set dwNumberRead to the length of the data

// now allocate a structure that is big enough to hold this data
// copy the data into the structure and set its length member variable
MessagData* pMessagData = (MessagData*)new BYTE[sizeof(MessagData) + dwNumberRead];
memcpy(pMessagData->byData, chReadData, dwNumberRead);
pMessagData->dwSize = dwNumberRead;

[edit]Added quick and dirty cast[/edit]

BTW please use the code block and var buttons above to add the correct HTML tags, <pre> or <code> to your code rather than making it bold, as I have done here.

One of these days I'm going to think of a really clever signature.

Re: Structure containing byte[1] as member variable

jschell4-Sep-12 11:46