Re: Non-null pointers in C/C++?

angel_tsankov wrote:
> On 29 =ED=C1=CA, 18:58, James Kuyper <jameskuy...@[EMAIL PROTECTED]
> wrote:
>> angel_tsankov wrote:
>>> On 23 =ED=C1=CA, 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 different
>> 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 a=
t.
>> How could such an implementation implement malloc2() so it would know
>> 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.
>=20
> 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=20
malloc(), we were talking about malloc2(). As described above, it takes=20
an unnullable pointer argument that is used to initialize the memory=20
allocated by malloc2(). Since unnullable pointers could, presumably,=20
have many different types, with correspondingly different sizes and=20
different representations, malloc2() could not work without being type=20
aware. Here's code for a hypothetical language with C++ - style=20
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;
}

The marked line has to be type-aware, because sizeof(T*) can depend
upon=20
what T is.

>> Would it be prohibited for a structure to contain a member of unnullab=
lepointertype? If not, how do you tell malloc2() where to insert thepoint=
erthat it takes as an argument, when allocating space for such a
>> structure?

Have you figured out an answer to that question?

>> Could you allocate an array of unnullable pointers? Does that mean tha=
t
>> malloc2() would have to be prepared to accept an unlimited number ofpo=
interarguments as initializers, presumably by using a <varargs.h>
>> interface? Or would it initialize all of them to point at the same
>> object, and let them be reassigned later? Unlike the previous issues,
>> this one has at least two different perfectly feasible solutions; but
>> you'll have to choose one.
>=20
> Automatic arrays would either be randomly initialized or prohibited.

I thought that the point of unnullable pointers was to ensure that they=20
could not be null? If they can, under certain cir***stances, be
randomly=20
initialized, doesn't that defeat the purpose?
-- 
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.