·>А вообще если ты передаёшь по значению, то с таким же успехом можно передавать и неконстантный объект.

const A a;
... // (1)
f(a);

·>Угу. Только причём тут константные объекты за которых ты так топишь?

The Map.of, Map.ofEntries, and Map.copyOf static factory methods provide a convenient way to create unmodifiable maps. The Map instances created by these methods have the following characteristics:

* They are unmodifiable. Keys and values cannot be added, removed, or updated. Calling any mutator method on the Map will always cause UnsupportedOperationException to be thrown.

Как вы предлагаете обходиться без таких вещей как константные ссылки/указатели?

S>·>А вообще если ты передаёшь по значению, то с таким же успехом можно передавать и неконстантный объект.

S>·>Угу. Только причём тут константные объекты за которых ты так топишь?

void some(const std::map<..> &data)
{
  validateData(data);
  callSomething();// были ли тут вызваны мутирующие методы data? Разбирайся в run-time
  useData(data);// здесь у нас та же data что выше или может быть уже другая, не та, которую мы провалидировали?
}

void mutator(std::map<...> & data);
void reader(const std::map<...> & data);

std::map<...> data;
...
mutator(data); // Мутирующие методы data могли быть вызваны.
reader(data); // Если там кто-то дернул мутирующие методы через const_cast, то это преднамеренная диверсия.

Вы еще не поняли, что иммутабельность можно пытаться обеспечить разными способами. Можно врукопашную, как в Java, когда у вас все на честном слове. Можно с помощью средств языка. В C++ таковыми являются const.

S>Это вы про Java во множественном числе?

class first_chunk_for_next_handler_t
{
    first_chunk_t chunk;
    int remaining_bytes;

    first_chunk_t chunk()
    {
        return this.chunk;
    }

    first_chunk_t giveaway_chunk()
    {
        var chunk = this.chunk;
        this.chunk = null;
        return chunk;
    }

    int remaining_bytes()
    {
        return remaining_bytes;
    }
}

S>std::map<...> data;
S>...
S>mutator(data); // Мутирующие методы data могли быть вызваны.
S>reader(data); // Если там кто-то дернул мутирующие методы через const_cast, то это преднамеренная диверсия.
S>

S>Вы еще не поняли, что иммутабельность можно пытаться обеспечить разными способами. Можно врукопашную, как в Java, когда у вас все на честном слове. Можно с помощью средств языка. В C++ таковыми являются const. Можно научиться использовать const себе во благо. А можно убеждать себя, что и без const можно жить. Можно, кто ж спорит. Но лучше с const

const std::vector<std::string> immutable_data{ "Hello"s, "World"s };
immutable_data.push_back("!"s); // Да как так-то?!!! Да чтож это деется-то, а?

·> Константная ссылка не делает данные константными.

·>class first_chunk_for_next_handler_t
·>{
·>    int remaining_bytes()
·>    {
              // А потом кто-то с кривыми руками...
              remaining_bytes--;
·>        return remaining_bytes;
·>    }
·>}
·>

·>Как и const-интерфейс. В чём поинт-то?

interface ConstFirstChunkForNextHandler {
    int remainingBytes();
}

class FirstChunkForNextHandler implements ConstFirstChunkForNextHandler {
    private int remainingBytes = 0;
    public int remainingBytes() {
        --remainingBytes;
        return remainingBytes;
    }
}

public class Main
{
    public static void main(String[] args) {
        ConstFirstChunkForNextHandler chunk = new FirstChunkForNextHandler();
        System.out.printf("first call: %d\n", chunk.remainingBytes());
        System.out.printf("first call: %d\n", chunk.remainingBytes());
    }
}

#include <string>
#include <vector>
#include <thread>
#include <iostream>

using namespace std::string_literals;

using vector_of_string = std::vector<std::string>;

[[nodiscard]]
std::thread
launch_thread(const vector_of_string & v, int iterations) {
    return std::thread{ [&v, iterations] {
        std::size_t l{};
        for(int i=0; i < iterations; ++i) {
            for(const auto & s :v) l += s.size();
        }
        std::cout << "iterations: " << iterations << ", l=" << l << std::endl;
    }};
}

int main() {
    const vector_of_string immutable_data{ "Hello"s, "World"s };
    std::vector<std::thread> threads;
    threads.push_back(launch_thread(immutable_data, 1'000));
    threads.push_back(launch_thread(immutable_data, 2'000));
    threads.push_back(launch_thread(immutable_data, 3'000));
    for(auto & t : threads) t.join();
}

S>const std::vector<std::string> immutable_data{ "Hello"s, "World"s };
S>immutable_data.push_back("!"s); // Да как так-то?!!! Да чтож это деется-то, а?
S>

S>Константную ссылку на константный объект. Какую идею это ломает Видимо, это что-то очень личное.

Qwer data = nmqwert();
zdfkgjq(data);
ouqengtn(data);
qhrign(data);