C++ Calling overloaded operator from within a class

Question

I have a class which inherits from another class, and I wish to call [index] to access the index'th element of some allocated storage.

Here is a minimal example:

class A
{
    protected:
    double *mem;

    double operator[](const size_t index)
    {
        return mem[index];
    }
}

class B : public A
{
    void function()
    {
        double var = this->operator[](0);
    }
}

So here I step around the problem by calling this->operator[](0) which is kind of messy.

Is this the correct way to access elements of mem considering that I don't have access to that variable from the derived class, or is there an alternative way?

Edit: I think it might be significant that I'm conforming to C++11, so can't call mem[0]?

Edit, template classes

As discussed below, the compiler error I see isn't showing up for this example, because there are no templates here.

To reproduce the compiler error:

template <typename T>
class A
{
    protected:
    double *mem;

    double operator[](const size_t index)
    {
        return mem[index];
    }
}

template <typename T>
class B : public A<T>
{
    void function()
    {
        double var = this->operator[](0);
    }
}

Possible Solutions

return this->operator[](0);
return (*this)[0];
return (this->mem)[0];
return *((this->mem)+0);
return (*this).mem[0];
return *((*this).mem+0);

... I think all of these do what I expect them to. Any more suggestions?

Even better solution:

return A::mem[0];

Exactly what I wanted!

"Is this the correct way to access elements of mem considering that I don't have access to that variable from the derived class" -- You do have access from the derived class because `mem` is declared `protected`. — James Adkison, Mar 05 '16 at 17:53
Possible duplicate of [How to use base class's constructors and assignment operator in C++?](http://stackoverflow.com/questions/1226634/how-to-use-base-classs-constructors-and-assignment-operator-in-c) — mustafagonul, Mar 05 '16 at 18:09

score 6 · Answer 1 · answered Mar 05 '16 at 17:48

6

You could say (*this)[0].

There's nothing stopping you from using mem[0] either though, in any version of C++.

answered Mar 05 '16 at 17:48

Matti Virkkunen

61,328
9
119
152

Nothing except sanity. You shouldn't directly access base members when they're already "controlled" through a tidy interface. I'd actually make `mem` `private` as soon as possible. – Lightness Races in Orbit Mar 05 '16 at 17:51
1

I think anything declared as `protected` is fair game. If you're not supposed to access it, it should be `private`. But otherwise I agree, I was just pointing it out there is no mystery rule in C++11 that would prevent you from doing that if you really wanted to. – Matti Virkkunen Mar 05 '16 at 17:52
`mem` is protected, but I cannot access it! `error: 'mem' was not declared in this scope` – FreelanceConsultant Mar 05 '16 at 17:53
@userrandomnumbers: I just ran your code and I could access it just fine. I bet you didn't paste your exact code. – Matti Virkkunen Mar 05 '16 at 17:55
Additional info, I am using a template class? – FreelanceConsultant Mar 05 '16 at 17:55
1

@userrandomnumbers: If you want precise help you are going to have to post precise code and not just something that's kinda-sorta like what you actually have. – Matti Virkkunen Mar 05 '16 at 17:56
Granted, it was a good MCVE for the question you were actually asking. – Lightness Races in Orbit Mar 05 '16 at 18:01
1

@user3728501: Might want to make it a new question even. Maybe. – Matti Virkkunen Mar 05 '16 at 18:01
@user3728501: Solution and link to explanation is now in my answer. – Lightness Races in Orbit Mar 05 '16 at 18:04
@user3728501: Are you still there? "One sec" was four hours ago :( – Lightness Races in Orbit Mar 05 '16 at 22:55

score 0 · Answer 2 · edited May 23 '17 at 12:33

0

Yes, this is a good approach. You can make the call more pleasing by writing it as (*this)[0].

However, if you don't mind bypassing the base class's interface (I wouldn't — I'd actually make mem private), you can write mem[0]!

If you're having trouble with that, it's due to something not in your testcase. For example, if it's a base member in a class template, you may need to write this->mem[0] due to a C++ oddity.

edited May 23 '17 at 12:33

Community

1
1

answered Mar 05 '16 at 17:51

Lightness Races in Orbit

369,052
73
620
1,021

Why is `this->[0];` not allowed? Seems syntactically inconsistent? – FreelanceConsultant Mar 05 '16 at 17:55
@user3728501: It's not inconsistent. – Lightness Races in Orbit Mar 05 '16 at 17:55
I could call `this->Get(0)`, or `this->anyotherfunction()` ? – FreelanceConsultant Mar 05 '16 at 17:56
@user3728501: `[]` is not function call notation. You don't write `obj.[0]` so a lack of `ptr->[0]` is not an inconsistency. – Lightness Races in Orbit Mar 05 '16 at 17:56
ie; Why does the compiler not interpret `this->[N];` as `this->operator[](N);` – FreelanceConsultant Mar 05 '16 at 17:57

C++ Calling overloaded operator from within a class

2 Answers2