C++:如何使某些类在其对象中默认访问它的成员？

Question

让我们举个例子，下面的一些代码使用对象，但可以直接访问它们的成员而无需使用任何“.”。运算符

例1

#include <iostream>
#include <string>
using namespace std;

int main () {
  string mystr;
  cout << "What's your name? ";
  getline (cin, mystr);
  cout << "Hello " << mystr << ".\n";
  cout << "What is your favorite team? ";
  getline (cin, mystr);
  cout << "I like " << mystr << " too!\n";
  return 0;
}

这里的 mystr 是 std::string 的对象，但它可以访问其中的字符组而无需使用“.”。运算符应该是

getline(cin,mystr.(member_name)); //Here member name is the name of the member which is there inside the class std::string and stores the data

但实际的工作代码是

getline(cin,mystr);

第二点什么是间接

编辑 1:

好吧，让我用一种更简单的方式来表达，如果我有一些具有一些数据成员的类，并且如果我想使用任何数据成员，那么我需要从对象中引用它，比如

例2

class reff{

public:
     int a;
     int b;
}

reff per;
per.a=36;

这个语句告诉我们要访问任何类的成员，我们需要从对象中引用它，但是在我上面提到的 std::string 的例子中并没有发生同样的事情 mystr 是一个对象，所以它必须有一些存储数据的数据成员如果我想在 std::string 对象中显示数据，那么我应该在对象名称的同时提到数据成员的名称，但在 Eg-1 中只提到对象的名称。

Answer 1

调用 getline(cin,mystr); 没有直接指定 mystr 的任何成员的原因是因为 getline() 函数需要一个 string 对象，不是它的成员变量之一。实际实现将访问各个成员，但作为 string 类的用户，您不需要(或者不想)了解这些细节。此概念称为封装，它允许您将事物的作用(存储并允许访问字符串)与方式分开它做到了(指针和长度计数器、静态缓冲区或其他)。

在你的例子中:

class reff{

public:
     int a;
     int b;
};

reff per;
per.a=36;

您直接访问a 成员，但我们可以编写一个函数，该函数需要引用reff 对象来设置其成员变量的值:

void setValueA(reff& obj, int value)
{
  obj.a = value;
}

然后使用与 getline() 方法类似的语法:

setValueA(per, 36);

实现与 per.a = 36 相同的功能，但具有封装的好处:如果您以后需要更改 reff 存储其数据的方式的细节(例如，将 a 和 b 更改为有意义的名称)，您只需更改函数实现即可使用新的数据成员；使用此类的所有用户代码将继续工作。如果用户代码直接访问成员，也需要更改为使用新名称。

注意 setValueA() 正在访问传递给它的对象的成员变量；所以直接用 per.a 调用它不仅没有必要，而且不可能:

setValueA(per.a, 36); // invalid: setValueA() requires a reff&, not an int

由于函数本身试图利用传递给它的对象的成员 a，而 int 没有任何成员。

---

对于使用 std::string 的 getline() 调用，它具有相同的问题:要使此函数正常工作，至少需要:

1. 读/写访问指向内存的指针以存储它读取的数据(如果没有分配足够的空间，可能需要重新分配它)；和
2. 指向上面的内存量，所以它知道在需要分配额外空间之前它可以存储多少额外数据。

因此，考虑到 getline() 需要的不仅仅是一个内部类型才能运行，应该清楚为什么参数包含一个 string 对象 而不是它的特定成员变量之一。

---

有关其他示例，您应该查找 operator overloading ，它甚至可以让你做一些事情，比如让 per = 36; 为 per.a 赋值。

这是一个独立的示例，在您的 reff 类的略微修改版本上使用重载运算符。这些评论试图解释发生了什么，并且应该为您提供可以搜索的术语 - 这些都是非常基础的 C++，应该在任何教程系列中介绍。

#include <iostream>

class Reff
{
public:
    int a;
    float b; // changed the data type to illustrate overloading the = operator

    // operator= will be called if we try to assign to a an object of this class;
    // this version of the function accepts an integer value
    Reff& operator= (int intval)
    {
            a = intval;
            return *this;
    }

    // another operator=, this one accepting a float value as the parameter
    Reff& operator= (float floatval)
    {
            b = floatval;
            return *this;
    }
};

// operator+ will be called if we try to add a value to this object;
// I'm only defining this one which accepts an int value
int operator+ (Reff const& reff, int intval)
{
    return reff.a + intval;
}

// an overload of the operator<< function, which accepts a reference to
// an instance of a Reff, along with the output stream parameter.
std::ostream& operator<< (std::ostream& stream, Reff const& reff)
{
    return stream << "[a:" << reff.a << " b:" << reff.b << "]";
}


int main()
{
    // create an instance of our class
    Reff per;

    // assign the instance 42 (an integer value) - this will use the integer
    // overload of the operator= we defined
    per = 42;

    // assign it a floating point value - this will use the float overload
    // of the operator=. Note that if we didn't define a float-specific overload,
    // the compiler would probably truncate the value to an integer and use our
    // integer version instead - possibly with a warning, possibly silently,
    // depending on your compiler settings.
    per = 3.14159f;

    // output the object; this will use the overload of the operator<< function
    // that we created, which accepts our Reff object
    std::cout << per << std::endl;

    // output the result of adding 58 to our object; this will use the operator+
    // overload which accepts an integer
    std::cout << "per + 58 = " << (per + 58) << std::endl;
}