Question

成员函数中的静态变量是类级变量，这意味着所有类实例都访问同一个变量。

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

我想要一种方法来计算在每个foo实例中分别调用count()的次数，我可以这样做：

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

但我对这种方法的问题是count和somevalue仅在doingSomething()的foo中使用和访问，所以没有理由将它作为成员变量，因为它打开了由其他类成员函数修改和使用它的大门，我想防止它。我有什么解决方案吗？

编辑1： 我的想法是计算在doingSomething()的每个实例中调用Foo的时间，并且此值仅由'doingSomething（）'用于计算其他值，这将是不同的每个实例。

为什么吗 doingSomething()在第一次调用时计算int someVariable，然后存储以供以后使用，doingSomthing()每次调用使用此存储值10次，每次11次调用{重新计算{1}}并使用此新值...无限期重复处理。

Answer 1

你可以在基类中隐藏你的计数器

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

private:
   int counter;
};

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

Answer 2

我可以看到你这样做的一种方法是使用std::map。您可以在函数中使用static std::map<class_name*, int>，并且每次调用函数时都使用operator[] this并增加int部分。

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

Answer 3

与许多其他语言一样，C ++没有多种功能可以共享变量而不允许所有函数访问的方式（除了将它们放在一起，你已经知道了）。但是，有一些方法可以近似你想要的东西。

这是一个简单的解决方法：

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

现在只有foo::count可以访问它，它会执行双重任务：递增它，然后返回它。

如果您不喜欢这样，这里有一个更长的修复程序符合所需的行为：

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_;
};

因此，保持Counter私有的所有内容意味着没有人可以访问...除了您选择的功能，并指定为计数器的friend。

然而，这是一个非常糟糕的事情。我会选择第一个解决方案，或者不用担心其他成员函数访问计数。

Answer 4

我不认为C ++中有选项可以让方法范围为私有字段。封装规则是类是封装的单位，所以你应该知道在你自己的类中做什么和不做什么。

使用单独的仿函数可以达到类似的效果：

#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;
}

在这种情况下，counter完全无法访问Test。

Answer 5

这是你想要实现的目标：

#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;
}

一个函数可访问的类变量或仍然是对象感知的成员函数中的静态变量

5 个答案: