# sol2 3.5.0 documentation

## readonly

### Search the Documentation

# readonly

routine to mark a member variable as read-only

    template <typename T>
    auto readonly( T&& value );

The goal of read-only is to protect a variable set on a usertype or a function. Simply wrap it around a member variable, e.g. `sol::readonly( &my_class::my_member_variable )` in the appropriate place to use it. If someone tries to set it, it will error their code.

`sol::readonly` is especially important when you’re working with types that do not have a copy constructor. Lua does not understand move semantics, and therefore setters to user-defined-types require a C++ copy constructor. Containers as member variables that contain types that are not copyable but movable – e.g. `std::vector<my_move_only_type>` amongst others – also can erroneously state they are copyable but fail with compiler errors. If your type does not fit a container’s definition of being copyable or is just not copyable in general and it is a member variable, please use `sol::readonly`.

If you are looking to make a read-only table, you need to go through a bit of a complicated song and dance by overriding the `__index` metamethod. Here’s a complete example on the way to do that using `sol`:

read_only.cpp

     1#define SOL_ALL_SAFETIES_ON 1
     2#include <sol/sol.hpp>
     3
     4#include <iostream>
     5
     6struct object {
     7	void my_func() {
     8		std::cout << "hello\n";
     9	}
    10};
    11
    12int deny(lua_State* L) {
    13	return luaL_error(L, "HAH! Deniiiiied!");
    14}
    15
    16int main(int, char*[]) {
    17
    18	sol::state lua;
    19	lua.open_libraries(sol::lib::base);
    20
    21	object my_obj;
    22
    23	sol::table obj_table = lua.create_named_table("object");
    24
    25	sol::table obj_metatable = lua.create_table_with();
    26	obj_metatable.set_function(
    27	     "my_func", &object::my_func, &my_obj);
    28	// Set whatever else you need to
    29	// on the obj_metatable,
    30	// not on the obj_table itself!
    31
    32	// Properly self-index metatable to block things
    33	obj_metatable[sol::meta_function::new_index] = deny;
    34	obj_metatable[sol::meta_function::index] = obj_metatable;
    35
    36	// Set it on the actual table
    37	obj_table[sol::metatable_key] = obj_metatable;
    38
    39	try {
    40		lua.script(R"(
    41print(object.my_func)
    42object["my_func"] = 24
    43print(object.my_func)
    44        )");
    45	}
    46	catch (const std::exception& e) {
    47		std::cout << "an expected error occurred: " << e.what()
    48		          << std::endl;
    49	}
    50	return 0;
    51}

It is a verbose example, but it explains everything. Because the process is a bit involved and can have unexpected consequences for users that make their own tables, making read-only tables is something that we ask the users to do themselves with the above code, as getting the semantics right for the dozens of use cases would be tremendously difficult.