分配数组指针C ++等效代码

Question

I'm modifying some code I found to be inside a C++ object. Message is a c++ class.

The original line of code looks like this:

unsigned char fifoQueue[256 * sizeof(Message)] = {0};

Since I'm putting it into an object, I'm doing this:

///in header
unsigned char fifoQueue;

///in object initializer
fifoQueue = new unsigned char[256 * sizeof(Message)];

Somehow I don't think that is correct. What's the correct implementation to get the same result? I'm just a bit cloudy about how this works - In the given example fifoQueue is a pointer to a memory location, correct? Should my object have the fifoQueue instance variable as a pointer to a "Message" array, instead?

Thanks!

/////// Okay, I'm adding some information here that is relevant to the way this is being used. Sorry for not including this before.

There is a method that accesses this value as a pointer and increments it based on a read/write location. So I need the new initializer such that this method works correctly.

Message* Fifo::getMessageToWrite(){

    Message* base = (Message*)fifoQueue;
    return new(base + (fifoWritePtr & 255)) Message();

}

Answer 1

From the looks of it, you want to pass objects of type Message through a queue. For this, the proper C++ mechanism is to use std::queue<Message> : it will grow to an appropriate size when pushing new messages into the queue. Unlike the std::vector<T> proposed in other answers, this actually uses a std::deque<Message> under the hood (you can use a std::deque<Message> directly but if you want a queue just use a queue).

The advantage of using a std::queue<Message> is that the object inside this queue stays put while they keep being shuffled around in a std::vector<Message> : while std::vector<T> only supports efficient (ie O(1)) addition/removal at the back as is eg used for a stack (LIFO), std::deque<T> supports efficient addition/removal at both ends as is needed for a queue (FIFO). I think the complexity of adding/removing to a std::deque<T> is only amortized constant but this is still better than linear complexity you'd get with a std::vector<T> when using it as a FIFO.

Answer 2

The second version declares an unsigned char and tries to assign a unsigned char* to it. This is not going to work and even so it is not clear to me why you would allocate enough space for 256 intS and assign them to a unsigned char* unless you are doing something very low level. A std::vector is probably the better choice anyway.

Answer 3

Piece of cake: std::vector is more preferable way instead of manual dynamic memory allocation (plain-old pointers).

#include <vector>
...
std::vector<char> fifoQueue(256);