Class variable accessible to one function or a static variable in member function that is still object aware

Question

A static variable in a member function is a class level variable, meaning that all class instances access the same variable.

class foo{
 int doingSomething(){
   static int count =0;
   static int someValue=0
   count++;
   if(count%10 == 0){
     someValue *= counter;
     }
   someValue += counter;
   return someValue * 2;
 }
}

I want a way to count the number of times count() was called in each instance of foo separately, i can do this :

class foo{
 int count;
 int someValue;
 int doingSomething(){
   count++;
   if(count%10 == 0){
     someValue *= counter;
 }
 someValue += counter;
 return someValue * 2;
}

but my problem with this approach is that count and somevalue is only used and accessed in foo by doingSomething(), so there is no reason for it to be a member variable, since it opens the door to it modified and used by other class member function, and i want to prevent that. is there a solution that i am missing ?

EDIT 1: The idea is to count the number of time that doingSomething() was called in each instance of Foo, and this value will be used only by 'doingSomething()' to compute other values, which will be different for each instance.

Why? doingSomething() compute a int someVariable the first time is called, then stores it for later use, this stored value is used by doingSomthing() 10 times with every call, every 11calls int someVariable is recalculates and this new value is used...process repeated indefinitely.

RedOctober · Accepted Answer · 2015-10-08 16:53:07Z

4

you can hide your counter in a base class

class base_foo
{
public: 
 void doSomething()
 {
     counter++;
     //other fun stuff
 }

private:
   int counter;
};

class foo : base_foo
{
public:
    foo()
    {
        doSomething();
    }
// your other code
};

edited Oct 8, 2015 at 16:53

answered Oct 7, 2015 at 19:16

RedOctober

2153 silver badges10 bronze badges

Sign up to request clarification or add additional context in comments.

4 Comments

InsaneBot Over a year ago

The base class is still accessible equally to any member function of Foo

DaBrain Over a year ago

@BinaryA you could place doingSomething() in the base class and use public inheritace. private: int counter; will be inaccessible.

InsaneBot Over a year ago

@DaBrain another great idea, if RedOctober wants to update his answer with your idea, it would upvoted

RedOctober Over a year ago

@BinaryA I would have to disagree. Even as is, int counter is a private member variable of the base class and therefore is not directly accessible from foo.

NathanOliver · Accepted Answer · 2015-10-07 19:23:38Z

3

One way I could see you doing this is with a std::map. You could have a static std::map<class_name*, int> in the function and every time the function is called use operator[] with this and increment the int part.

class Foo
{
public:
    void bar()
    {
        static std::map<Foo*, int> counter;
        counter[this]++;
    }
};

answered Oct 7, 2015 at 19:23

NathanOliver

184k29 gold badges323 silver badges439 bronze badges

3 Comments

InsaneBot Over a year ago

Very cool idea, if a new function was to be declared in Foo would this new function be able to access counter?

NathanOliver Over a year ago

@BinaryA No as counter is local to bar()

NathanOliver Over a year ago

@BinaryA what do you mean by filling counter? counter[this]++; already fills counter every time the function is called. Did you want to see a use case?

Topological Sort · Accepted Answer · 2015-10-07 20:47:20Z

3

C++, like many other languages, doesn't have a way that multiple functions can share a variable without allowing all functions access (besides putting them into a class together, which you already know). There are some ways to approximate what you want, however.

Here's a simple fix:

class foo
{
public:
  int count () 
  {
    static int count_ = 0;
    return ++count_; 
  }
};

Now only foo::count can access it, and it does double duty: increments it, and returns it.

If you don't like that, here's a lengthier fix that matches the desired behavior:

class foo
{
private:
  class Counter //hides all that counting stuff
  {
  public:  
     //ctor initializing count...
  private:      //it's all hidden!  Only friends can access
    friend int  foo::returnCount () const; 
    friend void foo::updateCount ();

    int count () const { return count_; }
    void updateCount (){ ++count_; }

    int count_;
  };

public:
                  //and only these two functions are friends.
  int returnCount () const { return myCounter_.count (); }
  void doSomethingAndIncCount()       { myCounter_.updateCount ();   }

private:
  static Counter myCounter_;
};

So keeping all the contents of Counter private means nobody can access... except the functions you picked out, and designated as friends of Counter.

That's an awful lot of mess to go to, though. I'd go with the first solution, or else not worry about those other member functions accessing count.

edited Oct 7, 2015 at 20:47

answered Oct 7, 2015 at 19:24

Topological Sort

2,9643 gold badges31 silver badges63 bronze badges

4 Comments

Andrey Over a year ago

"C++, like other languages" in JS you can something like that with closures.

DaBrain Over a year ago

The first simple fix with static int count_; is missing an initialization.

DaBrain Over a year ago

Actually the second example is missing the initialization too.

Topological Sort Over a year ago

Fixed that now. Thanks.

Andrey · Accepted Answer · 2015-10-07 19:20:49Z

0

I don't think there are options in C++ to have method scope private field. Encapsulation rules are that class is the unit of encapsulation so you should know what to do and what not to do within your own class.

You can achieve similar effect by using separate functor:

#include <iostream>
using namespace std;

class Counter {
    private:
     int counter = 0;
    public:
     int operator () () {
        return counter++;
     }
};

class Test {
    public:
     Counter count;
};

int main() {
    Test test;
    test.count();
    test.count();
    std::cout << test.count();
    return 0;
}

In this case counter is completely inaccessible from class Test.

edited Oct 7, 2015 at 19:20

answered Oct 7, 2015 at 19:10

Andrey

60.3k12 gold badges127 silver badges169 bronze badges

3 Comments

InsaneBot Over a year ago

The problem is that count() can be still called by any member of 'class Test'

Andrey Over a year ago

@BinaryA and how is that a problem? If you want to go that far then move all your dosomething logic to Counter class (and call it SomethingDoer). But honestly what you are trying to achieve doesn't make much sense.

InsaneBot Over a year ago

My issues is that in my second code snippet, i have 2 class variables that are only used in one function, it is not a big deal, but i would rather isolate it from the rest of the class.

user3463778 · Accepted Answer · 2015-10-07 19:35:01Z

0

Is this what you are trying to achieve:

#include <iostream>
#include <string>

using namespace std;

class Foo
{
private:
    int counter;

public:

    Foo() : counter(0) {};

    void count()
    {
        counter++;
    }

    int getCounter()
    {
        return counter;
    }
};

int main()
{
    Foo foo1;
    Foo foo2;

    foo1.count(); foo1.count(); foo1.count();
    cout << "You called count() from foo1 " << foo1.getCounter() << " times" << endl;

    foo2.count();
    cout << "You called count() from foo2 " << foo2.getCounter() << " times" << endl;
}

answered Oct 7, 2015 at 19:35

user3463778

Collectives™ on Stack Overflow

Class variable accessible to one function or a static variable in member function that is still object aware

5 Answers 5

4 Comments

3 Comments

4 Comments

3 Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

5 Answers 5

4 Comments

3 Comments

4 Comments

3 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related