永远也不完美的程序

struct X {};
void f(std::auto_ptr<X>);

module(L)
[
    class_<X, std::auto_ptr<X> >("X")
        .def(constructor<>()),

    def("f", &f)
];

Lua 5.0  Copyright (C) 1994-2003 Tecgraf, PUC-Rio
> a = X()
> f(a)
> print a.__ok
false

module(L)
[
    class_<base, boost::shared_ptr<base> >("base")
        .def(constructor<>()),
    class_<derived, base, boost::shared_ptr<base> >("base")
        .def(constructor<>())
];

void register_part1(class_<X>& x)
{
    x.def(/*...*/);
}

void register_part2(class_<X>& x)
{
    x.def(/*...*/);
}

void register_(lua_State* L)
{
    class_<X> x("x");

    register_part1(x);
    register_part2(x);

    module(L) [ x ];
}

void my_function(object const& table)
{
    if (type(table) == LUA_TTABLE)
    {
        table["time"] = std::clock();
        table["name"] = std::rand() < 500 ? "unusual" : "usual";

        std::cout << object_cast<std::string>(table[5]) << "\n";
    }
}

class iterator
{
    iterator();
    iterator(object const&);

    object key() const;

    standard iterator members
};

for (iterator i(globals(L)["a"]), end; i != end; ++i)
{
  *i = 1;
}

object globals(lua_State*);
object registry(lua_State*);

class 'lua_testclass'

function lua_testclass:__init(name)-- 译注:这个风格类似Python的OO语法
    self.name = name
end

function lua_testclass:print()
    print(self.name)
end

a = lua_testclass('example')
a:print()

class 'derived' (lua_testclass)

function derived:__init() super('derived name')
end

function derived:print()
    print('Derived:print() -> ')
    lua_testclass.print(self)-- 译注:注意这里 : 和 . 的区别
end

class base
{
public:
    base(const char* s)
    { std::cout << s << "\n"; }

    virtual void f(int a) 
    { std::cout << "f(" << a << ")\n"; }
};

struct base_wrapper : base, luabind::wrap_base
{
    base_wrapper(const char* s)
        : base(s) 
    {}

    virtual void f(int a) 
    { 
        call<void>("f", a); 
    }

    static void default_f(base* ptr, int a)
    {
        return ptr->base::f(a);
    }
};

...

module(L)
[
    class_<base, base_wrapper>("base")
        .def(constructor<const char*>())
        .def("f", &base::f, &base_wrapper::default_f)
];