How to know when a copy is being created?

Question

I'm trying to get better at understanding the intricacies of C++. I came across this exercise in C++ Best Practices by Jason Turner.

The question is if a copy is being created here.

std::map get_map();
using element_type = std::pair;
for (const element_type & : get_map())
{
}

My answer is yes, because I think std::map isn't explicitly using std::pair to represent the key-value pair. So maybe implicitly the underlying key-value pair is being copied to element_type? How off am I here? Any help would be appreciated :).

user_7478597 · Answer

In my answer, I'd like to address the question title literally:

How to know when a copy is being created?

This can be achieved quite easy with a sample class where every constructor in quest makes an output:

struct Data {
  Data() { std::cout << "Data::Data()
"; }
  Data(const Data&) { std::cout << "Data::Data(const Data&)
"; }
  Data& operator=(const Data&) { std::cout << "Data::operator=(const Data&)
"; return *this; }
  Data(Data&&) { std::cout << "Data::Data(Data&&)
"; }
  Data& operator=(Data&&) { std::cout << "Data::operator=(Data&&)
"; return *this; }
};

According to cppreference.com, the copy constructor of std::pair is the default, i.e. it just calls the copy constructors of its member variables:

pair( const pair& p ) = default;

Thus, a little MCVE can illustrate the mistake of the OP quite obviously:

#include 
#include 

struct Data {
  Data() { std::cout << "Data::Data()
"; }
  Data(const Data&) { std::cout << "Data::Data(const Data&)
"; }
  Data& operator=(const Data&) { std::cout << "Data::operator=(const Data&)
"; return *this; }
  Data(Data&&) { std::cout << "Data::Data(Data&&)
"; }
  Data& operator=(Data&&) { std::cout << "Data::operator=(Data&&)
"; return *this; }
};

#define DEBUG(...) std::cout << #__VA_ARGS__ << ";
"; __VA_ARGS__ ; std::cout << std::endl

int main()
{
  DEBUG(std::map aMap = { { 1, Data() }, { 2, Data() } });
  // done like OP -> copy assignment
  DEBUG(for (const std::pair& value : aMap) {
    std::cout << value.first << '
';
  });
  // without copy assignment
  DEBUG(for (const std::pair& value : aMap) {
    std::cout << value.first << '
';
  });
  DEBUG(for (const std::map::value_type& value : aMap) {
    std::cout << value.first << '
';
  });
}

Output:

std::map aMap = { { 1, Data() }, { 2, Data() } };
Data::Data()
Data::Data(Data&&)
Data::Data()
Data::Data(Data&&)
Data::Data(const Data&)
Data::Data(const Data&)

for (const std::pair& value : aMap) { std::cout << value.first << '
'; };
Data::Data(const Data&)
1
Data::Data(const Data&)
2

for (const std::pair& value : aMap) { std::cout << value.first << '
'; };
1
2

for (const std::map::value_type& value : aMap) { std::cout << value.first << '
'; };
1
2

Demo on coliru

Thus, for the first loop (using std::pair) the copy constructor of Data is called in each iteration.

This doesn't happen for std::pair
nor for the std::map::value_type.

Another simple alternative could have been the usage of auto:

  for (const auto& value : aMap) {
    std::cout << value.first << '
';
  }

Furthermore, I would like to mention the diagnostic of g++ with an even shorter MCVE:

#include 
#include 

struct Data { };

int main()
{
  std::map aMap = { { 1, Data() } };
  for (const std::pair& value : aMap) std::cout << value.first << '
';
}

Output:

main.cpp: In function 'int main()':
main.cpp:9:36: warning: loop variable 'value' of type 'const std::pair&' binds to a temporary constructed from type 'std::pair' [-Wrange-loop-construct]
    9 |   for (const std::pair& value : aMap) std::cout << value.first << '
';
      |                                    ^~~~~
main.cpp:9:36: note: use non-reference type 'const std::pair' to make the copy explicit or 'const std::pair&' to prevent copying

Demo on coliru

user_19379207 · Answer

i try this simple code section:

#include 
#include 
#include 

std::map get_map()
{
    std::map m { {"CPU", 10}, {"GPU", 15} };
  
  return m;
}

int main()
{
    using element_type = std::pair;
    for (const element_type &e : get_map())
    {
    }
    return 1;
}

It does NOT copy, insteady the move is moved. i use https://cppinsights.io/ to get:

std::map, int, std::less >, std::allocator, int> > > get_map()
{
  std::map m = std::map, int, std::less >, std::allocator, int> > >{std::initializer_list, int> >{std::pair, int>{"CPU", 10}, std::pair, int>{"GPU", 15}}, std::less >(), std::allocator, int> >()} /* NRVO variable */;
  return std::map, int, std::less >, std::allocator, int> > >(static_cast, int, std::less >, std::allocator, int> > > &&>(m));
}


int main()
{
  using element_type = std::pair, int>;
  {
    std::map, int, std::less >, std::allocator, int> > > && __range1 = get_map();
    std::_Rb_tree_iterator, int> > __begin1 = __range1.begin();
    std::_Rb_tree_iterator, int> > __end1 = __range1.end();
    for(; operator!=(__begin1, __end1); __begin1.operator++()) {
      const std::pair, int> & e = std::pair, int>(__begin1.operator*());
    }
    
  }
  return 1;
}

Hope this help. thx.

Mark_Ransom_5987 · Answer

The for loop will use an iterator internally. Dereferencing an iterator will generate a value_type object not a reference to one. So even though your own loop specifies a reference, it will be a reference to a temporary object that was created (via copy) by the iterator and kept alive by your reference.

How to know when a copy is being created?

3 Answers