也许可以这样说：

class T {
private:
  T(int n, int expensive)
    : value{n-1}, a_{ka*expensive}, b_{kb*expensive} {}
public:
  T(int n) : T(n, n*n*n - 1) {}
};

一种可能的方法是将a和b放入第二个结构中，该结构进行昂贵的计算，然后具有该结构的常量成员。
也许是这样的：

class T {
    struct constants {
        int a;
        int b;

        constants(int n) {
            const int expensive = ... something involving n...;
            a = ka * expensive;
            b = kb * expensive;
        }
    };

    constants const c_;

public:
    T(int n)
        : c_{ n }
    {
    }
};

也就是说，如果您控制类T及其实现，为什么首先要使a_和b_保持不变呢？
如果您希望禁止其他开发人员对T类进行修改，那么可以添加大量文档和注解，说明不允许修改的值。这样，如果有人修改了a_或b_的值，那就是他们的错了，因为他们做了一些可能会破坏性的修改。然后应该使用审查实践和适当的版本控制处理来指出并可能责备犯错者。

在描述答案之前，我首先建议您重新考虑您的接口。如果有一个开销很大的操作，为什么不让调用者知道它并允许他们缓存结果呢？通常，设计形式围绕着值得作为一种状态保留的计算和抽象;如果它价格昂贵且可重复使用，那么它绝对值得保留。
因此，我建议把这个放到公共接口上：

struct ExpensiveResult
{
    int expensive;

    ExpensiveResult(int n)
    : expensive(n*n*n - 1)
    {}
};

class T
{
private:
  const int a;
  const int b;

  T(const ExpensiveResult& e)
  : a(ka * e.expensive)
  , b(kb * e.expensive)
  {}
};

请注意，ExpensiveResult可以直接从int n构造（ctor不是explicit），因此当您不缓存它时，调用语法是类似的;但是调用者可以在任何时候开始存储昂贵计算的结果。

由于c++20中的一个重大变化，修改对象中的常量非常容易。库函数construct_at和destroy_at已经提供来简化这一点。对于您的类，destroy_at是多余的，因为该类不包含使用动态内存的成员，如vector等。我做了一个小的修改，我添加了一个只接受int的构造函数。还定义了一个operator=，它允许在容器中操作对象。你也可以使用construct_at在你的operator--方法中递减a_和b_。代码如下：

#include <iostream>
    #include <memory>

    namespace {

        constexpr int initializer{ 3 };
        constexpr int ka{ 10 };
        constexpr int kb{ 25 };

        class T {
        private:
            int value;
            const int a_{};
            const int b_{};
        public:
            T(int n);
            T(int n, int a, int b);
            T(const T&) = default;
            inline int operator()() const { return value; }
            inline int a() const { return a_; }
            inline int b() const { return b_; }
            int& operator--();
            T& operator=(const T& arg) { std::construct_at(this, arg); return *this; };
        };

        T::T(const int n, const int a, const int b) : value{ n - 1 }, a_{ a }, b_{ b } {}
        T::T(const int n) : value{ n - 1 }
        {
            // The integer expensive
            //     + is to be computed only once and,
            //     + after the T object has been constructed,
            //       is not to be stored.
            // These requirements must be met without reliance
            // on the compiler's optimizer.
            const int expensive{ n * n * n - 1 };
            std::construct_at(this, n, ka*expensive, kb*expensive);
        }

    int& T::operator--()
    {
        // implement decrements
        //--a_; --b_;
        const int a_1 = a_ - 1;
        const int b_1 = b_ - 1;
        std::construct_at(this, value, a_1, b_1);
        return value;
    }
}

int main()
{
    T t(initializer);
    std::cout << "before decrement, t() == " << t() << "\n";
    --t;
    std::cout << "after  decrement, t() == " << t() << "\n";
    std::cout << "t.a() == " << t.a() << "\n";
    std::cout << "t.b() == " << t.b() << "\n";
    return 0;
}

输出量：

before decrement, t() == 2
after  decrement, t() == 1
t.a() == 259
t.b() == 649