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];

"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
"I'm conforming to C++11, so can't call mem[0]" a non sequitur. — n. m. could be an AI, May 03 '23 at 09:57
@n.m. If the previous (2) edits are wrong please edit and change again — FreelanceConsultant, May 03 '23 at 13:29
This is an open-ended question that is calling for a vague and possibly infinite set of suggestions, none of which are necessarily better than others. Please limit the scope of the question such that it can be answered with a single authoritative answer. For example, "Why doesn't `mem[0]` work?". — n. m. could be an AI, May 03 '23 at 15:42
@n.m. Not true. Some of the suggestions are objectively better than the others. It isn't at all what `*((*this).mem + 0)` does, for example. — FreelanceConsultant, May 04 '23 at 14:10
It is still impossible to provide a single authoritative answer to this question even if some of the suggestions are better (by what metric?) than some others. — n. m. could be an AI, May 04 '23 at 14:23
See [here](https://stackoverflow.com/help/dont-ask). "Your answer is provided along with the question, and you expect more answers". — n. m. could be an AI, May 04 '23 at 14:31
@n.m. And yet, the suggestions, which are not "answers" are wrong. — FreelanceConsultant, May 06 '23 at 14:05

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

63,558
9
127
159

1

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
2

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
"If you're not supposed to access it, it should be private". You are not supposed to access it and it should be private. If it isn't, send a PR. – n. m. could be an AI May 03 '23 at 10:01

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

378,754
76
643
1,055

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

score 0 · Answer 3 · answered May 02 '23 at 23:10

0

Although this is mostly a matter of preference, and other answers have given some options that use (*this)[0], I tend to prefer a cleaner syntax that doesn't require use of this at all:

return operator[](0);

answered May 02 '23 at 23:10

Riot

15,723
4
60
67

C++ Calling overloaded operator from within a class

3 Answers3