error: 'this' is not a constant expression

Question

I have constexpr object constructor with constexpr methods.

// My SparseArray implementation

#include <cstdint>
#include <iostream>
#include <utility>

template<typename T, uint64_t size>
class SparseArray 
{
    public:
    using ElementType = T;

    template<typename... Args>
    constexpr SparseArray(Args&&... args) 
    : values{args...} {
        std::cout << "Args ctor." << '\n';
    }

    template<uint8_t Index>
    constexpr ElementType get() const {
        // some logic
        return T();
    }

    constexpr auto someMethod() {
        get<0>();                                            // <--------- works fine
        auto seq  = std::integer_sequence<ElementType, 0>{}; // <--------- works fine
        auto seq2 = std::integer_sequence<ElementType, get<0>()>{}; // <-- error
    }

    ElementType values[size];  
};

int main ()
{
    SparseArray<int, 3> array(1, 2, 3);
    array.someMethod();

    return 0 ;
}

Run code

But I really need to use method in such compile-time context. I'm going to sum two constexpr objects in compile-time, so I need to get data of both thanks to get method.

=======Edited=====

After @chris answer I understood that I missed one thing. Actually get method looks like this:

    template<uint8_t Index>
    constexpr ElementType get() const {
        if(/*some logic*/)
            return values[/*some logic*/];
        else
            return T();
    }

So, the code deals with data member of the object.

`index_sequence{}` it seems const values only be passed in angle bracket of index_sequence here, in the line `auto seq2 = std::integer_sequence()>{};`, check for reference it might help : https://stackoverflow.com/questions/49669958/details-of-stdmake-index-sequence-and-stdindex-sequence — HarshGiri, Jul 03 '18 at 10:37
now I see `const_values_only`. thank you. but I don't now what to do... — Владимир Н, Jul 03 '18 at 11:30

score 3 · Accepted Answer · answered Jul 03 '18 at 10:57

3

constexpr functions have to be usable at compile-time and runtime. You're calling a non-static member function, so it needs to work regardless of whether the class object is known at compile-time. If you require the object to be known at compile-time, the function no longer works at runtime.

The easiest way around this is to use a function that doesn't depend on the unused class object:

template<uint8_t Index>
static constexpr ElementType get() {
    // some logic
    return T();
}

If that isn't an option because you are using the class object, then you need to ensure that object is constexpr to use it:

constexpr SparseArray<int, 3> array(1, 2, 3);
auto seq2 = std::integer_sequence<int, array.get<0>()>{};

Regardless of where you use get, the only way the result is going to be usable as a compile-time value is if all parameters, including the object, are compile-time values.

EWG has accepted constexpr! to force compile-time evaluation of a function, but it wouldn't make your original example compile until used with a constexpr SparseArray object.

answered Jul 03 '18 at 10:57

chris

60,560
13
143
205

Thanks for answer! Now I understand tha missed one most essential thing in the topic. Added to topic. – Владимир Н Jul 03 '18 at 11:14
@ВладимирН, That's covered in the answer. You can't expect compile-time results from a function called on a runtime object. You're going to have to take a look at what you're giving the compiler to work with. – chris Jul 03 '18 at 11:23
I made `constexpr SparseArray array(1, 2, 3);` but still can not call `someMethod()` method. I suppose compiler have all the info he needs to call this method. But, it doesn't work: `error: passing 'const SparseArray' as 'this' argument discards qualifiers [-fpermissive] array.someMethod();` – Владимир Н Jul 03 '18 at 11:32
Oh. I added `const` to method and it is became better. But still this string `auto seq2 = std::integer_sequence()>{};` leads to `error: 'this' is not a constant expression` – Владимир Н Jul 03 '18 at 11:43
@ВладимирН, Yes, `constexpr` functions like `someMethod` are required to be usable at compile-time and runtime. As of C++17, there isn't a really great option for forcing only compile-time evaluation. You can't yet use objects of custom types as template arguments and `constexpr!` isn't merged in as of writing. – chris Jul 03 '18 at 12:13

error: 'this' is not a constant expression

1 Answers1