error: Cannot access memory at address

Question

I'm trying to return pointer from function in derived class, This is the code:

class A

class A { 
 protected:
  C c;

 public:
  virtual void func(){
   unsigned char *data;
   int size=getData(data);
  }
}

class B

class B : public A {

private:
 int size;
public:
 B(const C &_c) { c=_c; };
 const int B::getData(unsigned char *data) const {
    data=(unsigned char *)malloc(size);
    memcpy(data,c.getMem(),size);
    if(!data){
        //err
    }
    return size;
}

class C

class C {
 private:
  unsigned char *mem;
 public:
  C(unsigned char *_mem) : mem(_mem);
  const unsigned char *getMem() const { return mem; };
}

main.cpp

C c(...);
B *b=new B(c);
b->func();

The error I get when getData returns

(this=0x50cdf8, data=0x2 <error: Cannot access memory at address 0x2>, size=32)

Thanks.

Answer 1

In class A , the func() is worthless because:
1. size is not returned to the caller.
2. The pointer data is local to func and it's contents will disappear after the end of execution in func() .

You don't need to return const int from a function. A function will return a copy of variables, so they are constant (copies).

Don't use malloc in C++, use operator new . The malloc function does not call constructors for objects.

Don't use new or malloc unless absolutely necessary . Usually, dynamic memory is for containers where their capacity is not known at compile time; or for objects that live beyond a function or statement block's execution time. If you must use dynamic memory, use a smart pointer (like boost::shared_ptr ).

Use std::vector for dynamic arrays. It works; it's been tested; you don't have to write your own, including memory management.

You are passing data by value (a copy of the pointer). If you want to modify a pointer, pass it by reference or pass a pointer to the pointer; (what I call the address of the pointer).

Example:

void my_function(uint8_t * & p_data)
{
  p_data = new uint8_t[512];
}

Or

void another_function(unsigned char * * pp_data)
{
  *pp_data = new unsigned char [1024];
}

A much better solution:

void better_function(std::vector<uint8_t>& data)
{
  data.reserve(64);
  for (uint8_t i = 0; i < 64; ++i)
  {
    data[i] = i;
  }
}