C++ 不允许在同一类中直接访问成员变量

我不确定我的问题对不对？但我还是试着问一次

我有一个定义了几个成员变量的类。根据OO概念，每个成员函数都可以访问其类的所有成员变量

但我希望通过特定的方法（比如getter）访问这些成员变量，即使在同一个类成员函数中也是如此

有什么办法吗

class A {

public:

void func1();
void func2();
B getB();

private:
B b;
}

void A::func1() {

b.functionFromB(); // function uses member variable b directly
}

void A::func2() {
B b1=getB();  // function ask for B from a function and then uses it. // I need something like this... And ensure each function uses same way otherwise there should be warning...
b1.functionFromB();
}

谢谢，

---

凯拉斯不，没有。您可以通过封装和继承这样做：

class shape
{
    private:
        int angles;
    protected:
        shape(int angles_):angles(angles_){}; 
        int getAngles() const;
}

class square : private shape
{
    public:
        square():shape(4){}
        void doSth()
        {
            \\ you can access angles only via getAngles();
        }    
}

---

不，没有。您可以通过封装和继承这样做：

class shape
{
    private:
        int angles;
    protected:
        shape(int angles_):angles(angles_){}; 
        int getAngles() const;
}

class square : private shape
{
    public:
        square():shape(4){}
        void doSth()
        {
            \\ you can access angles only via getAngles();
        }    
}

---

类的任何私有成员都可以从类内访问，但不能由类的用户访问。所以看起来您需要允许访问它们的私有成员和公共方法

class A
{
  private:
      int a;
  public:
      int getA() {return a;}

};

int main()
{
  A inst;
  int t;

  inst.a =5; // error member a is private
  t = inst.getA(); //OK
}

---

如果您只想允许从另一个类创建一个类的实例，那么这个概念可以很好地扩展到嵌套类声明；详细信息

类的任何私有成员都可以从类内访问，但不能由类的用户访问。所以看起来您需要允许访问它们的私有成员和公共方法

class A
{
  private:
      int a;
  public:
      int getA() {return a;}

};

int main()
{
  A inst;
  int t;

  inst.a =5; // error member a is private
  t = inst.getA(); //OK
}

---

如果您只想允许从另一个类创建一个类的实例，那么这个概念可以很好地扩展到嵌套类声明；细节

正如其他人所说，您必须添加一个附加层

如果您想授予对特定方法的访问权，则可以使用关键字。例如

// Public.h
#pragma once

class Public
{
public:
    Public();

    int GetI() const;
    float GetF() const;

private:
    std::unique_ptr<Private> p_;
};

//Public.cpp
#include "Public.h"

Public::Public()
    : p_(new Private)
{
}

int Public::GetI() const
{
    return p_->i_;
}

float Public::GetF() const
{
    return p_->f_;
}

// Private.h
#pragma once

class Private
{
    friend int Public::GetI() const;
    friend float Public::GetF() const;

    int i_;
    float f_;
};

//Public.h
#布拉格语一次
公开课
{
公众：
公共的（）；
int GetI（）常量；
float GetF（）常量；
私人：
std：：唯一的ptr p；
};
//Public.cpp
#包括“Public.h”
Public：：Public（）
：p_（新私人）
{
}
int Public:：GetI（）常量
{
返回p->i；
}
float Public:：GetF（）常量
{
返回p->f；
}
//二等兵
#布拉格语一次
班级私人
{
friend int Public:：GetI（）常量；
friend float Public:：GetF（）常量；
国际组织；
浮动f_2;；
};

请记住，每个friend方法都可以访问所有私有成员

---

如果您真的想限制哪些方法可以访问哪些成员，那么您可以将每个成员包装在一个单独的类/结构中，并使该成员的getter/setter成为该类/结构的朋友，但我不推荐这种方法。

正如其他人所说，您必须添加一个额外的层

如果您想授予对特定方法的访问权，则可以使用关键字。例如

// Public.h
#pragma once

class Public
{
public:
    Public();

    int GetI() const;
    float GetF() const;

private:
    std::unique_ptr<Private> p_;
};

//Public.cpp
#include "Public.h"

Public::Public()
    : p_(new Private)
{
}

int Public::GetI() const
{
    return p_->i_;
}

float Public::GetF() const
{
    return p_->f_;
}

// Private.h
#pragma once

class Private
{
    friend int Public::GetI() const;
    friend float Public::GetF() const;

    int i_;
    float f_;
};

//Public.h
#布拉格语一次
公开课
{
公众：
公共的（）；
int GetI（）常量；
float GetF（）常量；
私人：
std：：唯一的ptr p；
};
//Public.cpp
#包括“Public.h”
Public：：Public（）
：p_（新私人）
{
}
int Public:：GetI（）常量
{
返回p->i；
}
float Public:：GetF（）常量
{
返回p->f；
}
//二等兵
#布拉格语一次
班级私人
{
friend int Public:：GetI（）常量；
friend float Public:：GetF（）常量；
国际组织；
浮动f_2;；
};

请记住，每个friend方法都可以访问所有私有成员

---

---

如果您真的想限制哪些方法可以访问哪些成员，那么您可以将每个成员包装在一个单独的类/结构中，并使该成员的getter/setter成为该类/结构的朋友，但我不推荐这种方法。

不直接，但是您可以添加一个附加层。我只能想到一种方法来实现这一点，那就是将这些变量放入嵌套类中。如果您有一个私有成员，而您不希望该类的其他成员能够访问，那么这听起来更像是通过公共成员函数（setter/getter）访问私有成员，这表明你的类缺乏内聚性。不是直接的，但你可以添加一个额外的层。我只能想一种方法来实现这一点，就是将这些变量放入嵌套类中。这听起来更像是通过公共成员函数（setter/getter）访问私有成员如果您有一个私人成员，而您不希望该类的其他成员能够访问该成员，这表明您的类缺乏凝聚力。我认为这是一个很好的例子，可以证明OOP的优势。+1这不是她或他所要寻找的。是的。。我不是在找这个。。我想限制直接访问变量/至少警告从同一类的方法直接访问变量。我认为在这里除了使用继承之外没有其他选择。@Kailas我不知道你的意思；也许在问题中给出一个例子，确切地说明您想要防止什么？@Kailas听起来您想要使用嵌套类；我包括了一个链接，并给出了很好的解释。我认为这是一个很好的例子来说明OOP的优势。+1这不是她或他想要的。是的。。我不是在找这个。。我想限制直接访问变量/至少警告从同一类的方法直接访问变量。我认为在这里除了使用继承之外没有其他选择。@Kailas我不知道你的意思；也许在问题中给出一个例子，确切地说明您想要防止什么？@Kailas听起来您想要使用嵌套类；我包括了一个链接，解释得很好。