const placement matters

const_placement_example.cpp

template <typename T>
void test(T p) {
    (*p)++;                           // increment by value
    p++;                              // increment pointer to next element
}

void testrun1()
{
    int value[2] {0, 1};
    test<int *>(&value[0]);           // 1. compiles and runs successfuly
    test<int const*>(&value[0]);      // 2. error on line: (*p)++;
    test<const int*>(&value[0]);      // 3. error on line: (*p)++;
    test<int *const>(&value[0]);      // 4. error on line: p++;
    test<int const*const>(&value[0]); // 5. error on lines: (*p)++ and p++;
}

void testrun2()
{
    int * iptr = nullptr;
    (*iptr)++;                        // 1. will compile successfuly
    iptr++;                           // 1. will compile successfuly
    int const * icptr = nullptr;
    (*icptr)++;                       // 2. error on line: (*icptr)++;
    icptr++;                          // 2. will compile successfuly
    const int * ciptr = nullptr;
    (*ciptr)++;                       // 3. Same as 2.
    ciptr++;                          // 3. Same as 2.
    int * const iptrc = nullptr;
    (*iptrc)++;                       // 4. will compile successfuly
    iptrc++;                          // 4. error on line: iptrc++;
    int const * const icptrc = nullptr;
    (*icptrc)++;                      // 5. error on line: (*icptrc)++
    icptrc++;                         // 5. error on line: icptrc++
}