C++ operator new with parameters

Hi,
I want to pass an extra parameter to the new operator so I can allocate more space than that of the class. The reason to do this is to create a Window class which is followed by an array of Icons, (see the PRMs), which is variable and the space made available dynamically for those icons.

I’m trying the following as an example:

#include <libc.h>
#include <malloc.h>

class Example {

  public:

    Example(){};

    ~Example(){};

    void *operator new(size_t size, int i) {

      return malloc(size + i * 32);

    };

    void operator delete(void *ptr) {

      free((char *)ptr);

    };

  private:

    int j;

};

However, I get the error message:
“argument 2 of type int expected for Example::operator new()”

When the code is split into c++ and h files the error message is on the plain constructor, in the example above it occurs on the class, line 4, I’ve tried to make the example small to show the problem.

Can this implementation cope with overloaded new with extra parameters defined in the class? Any clues?

Thanks in advance…

Which implementation?

DDE, thought about that after I posted earlier.

You are almost there:

#include <libc.h>
#include <malloc.h>

static void *allocate(size_t x, int y)
{
        return (void *)malloc( x + y * 32);
}

class Example {

  public:

    Example(){};

    ~Example(){};

    void *operator new(size_t size)
    {
      return allocate( size, 8);
    };

    void *operator new( size_t size, int num)
    {
      return allocate(size, num);
    };

    void *operator new( size_t size, int num1, int num2)
    {
      (void)num2;
      return allocate(size, num1);
    };

    void operator delete(void *ptr) {

      free((char *)ptr);

    };

  private:

    int j;

};


int main(void)
{
  Example *test = new (5,2) Example();

  delete test;

  return 0;
}

It’s been a while since I have used DDE C++, so I do not remember if you’ll have to use num2 or num1, apologies. You’ll need to do some tests and yes it’s a very quirky compiler! (actually translator).

The syntax above should make your code compile on a good C++ compiler and also on that thing of DDE C++. The 3rd overload will be used in DDE C++, while the 2nd should be used in a decent compiler for the same new (x,y) syntax.

The only reason I know how to use it a bit is because I needed a C++ at Uni time (long long time ago), I already had Acorn C/C++ and had no money to buy another, so had to go through the painful path of try and error until I have learned all the broken pieces and found ways to work around them.

Hope this helps and good luck! :)

Thanks, I’ll have a go.

That worked, threw a couple of warnings of unused variables but it compiled to object code. Have yet to find out if it’s num1 or num2 to use to allocate the memory.

Thanks. Yes, I only have DDE installed so can’t test it with any other compiler.

Thanks for an introduction to a new feature (to me) of C++. Just out of interest, I’d probably have just declared a single operator with default arguments:

void *operator new( size_t size, int num1 = 8, int num2 = 0)

Is that now an outdated technique?

I guess the original error message was because the constructor calls that class’ new operator, but the only one available takes two parameters.

Could you quickly try putting “= 0” this in your original example?

void *operator new(size_t size, int i = 0) …

Hi Simon, just saw your message so I haven’t tested your questions yet.

However, just had time to have a look at what is needed to overload new. It appears the new with the single parameter is needed otherwise the error I was having earlier is produced, you can’t just go straight for new with more than one parameter and ignore the single parameter new.

The example below works but if you comment out the single parameter new, like the 3 parameter one, then the error appears.

#include <libc.h>
#include <malloc.h>
#include <iostream.h>

class Example {

  public:

    Example(){};

    ~Example(){};

    void *operator new(size_t size) {

      cout << "new 1 " << size <<endl;

      return malloc(size);

    };

    void *operator new(size_t size, int num1) {

      cout << "new 2 " << size + num1 * 32 << endl;

      return malloc(size + num1 * 32);

    };

    //void *operator new( size_t size, int num1, int num2) {

    //  (void)num2;

    //  cout << "new 3 " << size + num2 * 32 << endl;

    //  return malloc(size + num2 * 32);

    //};

    void operator delete(void *ptr) {

      free((char *)ptr);

    };

  private:

    int j;

};
int main(void) {

  Example *e = new(1) Example();

  delete(e);

  return 0;

}

