Anyone wanna try converting this C++ example to D?

(I tried, but getting nowhere.. so far).

// --- C++ example - working -----
#include <iostream>
using std::cout;

class test
{
  private:
    int objNo;
    static int objCnt;

  public:
    test()
    {
        objNo = ++objCnt;
    }

    ~test()
    {
        --objCnt;
    }

    void printObjNumber(void)
    {
        cout << "object number :" << objNo << "\n";
    }

    static void printObjCount(void)
    {
        cout << "count:" << objCnt << "\n";
    }
};

int test::objCnt;

int main()
{
    test t1, t2;
    test::printObjCount(); // 2

    test t3;
    test::printObjCount(); // 3

    t1.printObjNumber(); // object number :1
    t2.printObjNumber(); // object number :2
    t3.printObjNumber(); // object number :3

    return 0;
}
// -----------------------

// D code .. not working yet --
module example;
import std:writefln;

class test
{
  private:
    int objNo;
    static int objCnt;

  public:
    this()
    {
        objNo = ++objCnt;
    }

    ~this()
    {
        --objCnt;
    }

    void printObjNumber()
    {
        writefln("object number : %s", objNo);
    }

    static void printObjCount()
    {
        writefln("count: %s", objCnt);
    }
}

// ??
int counter;

// ??
static this()
{
    counter = test.objCnt;
}

int main()
{
    test t1, t2 = new test();

    test.printObjCount();

    test t3;
    test.printObjCount();

    t1.printObjNumber();
    t2.printObjNumber();
    t3.printObjNumber();

    return 0;
}
// --------------------

On Sunday, 16 April 2023 at 06:39:17 UTC, Mike Parker wrote:
>
> `t1` is default-initialized, so it's null.
>     test t1, t2 = new test();

silly me. I should have picked that up myself. thanks.

> Ditto for t3. Classes are reference objects, not value objects, so you must explicitly instantiate instances if you want them to be non-null.
>     test t3;

again, silly me. I should have picked that up myself. thanks.

I wish D had value type classes as well.

On Sunday, 16 April 2023 at 07:46:53 UTC, Skippy wrote:

>
> I wish D had value type classes as well.

I like the distinction between class and struct in D. It encourages you to think harder about how you intend to use your types. In C++, there may as well only be one or the other; the distinction is so small as to be meaningless.

On 4/16/23 00:46, Skippy wrote:

> I wish D had value type classes as well.

That cannot work due to the slicing problem.

C++ cannot have value type classes either for the same reason. The difference there is that the enforcement is by guidelines (e.g. "never pass class objects by value to functions", not by language).

If you want class objects on the stack, you have two options:

- The scope keyword

- The scoped template from Phobos

Ali

On Sunday, 16 April 2023 at 08:38:55 UTC, Ali Çehreli wrote:
> On 4/16/23 00:46, Skippy wrote:
>
> > I wish D had value type classes as well.
>
> That cannot work due to the slicing problem.
>
> C++ cannot have value type classes either for the same reason. The difference there is that the enforcement is by guidelines (e.g. "never pass class objects by value to functions", not by language).
>
> If you want class objects on the stack, you have two options:
>
> - The scope keyword
>
> - The scoped template from Phobos
>
> Ali

IMO, there is no need to 'force' reference semantics on the example provided (i.e the slicing problem does not apply here).

I was under the impression scope (the keyword) was being deprecated?

I could have used a struct of course, but my mental model of a struct is a C-like struct, not a C++ like struct. I like that mental model - which is the reason why I like C++'s value type classes.

Then there is the issue of the D compiler assigning a 'default value' to an object variable that hasn't yet been assigned a value: Object o;

But.. that's a separate discussion.