Greetings AllI am having a bit of an issue with the system I've made. I have a single luaState with a number of registered C functions in it. whenever I want to execute another script file, I make a new co-routine (from C)I load the lua code into this new co-routine, and then call a function on it. Any function registered with Lua must have this same prototype, defined as luaCFunction in lua.h: typedef int (.luaCFunction) (luaState.L); From the point of view of C, a C function gets as its single argument the Lua state and returns (in C) an integer with the number of values it is returning (in Lua). Its used in a similar way as callfunction, with the exception that it doesn’t take a luaState pointer, and the name is a member function in the Lua class. Warning The current implementation of callmember is not able to distinguish const member functions from non-const.

Object Oriented Programming is a fundamental method of programming that helps to develop programs using a modular approach. This approach treats data as the main element. The data is attached or linked to a function that acts and operates on it. Other functions cannot indulge in modifying this data. The functions only act on those data elements that are linked to them. This whole collection of data elements and functions is considered to be an object.

An object is one of the characteristics of Object Oriented Programming (OOP). This article introduces another characteristic feature of OOP - Polymorphism - through the concept of function overloading.

Polymorphism in Function Overloading

Polymorphism is the occurrence of different forms under certain given conditions. In computing, polymorphism is a property of object oriented programming in which a function can take different forms based on the number of arguments and their data types. All the functions will have the same name, but they will differ in their arguments.

Note: Function overloading is independent of the return type. Two functions with the same return types can qualify as function overloading if and only if they differ in their type of arguments and number of arguments.

Need for Function Overloading

When the user declares different functions with different names, calling has to be done for each function. But in function overloading, the function can be called only one time. The compiler resolves the relevant function by contrasting the arguments.

The program is executed faster.
The flow of the code is smooth and simple.
Handling and preserving the code is easy.
Code becomes shorter, hence easy to interpret and understand.
The interface between real world objects and the code enhances comprehension.

Differentiating Overloaded Functions

Example 1

Here, the name of the function is demo(). There are two functions with the same name. But, they differ in their argument list. This is an example of Function Overloading with different number of arguments.

Example 2

Here, the name of the function is demo(). There are two functions with the same name. But, they differ in the type of arguments used. This is an example for Function Overloading with different data types of arguments.

We can mix and match the number of arguments and the data types used, it doesn’t matter as long as no two functions have the same argument list.

Note: If the return type is not mentioned before the function name, it is considered to be a void function (i.e. a function that does not return any value).

C++ program to demonstrate Function Overloading

Consider the program to calculate the area of 3 geometrical figures, namely Circle, Square and Rectangle. 3 functions will be defined with the same name area(). But their number and type of arguments will be different.

Here, a class is created with the name demo. All the functions and data elements are restricted to this class itself.

Three functions are defined inside the public domain. All the functions have the same name but are different in their parameter list. This makes the function demo() overloaded. The class is publicly derived. So, even though the functions are defined outside the main() function, they can be invoked (or called) from the inside.

The functions are declared in the main function and relevant values have been passed through the function declaration itself. This type of passing is called call by value method. The other method is the call by reference method where the values are inserted during the run time of the program. d is the class variable that invokes the member functions.

The output of the above program is:

Inline Function

There are functions which are defined both inside and outside of the class. There is one such function that is defined inside the class. That is the ‘Inline Function’.

The inline function is a short function. As stated by the name itself, the function call is replaced by the body of the function. The function is in-line the main function of a program. To make use of this function, the keyword inline has to be written before the function definition. It should be defined before the function that calls it.

C++ program to demonstrate Inline Function

Consider this program to calculate area of the circle. The functions will be defined with the name area(). But here the function is in-line with the main function.

Here, the keyword inline indicates that the function is an inline function. When the function area() is invoked, the compiler replaces the function call area(2.5) with the body of the function itself. Then the result is stored in the variable a.

NOTE: Inline function does not work with recursive or looping constructs.

The output of the above program is:

Additional Resources

About the author

Kanishkvardhan A N

Kanishkvardhan A N is a sophomore at SDM College of Engineering and Technology pursuing his B.E in Information Science and Engineering. Apart from coding, he is ardent about exploring stellar space and understanding astronomy. In his leisure, he likes to play the guitar and write short stories.

wiki

Lua can be embedded and extended[1] with code or applications written in other languages. Code and values in another language can be exposed to Lua and vice-versa. The following lists low and high level solutions for binding between Lua and other languages.

Lua C API

The most direct method to bind to Lua is with the Lua C API. The C API consists of two parts: the basic API (lua.h) provides the primitive functions for all interactions between C and Lua, while the auxiliary library (lauxlib.h) provides higher-level functions for some common tasks.[2]

[The Lua 5.1 Reference Manual: The Application Program Interface] (5.1) describes Lua's native C API for calling Lua from C and vice-versa.

See also Lua book [PIL2]. Or read about the C API online in the 1st edition of PIL: [PIL1 - The C API]

An introductory video on embedding Lua in C++: [Embedding Lua in C++ #1]

A tutorial for embedding Lua in C: [Embedding Lua in C]

Enabling API checking

By default, the Lua C API does almost no sanity checking of arguments passed to it. Passing incorrect stack indexes, for example, can result in segfaults or random data corruption. You should always enable API checking in any debug build. You can do this by compiling with the option -DLUA_USE_APICHECK. luaconf.h uses this C macro to define luai_apicheck to call assert() in various places (you can also edit this definition to do something possibly more useful).

Example

Some examples of using the C API can be found by examining the source code of Lua's own standard libraries (src/*lib.c}. For example, the math library (math.*) is implemented in the file src/lmathlib.c. The basic form of this file is outlined below. First we import various headers, including the C API (lua.h) and the auxiliary library (lauxlib.h):

Then variou

C++ Calling Lua Functions With Same Name