Re: baffled by 'new' operator with array type.
On 2013-07-06, Ray Dillinger <bear@sonic.net> wrote:
I have the following type declarations, which I thought were quite simple;
const uint16_t SUBTREES = 64;
typedef struct stringnode *strpt; // a strpt is a pointer to a struct stringnode.
typedef strpt branchtype [SUBTREES]; // a branchtype is an array of SUBTREES strpt.
and the following function, which also seems simple. (I have added the line numbers
at the front so you can see which lines the error messages refer to).
132: // allocate and return a subtree, copied from argument within the (modular) range specified
133: branchtype *branchcopy(const branchtype * const subtrees, const int start, const int end){
134: branchtype *newbranch = new(branchtype);
135: int count;
136: for (count = start; count != end; count = (count + 1) % SUBTREES)
137: newbranch[count] = subtrees[count];
138: return(newbranch);
139: }
This function is supposed to allocate a new branchtype (via a pointer to it which is
named newbranch) and then copy a subrange of an existing branchtype (whose address
it gets via its argument subtrees) to it. The subrange copied is intended to be
'modular' in that if 'end' is less than 'start' it copies a subrange from 'start'
to the end of the array, then continues from the beginning of the array to 'end'.
When compiling this function, I get the following errors and I don't understand
what I've done wrong.
string3.cpp:133:41: error: cannot convert ?stringnode**? to ?stringnode* (*)[64]? in initialization
string3.cpp:136:38: error: invalid array assignment
I think that the first error message is baffling because it seems to imply that
new(branchtype) is returning something other than a pointer to branchtype. (ie,
in this case a pointer to an array of pointers at struct stringnodes). I can't
figure out how that could happen after reading the documentation of 'new'. I
could, but wouldn't like, to simply drop 'new' and use 'calloc' and static cast
instead.
While reading the documentation for new, you must have missed the part about
new of an array returning a pointer to the first element of the array (not
a pointer to the array).
Due to the typedefs, the expression new(branchtype) is equivalent to
new(*stringnode[64]). A pointer to the first element of such an array is of
type **stringnode. The error message you get states that the value of type
**stringnode returned by the new expression, cannot be converted to what is on
the left hand side of the assignment operbator.
The second error message is baffling because subtrees is a (const) pointer to (const)
branchtype and newbranch is very explicitly declared to be a pointer to branchtype,
so they are clearly the same type, and I'm trying to modify the contents of the non-
const one, not the const one. The error message is documented to mean I have
attempted to assign to an array (in violation of standard, I know), but AFAIK
there isn't anything wrong with assigning to a single element of an array. If
I understand my declarations correctly, the elements of branchtype are pointers,
not arrays. Why does it think I'm making an assignment to an array here instead
of an assignment to a pointer (which happens to be one element of an array)?
Due to the typedefs, the type of the variable subtrees is stringnode*(*)[64],
the same as the type of newbranch given in the other message. The expression
stringnode[count]
is equivalent to
*(stringnode + count)
The type of (stringnode + count) is the same as that of stringnode (a pointer
to an array of 64 pointers to stringnode). Dereferencing that results in a
value whose type is an array of 64 pointers to stringnode. The assignment
statement is attempting to assign an array of 64 pointers to stringnode.
Was there something wrong with my declaration? Do these declarations not mean what
I think they mean?
[snip]
In C++, as in C, arrays are treated differently than non-arrays. Perhaps, you
mistakenly think that arrays and non-arrays are treated the same.