如何用 const 值初始化非 const 成员变量

Question

struct IntSlice {
  int* ptr_;
  int  len_;
};

std::initializer_list<int> xs = {1, 2, 3};
const IntSlice s = {xs.begin(), (int)xs.size()}; // this does not work :(

It is giving me an error, that we cannot assign a const pointer to a non const pointer but I thought the declaration const IntSlice would fix that.

I think I know what's going on. const IntSlice is promoting int* ptr_ to int* const ptr_ not const int* const ptr_ which is what I want.

But surely, there has to be some way to promote int* ptr_ to const int* without having to create a ReadonlyIntSlice ?

Answer 1

The members of an object with const -qualified class type still have the same type as declared in the class. The type of the ptr member subobject of const IntSlice s is int* , not int* const or const int* .

However when using the name of a variable which is declared const as an expression, then it is a lvalue expression and the expression's type is also const -qualified. When accessing a non-static data member via a member access expression like s.ptr , the const on the object expression ( s ) is propagated as top-level const to the type of whole member access expression. So the type of the expression s.ptr would be int* const , although the member subobject ptr has type int* .

But surely, there has to be some way to promote int* ptr_ to const int* without having to create a ReadonlyIntSlice ?

If you want the type of a member to change, then you must make a new class type for that. However, you do not need to completely rewrite classes in C++ for every minor modification that you'd like to make. That's what templates are for:

template<typename T>
struct IntSlice {
  T* ptr_;
  int len_;
};

And now you can use IntSlice<int> for modifiable pointers and IntSlice<const int> for non-modifiable pointers.

---

You probably added the explicit cast in (int)xs.size() because the compiler complained about the initialization without it. There is a good reason for that. When using list-initialization (initialization with braces), then C++ does not allow narrowing conversions to happen in the initializer as a protection against mistakes. The type of xs.size() is std::size_t . int is not typically able to hold all values that xs.size() could have.

The point therefore is that, instead of performing the cast, you should have the len_ member be of type std::size_t or std::ptrdiff_t (both may be reasonable, although the compiler will however still complain about narrowing in the latter case). These types are guaranteed to be able to hold all sizes that a pointer range could possibly have. (But the compiler doesn't know that sz.size() can't be so large that it will narrow to std::ptrdiff_t .)

Of course in your example you know that xs is of a size fitting int . If you want to instead rely on that, you should mark xs as constexpr . This let's the compiler know that it is to be treated as a compile-time constant and then xs.size() is also a compile-time constant, in which case the narrowing rules are relaxed to make the compiler complain only if the actual compile-time value doesn't fit the target type.

---

You don't really need to write IntSlice at all though. Since C++20 the standard library has std::span for exactly that purpose with a richer interface. If you don't have C++20, it is not difficult to re-implement most of it.