C++ C++；访问类成员的操作顺序

这条线能在主工作吗？也许其他运营商？有什么建议吗？ 我认为操作顺序是这里的问题。是否必须使用b.addA（“P”）；b、 参考文献

我想将一个对象的引用添加到其他对象，并在对象之间建立关系，比如数据库模型

#include <iostream>
#include <vector>
#include <string>

class A;
class B;

class A{
    std::string _name;
    std::vector<A*> _refs;
public:
    A(std::string="");
    A& ref(A&);
    std::string name() const;
};

class B{
    std::string _name;
    std::vector<A> _as;
public:
    B(std::string="");
    A& addA(std::string);
    A& R(std::string);
};

A::A(std::string nm){
    _name=nm;
}

A& A::ref(A &a){
    for(int i=0; i<_refs.size(); i++)
        if(_refs[i]==&a)
            return a;
    _refs.push_back(&a);
    return a;
}

std::string A::name() const{
    return _name;
}

B::B(std::string nm){
    _name=nm;
}

A& B::addA(std::string nm){
    for(int i=0; i<_as.size(); i++)
        if(_as[i].name()==nm)
            return _as[i];
    _as.push_back(A(nm));
    return _as[_as.size()-1];
}

A& B::R(std::string nm){
    for(int i=0; i<_as.size(); i++)
        if(_as[i].name()==nm)
            return _as[i];
    throw std::string("invaild A");
}

int main(){
    B b;
    b.addA("P").ref(b.R("P"));
    return 0;
}

#包括
#包括
#包括
甲级；
乙级;；
甲级{
std:：string _name；
标准：：矢量参考；
公众：
A（std:：string=“”）；
A&ref（A&）；
std:：string name（）常量；
};
B类{
std:：string _name；
std:：vector_as；
公众：
B（std:：string=“”）；
A&addA（标准：：字符串）；
A&R（标准：：字符串）；
};
A:：A（标准：：字符串nm）{
_名称=纳米；
}
A&A：：参考（A&A）{
对于（int i=0；i
这条线能在主工作吗

当然可以。这里只有两个操作符，函数调用和引用（点操作符）。如果关联是从右向左的，或者函数调用优先于引用，则会出现问题。事实并非如此。函数调用和引用具有相同的优先级，并且关联是从左向右的。这正是您想要的

但是，您的代码有一个问题。这是成员函数
B:：a
。在类
B
的上下文中，这将
a
的含义从
类a
更改为成员函数
B:：a（std:：string）
。我无法在多个编译器上编译您的代码，但它确实是使用clang 3.1编译的。在我看来，这看起来像是一个clang bug。（附录：使用clang编译是可以的，因为违反的规则是那些讨厌的“无需诊断”规则之一。）您的代码是非法的；它（理想情况下）应该无法编译

该函数的更好名称是
findA
。该名称不会与类名冲突，并且会使代码自文档化

旁白：您可能想让该函数返回指针而不是引用。异常应用于异常事件（即错误）。向量中没有表示“Foo”的事实真的值得引发异常吗？
从main中的行开始肯定会起作用。
现在你会感兴趣的问题是，这是怎么发生的？
当调用addA（“P”）时，它创建类A的对象并通过引用返回它，
现在A的这个对象调用它的成员fn ref（A&），正如您所看到的，您需要通过调用b.R（“P”）将A的一个对象通过引用传递给这个函数，而b.R（“P”）本身会返回对刚刚添加的对象的引用，并带有字符串“P”。现在

A.参考（A）

其中A“A”是由B类的两个不同fn返回的引用对象（在本例中，bydway A“将是相同的）

上述调用将通过引用返回类A的另一个对象，您可以将该对象分配给类似类的任何其他实例

A t；
t=b.addA（“P”）。参考（b.R（“P”））

您只是在执行链式函数调用，通过引用返回对象，可以确保临时变量中不会发生任何可能丢失的情况。
希望我已经回答了你的问题。
（除其他外）我认为这是错误的：
\u as.push\u back（A：：A（nm））；
。也许你的意思是
\u as.push\u back（A（nm））；
@MihaiTodor:我想这是可以的，因为我想在我的A型向量中存储名为_的“子对象”“您不能/不应该直接调用类的构造函数，即使VS2010似乎允许。在更正此错误后，我仍然在GCC中遇到一个奇怪的错误，但我不确定原因。@MihaiTodor:我本来会调用a（nm）；为了创建类型a的对象，但它将使用B:：a（std:：string）所以，是的，事实证明。你是这个限制的受害者。GCC足够聪明，可以禁止你这样做。将a&B:：a（std:：string）更改为a&B:：R（std:：string），问题仍然是…：（它也在VS2010上编译，但仍然是。我想返回reference以编写链式指令，就像缅因州的指令一样。@Adrian Dude，第
b.addA（“P”）行。ref（b.R（“P”）；
将首先计算
b.R（“P”）
。我不确定您在这里想要实现什么，但如果您想执行
b.R（“P”）
在
b.addA
之后，那么这不是做这件事的方法。@mihaitor:我也注意到了，但如果可能的话，我想做类似的事情。例如，如果我可以使用其他运算符像编写的那样从左到右求值……问题是b.R（“P”）首先调用。如果我在类之间创建友谊，并使用ref（std:：string）通过指向b的指针进行搜索，则会得到想要的结果。更详细地说，在a中，我可以使用b*_myb并调用ref（std:：string nm）_myb->R（nm）来查找类型为a的对象并将其添加到refs，那么对ref的调用将类似于b.addA（“P”）.ref（“P”）。这很有效。