Struct条目声明了一个数组类型的字段，但是编译器说这是一个指针

Question

I'm trying to swap two entries in a struct.

This is the struct:

struct hdr {
    uint8_t ether_dhost[6];
    uint8_t ether_shost[6]; 
}

When I try the save these values in temporary arrays, I get this error on this line:

uint8_t original_dhost[6];
original_dhost = ethernet_hdr->ether_dhost;

incompatible types when assigning to type 'uint8_t[6]' from type 'uint8_t *'

so instead I try using a pointer rather than an array:

uint8_t *original_dhost;

Then I get no error, but when I try to assign to the ethernet_hdr->ether_dhost , I get this error:

ethernet_hdr->ether_shost = original_dhost;

 incompatible types when assigning to type 'uint8_t[6]' from type 'uint8_t *' 

How can I avoid the first error above? Specifically, why does the compiler say the field is 'uint8_t *' when I declare it as an array?

Answer 1

ether_dhost is an array. You can't copy to or from it using a simple assignment statement.

Your first error comes because ethernet_hdr->ether_dhost resolves to the address of the first element (a uint8_t pointer), but you can't assign it's value to a new array.

You need to use memcpy (or a loop) to copy all the elements:

uint8_t original_dhost[6];
memcpy(original_dhost,ethernet_hdr->ether_dhost,sizeof(original_dhost));

Answer 2

There are several issues at play here.

First of all, an array expression may not be the target of an assignment. You cannot write something like

uint8_t original_dhost[6];
original_dhost = ethernet_hdr->ether_dhost;

because the expression original_dhost is not a modifiable lvalue. There are reasons for this, which will become apparent below. To copy the contents of one array to another, you will either need to copy each element individually, or use the memcpy library function:

memcpy( original_dhost, ethernet_hdr->ether_dhost, sizeof original_dhost );

Except when it is the operand of the sizeof or unary & operators, or is a string literal being used to initialize an array in a declaration, an expression of type "N-element array of T " will be converted ("decay") to an expression of type "pointer to T ", and the value of the expression will be the address of the first element of the array. The result is not a modifiable lvalue; that is, it cannot be the target of an assignment.

In the statement

original_dhost = ethernet_hdr->ether_dhost;

the expression ethernet_hdr->ether_dhost has type "6-element array of uint8_t "; since it is not the operand of either the sizeof or unary & operators, it is converted to an expression of type "pointer to uint8_t ", or uint8_t * . This type is not compatible with uint8_t [6] , hence the first error. The second error is the same problem, you've just reversed the players involved.

So why not simply convert the left hand side of the assignment to a pointer as well and let the assignment succeed? Time for a short history lesson.

C was derived from an earlier language called B, which was a "typeless" language; all data were stored in fixed-size words, or "cells", regardless of whether the data were being used to represent integers, real values, text, whatever. Memory was treated as a linear array of cells. When you declared an array in B, such as

auto arr[N];

the compiler would set aside N+1 cells; N cells for the array, and an additional cell that stored the offset to the first element of the array, which would be bound to the symbol arr , like so:

            +---+
  arr:      |   | ---+
            +---+    |
             ...     |
            +---+    |
  arr[0]:   |   | <--+
            +---+
  arr[1]:   |   |
            +---+
  arr[2]:   |   |
            +---+
             ...
            +---+
  arr[N-1]: |   |
            +---+

As in C, subscript operations like arr[i] were computed as *(arr + i) ; you added the value i to the offset value stored in arr , then dereferenced the result.

Dennis Ritchie initially kept B's array semantics as he was developing C, but he ran into a problem when he started adding the struct type to the language. He wanted the struct contents to map directly onto memory; an example he gives is of a file system entry, like

struct {
  int inode;
  char name[14];
};

He wanted the struct to contain a 2-byte integer value immediately followed by a 0-terminated string, but he couldn't figure out what to do with the pointer to the name array: should it be stored as part of the struct, or stored separately? If separately, where should it be stored?

He solved the problem by getting rid of the array pointer altogether; instead of setting aside storage for a pointer to the first element of the array, he designed the language so that the pointer value would be computed from the array expression itself. Thus, in C, when you declare an array like

T arr[N];

only N elements of type T are allocated:

            +---+    
  arr[0]:   |   | 
            +---+
  arr[1]:   |   |
            +---+
  arr[2]:   |   |
            +---+
             ...
            +---+
  arr[N-1]: |   |
            +---+

There's no separate storage bound to the symbol arr . This is why the expressions &arr and arr both yield the same value (the address of the first element in the array), even though the two expressions have different types ( T (*)[N] and T * , respectively). And this is why an array expression may not be the target of an assignment; there's nothing to assign a value to .

Answer 3

For no particular reason (besides some historical accident), in C you cannot assign arrays directly; you have to copy elements one by one (or use memcpy).

memcpy(ethernet_hdr->ether_shost,original_dhost,sizeof(original_dhost));

Answer 4

An array is a pointer to a fixed-number of contiguous objects. So to achieve your desired move, use memcpy .

Answer 5

Struct entry declares a field of type array, but compiler says it's a pointer

Because arrays almost always decay (are implicitly converted) into pointers when being referred to.

when I try to assign to the ethernet_hdr->ether_dhost, I get this error:

Sure. Arrays are not modifiable lvalues; if you want to "assign" them, you can't do that directly. Use memcpy() instead.

Answer 6

The compiler is not saying ethernet_hdr->ether_dhostt is a 'uint8_t * .
It is saying that the right-hand-side of the = is a uint8_t * as that is how arrays are converted when used as an R-value.

C11 6.3.2.1 3 "Except when it is the operand of the sizeof operator, ..., or the unary & operator, or is a string literal used to initialize an array, an expression that has type ''array of type'' is converted to an expression with type ''pointer to type'' that points to the initial element of the array object and is not an lvalue. ..."

Had OP performed the following, the expected result of 6 would occur for ethernet_hdr->ether_dhost is an array and not a pointer.

printf("%zu\n", sizeof(ethernet_hdr->ether_dhost));

---

OP can avoid this a number of ways.

1. Other have mentioned using memcpy() .

2. Assignment with arrays does not work, but assignment with structures do. By enclosing each array in a structure, the whole structure may be assigned.

3. There is a pre-C89 method, maybe-non standard way too. Not detailed here.

.

#include <stdio.h>
#include <stdlib.h>

struct U6 {
  uint8_t u[6];
};

struct hdr {
  struct U6 ether_dhost;
  struct U6 ether_shost;
};

struct hdr *ethernet_hdr;

void foo3(void) {
  struct U6 original_dhost = {{ 1,2,3,4,5,6}};
  ethernet_hdr = malloc(sizeof(*ethernet_hdr));
  ethernet_hdr->ether_dhost.u[1] = 7;
  // Copy structure
  original_dhost = ethernet_hdr->ether_dhost;
  printf("%u\n", original_dhost.u[1]);
}

int main() {
  foo3();
  return 0;
}