C++ memory allocation for a structure - c++

Question

I was given a task to create dll where I need to allocate and free memory for structure. Unfortunately, I don't know how to check if the code works.
#pragma once
#include "stdafx.h"
#include "RandomBlockHeader.h"
#include <iostream>
#include <ctime>
using namespace std;
namespace RandBlock {
unsigned long RandBlockFuncs::GenerateRandomBlock(RANDOM_BLOCK ** ppRandomBlock) {
try {
srand(time(NULL));
ppRandomBlock = (RANDOM_BLOCK**)malloc(sizeof(RANDOM_BLOCK));
int random = rand() % 129;
(**ppRandomBlock).ulRandomLen = random;
(**ppRandomBlock).pRandomData = new unsigned char[random];
for (int i = 0; i < random; i++) {
(**ppRandomBlock).pRandomData[i] = (char)(rand() % 256);
}
return 0;
}
catch (exception& e) {
return -1;
}
}
unsigned long FreeRandomBlock(RANDOM_BLOCK * pRandomBlock) {
try {
delete pRandomBlock;
return 0;
}
catch (exception& e) {
return -1;
}
}
}
Can anybody point out where I can have possible errors? And is this a correct way to allocate memory for two pointer structure?

Answer 1

ppRandomBlock = (RANDOM_BLOCK**)malloc(sizeof(RANDOM_BLOCK));
is not good. I suspect it needs to be:
*ppRandomBlock = (RANDOM_BLOCK*)malloc(sizeof(RANDOM_BLOCK));
Better yet, since you are using C++, change the function interface to:
unsigned long RandBlockFuncs::GenerateRandomBlock(RANDOM_BLOCK*& ppRandomBlock) { ... }
Then, the function will look cleaner (don't use malloc at all):
unsigned long RandBlockFuncs::GenerateRandomBlock(RANDOM_BLOCK*& ppRandomBlock) {
try {
srand(time(NULL));
ppRandomBlock = new RANDOM_BLOCK;
int random = rand() % 129;
(*ppRandomBlock).ulRandomLen = random;
(*ppRandomBlock).pRandomData = new unsigned char[random];
for (int i = 0; i < random; i++) {
(*ppRandomBlock).pRandomData[i] = (char)(rand() % 256);
}
return 0;
}
catch (exception& e) {
return -1;
}
}

Answer 2

I assume that a RANDOMBLOCK is a struct type that contains (at least) two members - ulRandomLen which is of type int (not withstanding its name) and pRandomData which is of type pointer to unsigned char.
Based on those assumptions, the code has the following problems
The function has return type of unsigned long and returns -1. That (fortunately) has a well-defined effect - it returns the largest value an unsigned long can represent. However, that may not be what the caller expects.
The code calls srand() every time the function is called. This will - unless the program runs for a very long time - reinitialise the random number seed, and result in the same sequence of random values being returned by rand(). You need to ensure srand() is only called ONCE within the COMPLETE program, before the first call of rand().
The statement ppRandomBlock = (RANDOM_BLOCK**)malloc(sizeof(RANDOM_BLOCK)) needs to allocate sizeof(RANDOMBLOCK *), not sizeof(RANDOM_BLOCK). Better yet, replace the statement with ppRandomBlock = new (RANDOM_BLOCK *), and get away from needing to worry about the sizing.
The problem with the preceding statement (whether fixed or not) is that it does not allocate a RANDOMBLOCK, and leaves *ppRandomBlock uninitialised. This causes all the accesses via **ppRandomBlock to have undefined behaviour. So, it would need to be followed by a *ppRandomBlock = new RANDOMBLOCK.
The inner for loop has a statement (*ppRandomBlock).pRandomData[i] = (char)(rand() % 256) despite pRandomData[i] being of type unsigned char. It is implementation-defined whether a straight char is signed or unsigned. If it is signed, the maximum value a char can hold is not guaranteed able to hold a value greater than 127. That causes the conversion to char to have undefined behaviour.
As a partial fix, change RANDOMBLOCK to contain a std::vector<unsigned char> RandomData and eliminate the members ulRandomLen and pRandomData completely. Then change the function to
unsigned long RandBlockFuncs::GenerateRandomBlock(RANDOM_BLOCK*& ppRandomBlock)
{
try
{
// assume `srand()` has been called, for example, in main()
ppRandomBlock = new RANDOM_BLOCK;
int random = rand() % 129;
ppRandomBlock.RandomData.resize(random);
for (int i = 0; i < random; i++)
{
ppRandomBlock.RandomData[i] = (unsigned char)(rand() % 256);
}
return 0;
}
catch (exception& e)
{
return -1;
}
}
Note that the above does not fix the problem with an unsigned return type and -1 return value.
More generally, the overarching problem in the OP's code is that it is a rough translation of some C code - with adornment - into C++. Even if it was good C code, good C technique is not always good C++ technique and vice versa. And, on the face of it, the original code involved bad technique in C.
It would be better to rewrite the code completely to use C++ library features (I've demonstrated one element of that, more are possible) and not use operator new directly at all.