问题引入
在编译下面一段代码时，无意中发现了这样一个错误：
.....
typedef nx_struct test_msg { nx_uint8_t data[]; } test_msg_t
.....
错误:
van9ogh@WSN:Git$ gcc test.c test.c:4: error: flexible array member in otherwise empty struct
但如果换成这样:
.....
typedef nx_struct test_msg {
nx_uint8_t counter;
nx_uint8_t data[];
} test_msg_t
.....
编译是没有问题的，现在我们再换一下，
.....
typedef nx_struct test_msg {
nx_uint8_t counter;
nx_uint8_t data[];
nx_uint8_t data2[]；
} test_msg_t
.....
编译如下:
van9ogh@WSN:Git$ gcc test.c test.c:5: error: flexible array member not at end of struct
这...，其实仔细想想，对阿，这不是让编译器为难吗，到底data2[]的首地址怎么办阿?!
TinyOS
好了，在tinyos中我们发现了很多这样的data[]，没有指定具体的数组大小，
比如，串口通信中/tos/lib/Serial.h
typedef nx_struct serial_header {
nx_am_addr_t dest;
nx_am_addr_t src;
nx_uint8_t length;
nx_am_group_t group;
nx_am_id_t type;
} serial_header_t;
typedef nx_struct serial_packet {
serial_header_t header;
nx_uint8_t data[];
} serial_packet_t;
那么这个data[]在这里到底起到什么作用呢?
其实就是保存上层数据帧地址的作用，我们举一个demo，具体代码请去
tinyos-2.x-contrib项目的tinyos-programming/ReliableTestSerial去查看;
说明:ReliableTestSerial是tinyos源码包中apps/tests/TestSerial的升级版，旨在提供一个可靠的PC-Mote串口通信,
主要组件:TestSerialC.nc：提供Ack机制的AMSend,Receive，底层通过Timer,SubSend,AckSend, SubReceive, AckReceive实现
客户端应用程序调用该组件提供的AMSend和Receive就可以可靠的进行串口通信.
ReliableSerialC.nc
/*
* Copyright (c) 2007-2009 Intel Corporation
* All rights reserved.
* This file is distributed under the terms in the attached INTEL-LICENS
* file. If you do not find this file, a copy can be found by writing to
* Intel Research Berkeley, 2150 Shattuck Avenue, Suite 1300, Berkeley, CA,
* 94704. Attention: Intel License Inquiry.
*/
#include "reliableserial.h"
module ReliableSerialC
{
provides {
interface AMSend;
interface Receive;
}
uses {
interface AMSend as SubSend;
interface AMSend as AckSend;
interface Receive as SubReceive;
interface Receive as AckReceive;
interface Timer<TMilli>;
}
}
implementation
{
message_t ackmsg;
bool ackBusy;
message_t *sending;
uint8_t sendLen;
am_addr_t sendAddr;
uint8_t dropCount;
uint8_t sendCookie = 1, recvCookie;
void done(error_t ok) {
message_t *sent = sending;
sending = NULL;
sendCookie *= 3; /* New cookie time! Cycles every 64 cookies. */
signal AMSend.sendDone(sent, ok);
}
default event void AMSend.sendDone(message_t *msg, error_t error) { }
command error_t AMSend.send(am_addr_t addr, message_t* msg, uint8_t len) {
error_t ok = EBUSY;
if (!sending)
{
reliable_msg_t *header = call SubSend.getPayload(msg, sizeof(reliable_msg_t));
header->cookie = sendCookie;
ok = call SubSend.send(addr, msg, len + sizeof(reliable_msg_t));
if (ok == SUCCESS)
{
sending = msg;
sendAddr = addr;
sendLen = len;
}
}
return ok;
}
event void SubSend.sendDone(message_t *msg, error_t error) {
if (error == SUCCESS)
call Timer.startOneShot(ACK_TIMEOUT);
else
done(error);
}
event void Timer.fired() {
error_t ok = call SubSend.send(sendAddr, sending, sendLen + sizeof(reliable_msg_t));
if (ok != SUCCESS)
done(ok);
}
event message_t *AckReceive.receive(message_t *m, void *payload, uint8_t len) {
ack_msg_t *ack = payload;
#ifdef TESTING
if (++dropCount == 5)
{
dropCount = 0;
return m;
}
#endif
if (ack->cookie == sendCookie)
{
call Timer.stop();
done(SUCCESS);
}
return m;
}
event message_t *SubReceive.receive(message_t *m, void *payload, uint8_t len) {
reliable_msg_t *header;
ack_msg_t *ack = call AckSend.getPayload(&ackmsg, sizeof(ack_msg_t));
#ifdef TESTING
if (++dropCount == 5)
{
dropCount = 0;
return m;
}
#endif
if (len < sizeof(reliable_msg_t))
return m;
header = payload;
if (ack && !ackBusy)
{
/* We ack the received packet. We don't care if that fails (we'll
just try the ack again on the sender's retry...) */
ack->cookie = header->cookie;
if (call AckSend.send(TOS_BCAST_ADDR, &ackmsg, sizeof(ack_msg_t)) == SUCCESS)
ackBusy = TRUE;
}
/* Duplicate packet - ignore */
if (header->cookie == recvCookie)
return m;
recvCookie = header->cookie;
return signal Receive.receive(m, header->data, len - sizeof(reliable_msg_t));
}
event void AckSend.sendDone(message_t *msg, error_t error) {
ackBusy = FALSE;
}
default event message_t *Receive.receive(message_t *m, void *payload, uint8_t len) {
return m;
}
command error_t AMSend.cancel(message_t* msg) {
if (msg == sending)
{
call Timer.stop();
return SUCCESS;
}
else
return FAIL;
}
command uint8_t AMSend.maxPayloadLength() {
return call SubSend.maxPayloadLength() - sizeof(reliable_msg_t);
}
command void* AMSend.getPayload(message_t* msg, uint8_t len) {
reliable_msg_t *header = call SubSend.getPayload(msg, len + sizeof(reliable_msg_t));
return header ? header + 1 : NULL;//这边的header+1正好跳过了一个reliable_msg_t个长度，到达data区域
//但问题是data[]不是在reliable_msg_t里面的吗，而用户数据在
//reliable_msg_t之后的吗?其实不是这样的，我们可以检测一下是否
//sizeof(reliable_msg_t）== sizeof(reliable.cookie),对的，
//data[]没有任何空间
}
}
上层应用传入的packet会被加入cookies传输,我们可以看到data的作用.
下面我们针对上面的问题做一个奇怪的实验,然后我们就可以理解什么叫做data[]没有任何空间了!
test.c
#include <stdio.h>
typedef struct test_t {
int count;
int *data1;
int data2[];
} test_t;
int main()
{
test_t test;
printf("%d\n", sizeof(test_t));
printf("%d\n", sizeof(test));
printf("0x%x\n", &test.count);
printf("0x%x\n", &test.data1);
printf("0x%x\n", &test.data2);
return 0;
}
我们来看一下输出,
van9ogh@WSN:Git$ ./test 8 8 0xbf9f66b8 0xbf9f66bc 0xbf9f66c0
奇怪了,怎么会只有八个字节呢?
如果改成这样呢?
#include <stdio.h>
typedef struct test_t {
int count;
// int *data1;
int data2[];
} test_t;
int main()
{
test_t test;
printf("%d\n", sizeof(test_t));
printf("%d\n", sizeof(test));
printf("0x%x\n", &test.count);
// printf("0x%x\n", &test.data1);
printf("0x%x\n", &test.data2);
return 0;
}
输出:
van9ogh@WSN:Git$ ./test 4 4 0xbf8e2d3c 0xbf8e2d40
很犀利阿~
转载于:https://www.cnblogs.com/van9ogh/archive/2012/05/06/2486135.html