I want to create a Window class which can have icons as well if needed, but the number of icons can be variable and are stored as one complete memory block with the window data, see the paper PRMs 3-89 and 3-90. If there was a pointer to an array of icons held with the window data then that would have been easier to write a class. There is a reason for the number 32 appearing in the example code, it is the size of an icon block.

Is that now an outdated technique?

“now”? DDE C++ it’s based on AT&T CFront release 3ish (aka pre-C++98!!) (with limitations), so as old as when we were teenagers my friend XD

Anyway, yes you can use the definition of default values, but that will cause problems with the specific signature Bill is seeking to achieve.

The problem, AFAIR, it’s a bug in DDE C++ which will converts:

... new (x,y) ...

Into a 3 arguments signature. That is the problem.

Now, if you add default values, you surely can avoid defining the single argument overload, but you’ll have issues between the 2 arguments and the 3 arguments overload, when using new (x,y).

It would work with just the 3 arguments overload, except that if you want to compile that code also in a good C++ compiler then, if DDE ends up using num2 and a good C++ compiler ends up using num1, then you’ll have a logical bug.

Hence, the most robust solution in this very particular case (and only because of DDE broken stuff) is probably to use the 3 different definitions and basically use the 3 arguments one only when compiling with DDE.

Am I making sense?

Could you quickly try putting “= 0” this in your original example?

If you try that, it should return some errors related to the 3 arguments mentioned above, or something like that. I may remember wrong, of course, if so happy to be corrected! :)

@ Bill

By the way, for whatever reason I can’t use the multi line comment method in the post.

Hummm… I remember DDE C++ could use /* */

I think it’s time to refresh my chops on that hellish tool! ]:)

Ok,
so I had some time to actually run some test and the most concise version that seems to work fine on both DDE C++ and GCC is:

#include <libc.h>

#if defined(__CC_NORCROFT)
// For the old and clanky DDE C++
#include <malloc.h>

// If you need to use cout:
#include <iostream.h>
#define mycout cout
#define myendl endl
#else
// For modern C++ compilers:

// if you need to use cout
#include <iostream>
#define mycout std::cout
#define myendl std::endl
#endif

static void *allocate(size_t x, int y)
{
        return (void *)malloc( x + y * 32);
}

class Example {

  public:

    Example(){};

    ~Example(){};

    void *operator new( size_t size, int num1 = 0, int num2 = 0)
    {
      (void)num2;
      return allocate(size, num1);
    };

    void operator delete(void *ptr) {

      free((char *)ptr);

    };

  private:

    int j;

};


int main(void)
{
  Example *test = new (5) Example();

  delete test;

  return 0;
}

I can also confirm the bug in DDE C++, indeed for new (x) it generates a 3 argument signature, so:

void *operator new( size_t size, int num1 = 0, int num2 = 0)

Is needed only for DDE, good C++ compilers will work totally fine with:

void *operator new( size_t size, int num1 = 0)

The good news is the order of arguments is actually correct, so must have been fixed over time and therefore DDE will have num1 correctly assigned (when new (x) ), which allowed to remove some of the old extra code required on older Acorn C++.

P.S.: Tested with DDE C++ 3.22 (30-Jul2018), for older DDE it may be worth to try the older example.

I was nearly a teenager when I bought the (not “my”) first issue of 2000AD. It seems I’m further behind the times than I thought; just another feature of C++ I’d missed (and I was using the damn thing daily for about 15 years). It’s an interesting feature, perfect for this job. I don’t think I would have used it, though.

Anyway, I just tried it out on DDE, and this works, which is nice:

#include <malloc.h>
#include <iostream.h>

class Example {
public:
  Example() { cout << "Constructor: " << this << endl; }
  ~Example() { cout << "Destructor: " << this << endl; }

  void *operator new( size_t size, int i = 0 )
  {
    void *mem = malloc( size + 32*i );
    cout << "New " << size << " + 32 * " << i << ", " << mem << endl;
    return mem;
  }
  void operator delete( void *ptr )
  {
    cout << "Free " << ptr << endl;
    free( (char*)ptr );
  }

private:
  int j;
};

