Порядок выполнения C ++ в цепочке методов

Результат этой программы:

#include <iostream> 
class c1
{   
  public:
    c1& meth1(int* ar) {
      std::cout << "method 1" << std::endl;
      *ar = 1;
      return *this;
    }
    void meth2(int ar)
    {
      std::cout << "method 2:"<< ar << std::endl;
    }
};

int main()
{
  c1 c;
  int nu = 0;
  c.meth1(&nu).meth2(nu);
}

Является:

method 1
method 2:0

Почему nuне 1 при meth2()запуске?

Поскольку порядок оценки не указан.

Вы видите nuв mainнастоящее время оценивается в 0еще до того , meth1как называется. Это проблема с цепочкой. Советую этого не делать.

Просто сделайте красивую, простую, понятную, легкую для чтения и понятную программу:

int main()
{
  c1 c;
  int nu = 0;
  c.meth1(&nu);
  c.meth2(nu);
}

Я думаю, что эта часть проекта стандарта, касающаяся порядка оценки, актуальна:

1.9 Выполнение программы

...

15. Если не указано иное, вычисления операндов отдельных операторов и подвыражений отдельных выражений неупорядочены. Вычисления значений операндов оператора последовательно выполняются перед вычислением значения результата оператора. Если побочный эффект для скалярного объекта не упорядочен относительно другого побочного эффекта для того же скалярного объекта или вычисления значения с использованием значения того же скалярного объекта, и они не являются потенциально параллельными, поведение не определено

а также:

5.2.2 Вызов функции

...

8. [Примечание: все оценки постфиксного выражения и аргументов не упорядочены относительно друг друга.Все побочные эффекты оценок аргументов упорядочиваются перед вводом функции - конец примечания]

Итак, для вашей строки c.meth1(&nu).meth2(nu);рассмотрите, что происходит в operator с точки зрения оператора вызова функции для последнего вызова meth2, чтобы мы четко видели разбивку на постфиксное выражение и аргументnu :

operator()(c.meth1(&nu).meth2, nu);

В оценках выражения постфикса и аргумент для вызова функции конечного (то есть выражение постфикса c.meth1(&nu).meth2и nu) являются unsequenced относительно друг друга в соответствии с вызовом функции правило , выше. Следовательно, побочный эффект вычисления постфиксного выражения на скалярном объекте arне упорядочен по сравнению с оценкой аргумента nuдо meth2вызова функции. По приведенному выше правилу выполнения программы это неопределенное поведение.

Другими словами, компилятору не требуется оценивать nuаргумент meth2вызова после meth1вызова - он может предполагать отсутствие побочных эффектов, meth1влияющих на nuоценку.

Ассемблерный код, созданный выше, содержит в функции следующую последовательность main:

1. Переменная nuразмещается в стеке и инициализируется 0.
2. Регистр ( ebxв моем случае) получает копию значенияnu
3. Адреса nuи cзагружаются в регистры параметров.
4. meth1 называется
5. Регистр возвращаемого значения , и ранее кэшированное значение из nuв ebxрегистре загружаются в регистры параметров
6. meth2 называется

Важно отметить, что на шаге 5 выше компилятор позволяет nuповторно использовать кэшированное значение из шага 2 в вызове функции meth2. Здесь игнорируется возможность, которая nuмогла быть изменена призывом к meth1«неопределенному поведению» в действии.

ПРИМЕЧАНИЕ. Этот ответ по существу изменился по сравнению с исходной формой. Мое первоначальное объяснение с точки зрения побочных эффектов вычисления операндов, которые не были упорядочены до последнего вызова функции, было неверным, потому что они есть. Проблема заключается в том, что вычисление самих операндов имеет неопределенную последовательность.

В стандарте C ++ 1998 г., раздел 5, пункт 4

Если не указано иное, порядок оценки операндов отдельных операторов и подвыражений отдельных выражений, а также порядок, в котором имеют место побочные эффекты, не указан. Между предыдущей и следующей точкой последовательности скалярный объект должен иметь свое сохраненное значение, измененное не более одного раза при оценке выражения. Кроме того, к предыдущему значению необходимо обращаться только для определения значения, которое необходимо сохранить. Требования данного параграфа должны соблюдаться для каждого допустимого порядка подвыражений полного выражения; в противном случае поведение не определено.

(Я пропустил ссылку на сноску № 53, которая не имеет отношения к этому вопросу).

По сути, &nuдолжен быть оценен перед вызовом c1::meth1()и nuдолжен быть оценен перед вызовом c1::meth2(). Однако нет никаких требований, которые nuоценивались бы раньше &nu(например, разрешается nuсначала оценивать, затем &nu, а затем c1::meth1()вызывать - что может быть тем, что делает ваш компилятор). Выражение *ar = 1в c1::meth1()поэтому не гарантируется быть оценены , прежде чем nuв main()оценивается, чтобы быть переданы c1::meth2().

В более поздних стандартах C ++ (которых у меня сейчас нет на компьютере, который я использую сегодня) есть, по сути, такой же пункт.

Я думаю, что при компиляции, до того, как на самом деле будут вызваны функции meth1 и meth2, им были переданы параметры. Я имею в виду, когда вы используете "c.meth1 (& nu) .meth2 (nu);" значение nu = 0 было передано в meth2, поэтому не имеет значения, будет ли изменено "nu" позже.

вы можете попробовать это:

#include <iostream> 
class c1
{
public:
    c1& meth1(int* ar) {
        std::cout << "method 1" << std::endl;
        *ar = 1;
        return *this;
    }
    void meth2(int* ar)
    {
        std::cout << "method 2:" << *ar << std::endl;
    }
};

int main()
{
    c1 c;
    int nu = 0;
    c.meth1(&nu).meth2(&nu);
    getchar();
}

он получит ответ, который вы хотите