On 22-Jul-2005, Mike Morley wrote:
| It occured to me that I needed to allocate some memory to my robot,
| otherwise it would cease to be when the C++ subroutine exited. I now
| have the code:
|
| #include<iostream>
| #include<octave/oct.h>
| #include<octave/dynamic-ld.h>
You probably don't need to include dynamic-ld.h.
| #include<string>
|
| using namespace std;
I would recommend avoiding this and instead prefixing all the names
you actually use from the std namespace with "std::".
| extern "C" {
| #include "robot_instr.h"
| #include "robot_link.h"
| }
This works, but it would be better if the robot_instr.h and
robot_link.h files could be mad C++ friendly.
| class Bot: public octave_base_value
| {
| public:
| //constructor
| Bot(void): octave_base_value()
| {
| robot_link robot;
| }
This doesn't look right. It simply creates a local variable in the
constructor, which will disappear when the constructor exits. Perhaps
you want to have a robot_link object as a class data member, and
then a constructor like
Bot (void) : robot (), octave_base_value () { }
(assuming the robot_link object is called robot)?
| //destructor
| ~Bot(void)
| {
| delete this;
| }
It is almost certainly an error to "delete this". Your constructor
doesn't use new, so your destructor should not use delete.
| DEFUN_DLD(BotMake,,nargouts,
| "BotMake creates a new robot to link in to")
| {
| Bot *b = new Bot();
| return octave_value(b);
| }
| DEFUN_DLD(BotKill,args,,
| "BotKill destroys the Bot")
| {
| if (args.length() == 1) {
| delete ((Bot*)&args(0));
| }
| }
I dont' think you really want this function. When the octave_value
object that holds your Bot object is deleted, it will call the
destructor for its Rep object, which will delete the memory.
Here is a complete working example (but using a simple typedef for the
robot_link object, so that I could avoid having to find the files for
that):
#include<iostream>
#include<octave/oct.h>
typedef int robot_link;
class Bot : public octave_base_value
{
public:
Bot (void) : robot (), octave_base_value () { }
bool is_defined (void) const { return true; }
private:
robot_link robot;
DECLARE_OCTAVE_ALLOCATOR
DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA
};
DEFINE_OCTAVE_ALLOCATOR (Bot);
DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA (Bot, "Bot", "Bot");
DEFUN_DLD (BotMake, , ,
"BotMake creates a new robot to link in to")
{
static bool type_loaded = false;
if (! type_loaded)
{
Bot::register_type ();
mlock ("BotMake");
// Install Bot ops here...
}
octave_value retval;
return octave_value (new Bot ());
}
Compiling this with
mkoctfile BotMake.cc
and running
while true, x = BotMake; end
in Octave does not result in a memory leak.
You will need a few more functions in your Bot class to make it
useful. See the example make_int.cc that is included in the Octave
sources.
jwe
-------------------------------------------------------------
Octave is freely available under the terms of the GNU GPL.
Octave's home on the web: http://www.octave.org
How to fund new projects: http://www.octave.org/funding.html
Subscription information: http://www.octave.org/archive.html
-------------------------------------------------------------