1

In C++11 is there any defined behaviour regarding the following? (i.e. does a = 1, 2 or is undefined)

void somefunc(int a, int b) {
  std::cout << a << b << std::endl;
}

int i = 0;
somefunc(++i, ++i)

Or should I write:

int i = 0;
int a = ++i;
int b = ++i;
somefunc(a, b);

The reason I ask, is I'm parsing a file for options and in one circumstance I'd like to create a keyvalue pair. And have functions similar to the following:

std::string create_key(std::string &source, size_t &size, int &index) {
  std:: string key = "";
  while(index < size) {
    // parse the string to create the key
    ++index
  }
  return key;
}

// Value is an base class for a template class. Allowing me to store values 
// of different data types inside a container.
Value* create_value(std::string &source, size_t &size, int &index) {
  Value* value = nullptr;
  while(index < size) {
    // determine type and assign it to value
    ++index;
  }
  return value;
}

std::map<std::string, Value*> create_object(std::string &source, size_t &size, int &index) {
  std::map<std::string, Value*> object;
  while(index < size) {
    // the line I think produces the same issue as my original example
    object.insert(std::pair<std::string, Value*>(create_key(source, size, index), create_value(source, size, index)));
    ++index;
  }
}
Improve this question
2
  • 1
    The order of evaluation on arguments is unspecified. Commented Sep 24, 2012 at 2:15
  • @ildjarn apologies, i meant int a = ++i; etc. Commented Sep 24, 2012 at 2:18

2 Answers 2

Reset to default
3

Yes, because you are modifying a variable in a manner which is not sequenced with respect to another modification of the same variable. Note that the comma is not a comma operator, which would introduce sequencing and prevent UB; it just separates the function arguments.

You cannot even do

somefunc(i, ++i)

without causing undefined behaviour. Modify the variable and then call the function (or vice versa if it's what you want) separately.

Improve this answer
Sign up to request clarification or add additional context in comments.

4 Comments

Minor detail: C++11 changes the phrasing, so "sequence point" is no longer used, though the same basic idea still applies.
@Seth : "Sequenced before" and "sequenced after".
@ildjarn: Or, in a case like this, "not sequenced" or "X is not sequenced with respect to Y".
@SethCarnegie: Yeah, I think so anyway.
2

The order in which function arguments are evaluated is unspecified. C++11 5.2.2.Function call para/4 states:

When a function is called, each parameter shall be initialized with its corresponding argument [Note: such initializations are indeterminately sequenced with respect to each other].

You should use:

somefunc (i+1, i+2); i += 2;

and stop worrying about such things.

This will work fine unless you're able to access i from elsewhere, in which case you have even more problems that should be fixed.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.