在c ++中使用const ArrayType或ConstArrayType在一个数组中使用const元素

Question

I am going to define some arrays with fixed size and const elements.
I tried to use typedef , but there seems to be something confused:

typedef int A[4];
typedef const int CA[4];

const A a = { 1, 2, 3, 4 };
CA ca = { 1, 2, 3, 4 };

a[0] = 0;
ca[0] = 0;
a = ca;
ca = a;

All assignments will cause syntax error in the code above which I think a[0] = 0; should be legal before my test.

Considering pointers,
the result is much easier to understand that p[0] = 0; and cp = p; is correct.

typedef int *P;
typedef const int *CP;

const P p = new int[4]{ 1, 2, 3, 4 };
CP cp = new int[4]{ 1, 2, 3, 4 };

p[0] = 0;
cp[0] = 0;
p = cp;
cp = p;

Why does the cv-qualifier behave different on pointer and array?
Is it because the array has already been a const pointer, then the compiler makes some implicit conversion?

PS I compiled the code on Visual Studio 2013.

Answer 1

These two declarations

const A a = { 1, 2, 3, 4 };
CA ca = { 1, 2, 3, 4 };

are fully equivalent and declare constant arrays. If you will run this simple program (for example using MS VC++)

#include<iostream>

typedef const int CA[4];
typedef int A[4];

int main()
{
    std::cout << typeid( CA ).name() << std::endl;
    std::cout << typeid( const A ).name() << std::endl;

    return 0;
}

you will get the same result for the both output statements

int const [4]
int const [4]

In fact you could write instead

#include<iostream>

typedef int A[4];
typedef const A CA;

int main()
{
    std::cout << typeid( CA ).name() << std::endl;
    std::cout << typeid( const A ).name() << std::endl;

    return 0;
}

with the same result.

As for pointer declarators then the semantic has a minor difference. You may use cv-qualifiers with pointer declarators

ptr-operator:
    * attribute-specifier-seqopt cv-qualifier-seqopt

That is you may write for example

typedef const int * const P;

(constant pointer that points to constant data).

Thus if you will write

typedef int *P;

and then write

typedef const P CP;

when CP will be a constant pointer. The object it points to is not constant. Only the pointer itself is constant and may not be changed. That is declaration

typedef const P CP;

is equivalent to

typedef int * const CP;

It is not the same as

typedef const int *CP;

where in the last declaration the pointer itself is not constant. It is the object pointed to by a pointer having this type will be constant and may not be changed using this pointer.

Shortly speaking if you have

typedef int A[4];

then

const A a = { 1, 2, 3, 4 };

is equivalent to

const int a[4] = { 1, 2, 3, 4 };

If you have

typedef int *P;

then

const P p = new int[4]{ 1, 2, 3, 4 };

is equivalent to

int * const p = new int[4]{ 1, 2, 3, 4 };

Take into account that if you have declaration like

const int *p;

then you need not to initialize the pointer because it is not constant.

While when you have declaration like

int * const p = new int;

or like

const int * const p = new int; 

you shall initialize the pointer because it is a constant. Otherwise the compiler will issue an error.

Answer 2

I searched cppreference again and again and finially found the answer...

http://en.cppreference.com/w/cpp/language/array

It is said that

Applying cv-qualifiers to an array type (through typedef or template type manipulation) applies the qualifiers to the element type, but any array type whose elements are of cv-qualified type is considered to have the same cv-qualification.

 // arr1 and arr2 have the same const-qualified type "array of 5 const char" typedef const char CC; CC arr1[5] = {}; typedef char CA[5]; const CA arr2 = {}; 

which is exactly what I am asking for!
Usually,
typedef const PointerType p; means that p can not be modified but the data pointed by p is mutable, and typedef const Type *cp; means cp is mutable but the data pointed by cp is constant.

But for an array, these two styles are equivalent!

Answer 3

I'm not 100% sure what you're asking, but maybe the following will be helpful.

In the first case, a[0]=0; fails because the type of a is const int[] . I like reading const from right to left.

typedef int IntegerArraySz4[4];
IntegerArraySz4 const a; // constant array, assignment not allowed

In the second case, there is a difference in your typedefs between a pointer to a constant integer array and a constant pointer to an integer array. Again, from right to left:

typedef int* IntPointer;
typedef int const* ConstantIntPointer;

// This is a constant pointer to some memory
IntPointer const p = new int[4] { 1, 2, 3, 4 };
p[2] = 1; // okay

// This is a pointer to some constant memory
ConstantIntPointer cp = new int [4] { 1, 3, 4, 5 };
cp[2] = 1; // error

Answer 4

It you want a C-style array you'll need to use a macro:

#define A(x) int x[4]
#define CA(x) const int x[4]

Which would be used like:

const A(a) = {1, 2, 3, 4};
CA(ca) = {1, 2, 3, 4};

But that appears very confusing. Using std::array<int, 4> seems by far preferable. And you could do that with a typedef :

typedef array<int, 4> A;
typedef const array<int, 4> CA;

Which would be used like:

const A a = {1, 2, 3, 4};
CA ca = {1, 2, 3, 4};

Note that the remainder of your code is illegal since you cannot assign to a const array or a const int[] .