如何初始化指向未知大小的const数据的const指针（需要alloc）

Question

I have the following class:

class A {
    A(B* b, unsigned int size_in);
private:

    unsigned int size;

    // Pointer whose address and pointed-to data shouldn't be changed
    const char* const p1;

    // Pointer which should hold a copy of p1's data (at another location in the memory).
    // Shouldn't ever be changed once copied from p1
    const char* const p1_copy;
};

I'm trying to understand how I should build the constructor, I want something of this functionality:

A::A(B* b, unsigned int size_in) :
  size(size_in), p1(b->GetPtr() + b->GetOffset())
{
  p1_copy = new char[size];
  memcpy(p1_copy, p1, size);
}

But I obviously can't do that to p1_copy because it is const and can only be initialized in an initialization list (also memcpy wouldn't work with a const pointer as the 1st argument).

FYI: after the constructor is executed, I will never change p1 or p1_copy .

What's the proper way to do this?

Thank you!

Answer 1

There are probably a few different solutions for this, but this is the typical case that const_cast was designed for - where you temporarily want to override the const ness of something.

So, you want something like (it can be done without a temporary variable, but you need more const_cast operations, and it's much less clear.

  char* tmp = new char[size];
  memcpy(tmp, p1, size);
  const_cast<const char*>(p1_copy) = tmp;

Answer 2

One option could be to create a function which makes a copy of the string:

char* copyString(const char* s, size_t size) {
    char* copy = new char[size];
    memcpy(copy, s, size);
    return copy;
}

A::A(B* b, unsigned int size_in) :
  size(size_in), p1(b->GetPtr() + b->GetOffset()),
  p1_copy(copyString(p1, size_in))
{
}

Another option, which I would prefer, is just to use std::string instead of raw pointer:

class A {
    //...
    const std::string p1_copy;
};

A::A(B* b, unsigned int size_in) :
  size(size_in), p1(b->GetPtr() + b->GetOffset()),
  p1_copy(p1, p1 + size_in)
{
}

Answer 3

Not sure if this is the proper/best way, but couldn't you do something like

const char* copy(const char* a, int size) {
    const char* ret = new char[size];
    memcpy(ret, a, size);
    return ret;
}

and then

A::A(B* b, unsigned int size_in) :
  size(size_in), p1(b->GetPtr() + b->GetOffset()), p1_copy(copy(p1, size)) {}