int main()
{
  Example *example = new (3) Example();
  delete example;
  example = new Example();
  delete example;
  Example stacked;

  return 0;
}

*c++ Example.cpp
Acorn C++ Language System 3.21 (27 Mar 2011) 
3 `cpp'
*Example
New 4 + 32 * 3, 0x12378
Constructor: 0x12378
Destructor: 0x12378
Free 0x12378
New 4 + 32 * 0, 0x1236c
Constructor: 0x1236c
Destructor: 0x1236c
Free 0x1236c
Constructor: 0x1020c
Destructor: 0x1020c

Calling “new Example()” without a parameter would call the single parameter version of “new”, but it seems happy to quietly insert the default value.

Interesting…

So the issue was the comments then, for some reasons it was not commenting out/excluding the various commented tests.

Removing everything did compile yes, nice catch! :)

Wouldn’t this do instead, for the includes part for old code (that doesn’t use the std:: prefix).

#if defined(__CC_NORCROFT)
// For the old and clanky DDE C++
#include <malloc.h>

// If you need to use cout:
#include <iostream.h>
#else
// For modern C++ compilers:

// if you need to use cout
#include <iostream>
using namespace std;
#endif

Or this for the new code:

#if defined(__CC_NORCROFT)
// For the old and clanky DDE C++
#include <malloc.h>

// If you need to use cout:
#include <iostream.h>
#define std::

#else
// For modern C++ compilers:

// if you need to use cout
#include <iostream>
#endif

Then use std::cout << std::endl; in your code.

yup that would do to (if it’s acceptable to default to std), mine was just a quick test and had to remember that DDE does not supports namespaces…

Also, nice to see that the Source debugging in DDT works fine, that is definitely useful.

Or this for the new code:

That doesn’t seems to work on mine, JFYI.

D’oh! I thought it was too good to be true. I “tested” it on the wrong compiler and was pleased it “worked”, when it really hadn’t been included. Sorry about that.

I’m using C++ with DDE. It’s nice to talk about C++ here.
@ Bill
I looked at your code,the goal is to create an array containing the window structure returned by a call to wimp_window_info (OsLib)?
I don’t really understand the reallocation of memory by malloc, whereas it is the role of new in C++
I tested the code below, I get the same results.

 

// test new operator

// https://www.riscosopen.org/forum/forums/11/topics/17215

#include 
#include 
class Example

{

  public:

  Example() {

    cout << "Constructor: " << this << endl;

    array = NULL;

  }

  Example(size_t size, int i=0)

  {

    array =new int(size + i * 32) ;

    cout << "New " << size << " + 32 * " << i << ", " << array << endl;

  }
~Example(){
cout << "Destructor: " << this << ", array: " << array << endl;
if (array!= NULL){
delete [] array ;
cout << "Free " << array << endl;
}
}
private:
int *array;
int j;
};
int main(void)

{

  Example test(5,2);
Example test2(4);
Example example;
return 0;
}

!Runimage: application built
New 5 + 32 * 2, 00010ac4
New 4 + 32 * 0, 00010a98
Constructor: 0000e830
Destructor: 0000e830, array: 00000000
Destructor: 0000e838, array: 00010a98
Free 00010a98
Destructor: 0000e840, array: 00010ac4
Free 00010ac4

I may have misunderstood what you wanted to do, sorry if my answer is not correct.
Thanks to Paolo and Simon, it allowed me to refresh my knowledge.

I’m using C++ with DDE.

You’re my hero! I thought there was no one left still using it XD

It’s nice to talk about C++ here.

Anytime! :)

I don’t really understand the reallocation of memory by malloc, whereas it is the role of new in C++

Your code example it’s a better approach IMHO. For the specific requirement that Bill has shared, I don’t see the need to overload new, but that’s what he asked for, so that is how to overload new in DDE :)

It is possible that he may want to add other parameters to Example(), so maybe he is trying to separate the memory allocation from the Constructor parameters. I do not know.

Jean-Michel, it’s a good approach that might work on other systems, but the RISC OS definition of the structure to pass to Wimp_CreateWindow requires that the 32-byte icon blocks follow directly on from the 88 bytes of the basic window block. Bill’s approach, I expect, will replace the “int j;” in Example with something like:

  DisplayRect visible;
  int scroll_x;
  int scroll_y;
  ... etc.
  TitleData title;
  int number_of_icons;

In class WindowBlock. And then be able to pass the object itself to the Wimp. (Virtual methods not allowed, I suspect.)

(And “new int(size + i * 32) ;” will allocate 4 times the required memory, I expect.)

@ Simon

I have ran more tests, because I remember it never worked with the right number of arguments when overloading new and interestingly I can confirm the bug in DDE.

Did you try to test your approach passing 2 arguments? For example: Example *test = new (5,2) Example()

When I test your:

void *operator new( size_t size, int i = 0 )

with a new that also provides i, then indeed I get the infamous:

Unexpected 3 arguments for Example::operator new

So, to me the only example that always work is when we overload new with:

void *operator new( size_t size, int i = 0, foo = 0 ) {
  (void)foo;

...

And this is what I remember always worked with DDE.

Can you please check?

I’m not sure that’s a bug. The method is called with the automatically generated class object size and however many parameters there are passed to the new.

So, basically

example = new (1, 2, 3) Example();

Example_operator_new( sizeof( Example ), 1, 2, 3 );

Or even more complicated:

class SingleImageMasklessSprite {
public:
  SingleImageMasklessSprite( const char *name, int width, int height, int depth );
  void *operator new( size_t size, int width, int height, int depth );
}

SingleImageMasklessSprite *bmp = new ( 1920, 1080, 32 ) SingleImageMasklessSprite( “Scrnsht”, 1920, 1080, 32 );

@Paolo
from Acorn lib c++
void operator new(size_t, void);
the operator new expects 2 arguments.
This is why new overloaded with 3 arguments works.
Note: the operator supplied with CathLibCpp is more efficient.

@Simon
For information
In my programs I use one or more window class with the attributes you mention.
This class is instantiated with new:
gMainWindow = new mainWindow (FENPRIN_TEMPLATE);
This constructor creates the object from a template and I just have to retrieve the info from the template to initialize the attributes of my class.
I think what interests Bill is to be able to add or modify the icons. So an array of 32 *nbicons bytes seems adequate to me. This is what I will add to my class if needed.

My !Diderot application is built this way with DDE in C++.
I’ve just been an Acorn enthusiast for years.

I agree with your last example, but find it a little confusing, it’s a good illustration of operator overloading and answers Bill’s question.
The code below seems more correct/readable to me, in the idea of ​​C++
Note: I deliberately did not use the class string for bmp_name, available with CathLibCpp

// test new operator
// <a href="https://www.riscosopen.org/forum/forums/11/topics/17215S">https://www.riscosopen.org/forum/forums/11/topics/17215S</a>
#include <stdio.h>
#include <libc.h>
#include <new.h>
#include <iostream.h>

class SingleImageMasklessSprite {
 public:
 SingleImageMasklessSprite( const char *name, int width, int height, int depth );
   char *bmp_name;
   private:
   int width, height, depth;
   char *bmp_array;
} ;

SingleImageMasklessSprite::SingleImageMasklessSprite(const char *name, int width, int height, int depth ){
  bmp_array = new char(width*height*depth);
  bmp_name = new char( 32 );
  sprintf(bmp_name,"%s", name);
}

int main(void)
{
  SingleImageMasklessSprite *bmp = new SingleImageMasklessSprite( "Scrnsht", 1920, 1080, 32);
  cout << "bmp sprite name: " << bmp->bmp_name << endl;
  return 0;
}

@ Jean

from Acorn lib c++
void operator new(size_t, void);
the operator new expects 2 arguments.
This is why new overloaded with 3 arguments works.

Ha! Thanks, so I did remember well. Sorry, late night testing always feels like I am doing something wrong.

@Jean-Michel There are two ways of coming at it, from the C++ side or from the RISC OS side, I suppose. I do kind of like the idea of being able to pass a pointer to a C++ object directly to a Wimp SWI, even if there’s practically no advantage to it.

That said, nobody says operator new has to return newly allocated memory, it could also create an object “over” a loaded Sprite file (plus size word), for example.

Just idle speculation.