byte [] receiverByte = new byte [BUFFER];

Question

I need some help with the following line of code. I am writing my code in C and I need some replacement for following line of code in Java. So please help me and suggest some alternatives on how I can modify it for my C code. I am waiting for line of code. Thanks..

byte[] receiverByte = new byte[BUFFER];

Answer 1

byte[] receiverByte = new byte[BUFFER_SIZE ];

becomes this if using a C++ compiler:

char* receiverByte = new char[BUFFER_SIZE ];

else in C:

char* receiverByte = malloc( BUFFER_SIZE );

Remember though that C is not memory managed like Java so you will need to call delete to free the memory when you are done:

So for C++:

delete[] receiverByte;

And for C:

free( receiverByte );

Also you could create a fixed size array on the stack. The size BUFFER_SIZE must be specified at compile time and the vector size cannot change or grow:

char receiverByte[BUFFER_SIZE];

EDIT: If you are using a c++ compiler you also have access to the STL library which removes the need to directly use new[] and delete[]:

#include <vector>
...
std::vector<char> receiverByte;
receiverByte.resize( BUFFER_SIZE );

Answer 2

If BUFFER is defined as a macro:

#define BUFFER 1234
unsigned char receiveBuffer[BUFFER];

or using a dynamic allocation with malloc() :

#include <stdlib.h>
unsigned char *receiveBuffer = malloc(BUFFER);

As mentioned by @mic_e you should multiply BUFFER with the size of a unsigned char to be more platform independent, the second example becomes:

unsigned char *receiveBuffer = malloc(BUFFER * sizeof(unsigned char));

the same goes for the first example.

Answer 3

unsigned char receiverByte[BUFFER];

or

unsigned char* receiverByte = malloc(BUFFER);
if (!receiverByte ) my_do_with_error(....);

And:

double data[19][4];

But a dynamic array here will be more tricky (test for NULL)

int M= 19, N= 4;
double **data   =malloc(sizeof( *data)*M);
         data[0]=malloc(sizeof(**data)*M*N);
for(int i=1; i<M; ++i) data[i] =data[0]+i*N;

.....

free(data[0]);
free(data);

EDIT: In 6.5.3.4 of the C standard we can find :

#include <stddef.h>
size_t fsize3(int n)
{
  char b[n+3];     // variable length array
  return sizeof b; // execution time sizeof
}
int main()
{
  size_t size;
  size = fsize3(10); // fsize3 returns 13
  return 0;
}

Answer 4

I would suggest to use unsigned char* as it resembles a byte in C. So it will be:

unsigned char* receiverByte = malloc(BUFFER * sizeof(unsigned char));

or

unsigned char receiverByte[BUFFER];