To: comp.lang.c.moderated moderators: I posted a previous version of=20
this post yesterday, which was missing a single character that rendered=20
it incorrect. It's not yet visible on my news server, in either=20
newsgroup. If it's not too late, please reject that message. Thanks!
[oops, a bit late. here we go with the fixed one, then - mod]
angel_tsankov wrote:
> On 2 =D0=AE=D0=BD=D0=B8, 19:54, James Kuyper <jameskuy...@[EMAIL PROTECTED]
> =
wrote:
>> angel_tsankov wrote:
>>> On 29 =C3=AD=C3=81=C3=8A, 18:58, James Kuyper <jameskuy...@[EMAIL PROTECTED]
> wrote:
>>>> angel_tsankov wrote:
>>>>> On 23 =C3=AD=C3=81=C3=8A, 23:57, jameskuy...@[EMAIL PROTECTED]
wrote:
>> ...
>>>>>> It would also have to be constraint violation for an
>>>>>> object with an unnullablepointertype to be left uninitialized. As =
a
>>>>>> result, I don't think it would be feasible to allow the space
>>>>>> containing an unnullablepointerobject to be allocated using the
>>>>>> malloc() family.
>>>>> One could have malloc2(), taking an unnullablepointerthat would
>>>>> serve as initilizer for the malloc'ed unnullablepointer.
>>>> The C standard currently allows for the possibility that pointers to
>>>> different types can have different representations, and even differe=
nt
>>>> sizes. There are a number of good reasons why many real-world
>>>> implementations actually use two or more differentpointer
>>>> representations, depending upon the type of the object being pointed=
at.
>>>> How could such an implementation implement malloc2() so it would kno=
w
>>>> which representation to use? It would be relatively straightforward =
to
>>>> handle that case by making malloc2() a C++ template function, but I
>>>> don't see any easy way to do it in C.
>>> I do not really get your point here... As far as I know malloc does
>>> not care about types - it only cares about allocating memory of the
>>> specified amount.
>> You are perfectly correct about malloc(); but we weren't talking about
>> malloc(), we were talking about malloc2(). As described above, it take=
s
>> an unnullable pointer argument that is used to initialize the memory
>> allocated by malloc2(). Since unnullable pointers could, presumably,
>> have many different types, with correspondingly different sizes and
>> different representations, malloc2() could not work without being type
>> aware. Here's code for a hypothetical language with C++ - style
>> templates and an 'unnullable' keyword:
>>
>> template <type T> unnullable T** malloc2(unnullable T *t, size_t size)
>> {
>> T** temp =3D malloc(size);
>> if(temp)
>> temp[0] =3D (T*)t; // Must be type-aware
>>
>> return (unnullable T**) temp;
>>
>> }
>=20
> Why not:
> unnullable void** malloc2(unnullable void const* initial_value, size_t
> size)
> {
> void** new_ptr =3D malloc(size);
> if(new_ptr !=3D NULL)
> {
> *new_ptr =3D initial_value;
> }
>=20
> return (unnullable void**)new_ptr;
> }
>=20
> If think the above sample implementation of malloc2 should do,
> provided that a conversion from T* to void*, and back to T*, always
> yields the initial value for any type T (which I think is guaranteed
> by the standard).
Yes, but that implementation only allows the initialization of
unnullable void* pointers; it doesn't allow the initialization of any
other pointer type. Therefore, if malloc2() is your only proposed
mechanism for allowing the initialization of unnullable pointers in
dynamically allocated memory, then no other unnullable pointer types can
reside in such memory. With references in C++, there's no corresponding
problem, because the constructor for any object type containing a
reference is responsible for initializing it, and the 'new' operator
causes the constructor to be called on the newly allocated memory.
>>>> Would it be prohibited for a structure to contain a member of unnull=
ablepointertype? If not, how do you tell malloc2() where to insert thepoi=
nterthat it takes as an argument, when allocating space for such a
>>>> structure?
>> Have you figured out an answer to that question?
I gather that you have not, since you didn't bother to answer it. You
know, "I don't know" is a perfectly acceptable answer.
Your solution, like mine, still suffers from only be able to initialize
a pointer that occupies the initial bytes of the allocated memory.
....
> -as to malloc2, if we cannot have it, then we won't have it (C++
> references cannot be allocated on the heap either);
Not directly, but it can be done indirectly:
#include <cstdlib>
#include <memory>
struct ReferenceHolder
{
int &ri;
ReferenceHolder(int &i):ri(i){}
};
int main()
{
int j;
ReferenceHolder *rj;
ReferenceHolder *rk;
rj =3D new ReferenceHolder(j);
rk =3D static_cast<ReferenceHolder*>(std::malloc(sizeof *rk));
new(rk) ReferenceHolder(j); // inplace construction
int retval =3D (&(rj->ri) =3D=3D &(rk->ri)) ? EXIT_SUCCESS : EXIT_FA=
ILURE;
std::free(rk);
delete(rj);
return retval;
}
This relies upon the existence of constructors in C++. I've no idea how
you could do something similar in C+unnullable.
--
comp.lang.c.moderated - moderation address: clcm@[EMAIL PROTECTED]
-- you must
have an appropriate newsgroups line in your header for your mail to be
seen,
or the newsgroup name in square brackets in the subject line. Sorry.
|
