什么是 gcc 编译器优化？

Question

I could think of 3 cases, compiler could represent as a CSP and then optimize, however I don't know if it does. I don't assume a specific compiler optimization flag, however, to ensure optimization, you could assume -O2 or -O3 flags are given.

1) passing arguments themselves instead of copying, if the arguments are not used after a function call

void aFunction(std::string aStr);
...
std::string aString = makeAString(anIntegerInput);
size_t mqSize = aString.size();
aFunction(aString); // or a class method like aClass->aFunction(aString);
std::cout << "Size : " << mqSize << std::endl

since the aString is not used after aFunction call. It could logically infer that, instead of copying aString, does compiler move the string(aFunction's signature is not string&& - it is not a move operation here)? Would making aFunction's input parameter std::string &&aStr force it?

2) Here, a T object with default constructor is created, and then copy constructor used to initialize values of a Map.

template<typename T>
void aMethod(std::map<std::string, T>& p, const std::vector<std::string>& aVec) {
    p.clear();
    T t;
    for (auto it = aVec.begin(); it != aVec.end(); ++it) {
        p[*it] = t;
    }
}

Compiler could detect that the "t" object is only default contructed object and instead of copying, may initialize values of the p map with default constructors.

3) We have a series of "theSameString"

std::map<std::string, int> temp{{"john", 5}, {"anna", 7}};
int aValue = temp.find("john");
int anotherValue = temp.find("john");
int yetAnotherValue = temp.find("john");

here, does compiler create 4 different "john" const char* datastructures, or for each const char* to be created, checks previous const char* datastructures? Thank you,

Answer 1

Compiler is not allowed to change a copy-constructor call by move-constructor call as it must follow language rules (Notice that if the methods have generally expected semantic, they are only regular methods which might not be equivalent with expected semantic (I see a matrix class where operator++() and operator++(int) behave really differently, one increase row, the other column, so it++; cannot be replaced by ++it; for optimization)).

The only allowed behavior change is copy/move (constructor) elision in specified cases. and since C++14 new expression .

What it can do is optimization following the as-if rule . so any change that doesn't affect observable behavior (I/O, volatile accesses). "timing" is not an observable behavior, I meant if you print elapsed time of a code, it doesn't disallow optimization of that code.

3.) We have a series of "theSameString"

compiler is allowed but not required to do that.

• "hello world" == "hello world" might return true or false .
• "hello world" + 6 == "world" might return true or false .

(remember we compare pointers here, not content).