How to move an object instead of copying it in c++?

Question

Is there a way where I could move the object GuitarSpec that is created in main instead of it being copied?

So here is the following example:- There is an Inventory class that has a list of guitars, and to add a guitar, there is a function called addGuitar that takes string, double and GuitarSpec object as an argument.

Inventory

class Inventory {
 private:
  list<Guitar> inventory;
public:
  void addGuitar(const string &, double, const GuitarSpec &spec);

addGuitar function

void Inventory::addGuitar(const string &serialNumber, double price,
                          const GuitarSpec &spec) {
  inventory.emplace_back(serialNumber, price, spec);
}

Guitar Constructor

Guitar::Guitar(const string& serialNumber, double price, const GuitarSpec &spec)
    : serialNumber{serialNumber}, price{price}, spec(spec) {
  cout << "Guitar Constructor" << endl;
}

Main function:-

 Inventory inventory;
inventory.addGuitar(
      "1001", 200,
      GuitarSpec(toString(FEDER), "starocaster", toString(ELECTRIC),
                 toString(Wood::SIKTA), toString(Wood::SIKTA)));

Is there a way to move that GuitarSpec object instead of taking a copy of it, or any other better solution?

Unless you have very specific needs and requirements, the default container type should be `std::vector`. What is the reason you picked `std::list` (I assume it is)? — Some programmer dude, Jul 09 '21 at 07:32
is `GuitarSpec` movable? Have you tried implementing moves? What problem did you encounter? Please show a [mre] — Alan Birtles, Jul 09 '21 at 07:33
@Someprogrammerdude Im actually reading Head First OOA and Design, the example was using list instead of vector so I went with it. — Mohammad Hussein, Jul 09 '21 at 07:34
@AlanBirtles I actually use move constructor in GuitarSpec object — Mohammad Hussein, Jul 09 '21 at 07:35
you have to start with implementing move semantics for GuitarSpec. Without seeing rough outline of class it's hard to tell what you have to do. That `toString` is also is a mystery. Moving makes sense only if class owns resources, otherwise that would be equivalent of copy . — Swift - Friday Pie, Jul 09 '21 at 07:39
there is no copy in your code, you are already passing the parameter by reference. Not moving is better than moving. — 463035818_is_not_an_ai, Jul 09 '21 at 07:41
@Swift-FridayPie By resources you mean memory allocated on the heap? Is there a better solution than copying the object? — Mohammad Hussein, Jul 09 '21 at 07:41
What I meant is it possible to move that GuitarSpec object created in main instead of taking a copy of it? — Mohammad Hussein, Jul 09 '21 at 07:43
"..instead of taking a copy of it" Where do you make a copy? — 463035818_is_not_an_ai, Jul 09 '21 at 07:43
@463035818_is_not_a_number Its being copied in the Guitar constructor — Mohammad Hussein, Jul 09 '21 at 07:45
yes I see it now. I often get confused when code is incomplete ;). Please post a [mcve]. It must not be much more code, but it should include a definition of the types you are using — 463035818_is_not_an_ai, Jul 09 '21 at 07:46
@Swift-FridayPie Sorry that std::move was a mistake , Ive edited my code, but should I keep it? — Mohammad Hussein, Jul 09 '21 at 07:47
@Mohammad Hussein Spec argument have to be mutable or passed by `GuitarSpec&&` rvalue reference, not by const reference, then `std::move` would be enough provided spec is designed properly. See https://stackoverflow.com/questions/28595117/why-can-we-use-stdmove-on-a-const-object You also can make `Guitar` constructor a template and use perfect forwarding. — Swift - Friday Pie, Jul 09 '21 at 07:49
@Swift-FridayPie Is that a better solution than copying? and thanks :) — Mohammad Hussein, Jul 09 '21 at 08:00
@MohammadHussein why you asking how to move if you don't know if it's better? Did you do profiling, is that critical part? — Swift - Friday Pie, Jul 09 '21 at 08:45
Pass by value instead of const& and use std::move each time? — user253751, Jul 09 '21 at 09:18
@user253751 passing by value would make either shallow or full copy,std::move after that is is like a bandaid for amputee limb. — Swift - Friday Pie, Jul 09 '21 at 16:45
@Swift-FridayPie Well, "actually moving" objects is *utterly 100% impossible*. In C++, a "move" is what we call a shallow copy with fixups to make it not crash the program. And it's what you get if you pass by value with std::move. Do you understand move semantics? — user253751, Jul 09 '21 at 17:15
@user253751 it's closer to `std::swap` than to shallow copy, we leave original in undefined but valid state. — Swift - Friday Pie, Jul 09 '21 at 19:25

score 1 · Answer 1 · answered Jul 09 '21 at 09:22

When you consider moving only one parameter, you might get away with declaring function overloads, one of which would be moving from a temporary. Or you have design where oly temporaries are used, then why don't you follow an "emplace" strategy instead and create new object on-site?

But with two or more parameters moved the number of required overloads would be four, eight and so on. That's not good, in that case perfect forward might be more useful. An example of forwarding single parameter (of type Spec) in C++11 style:

#include <iostream>
#include <utility>

struct Data {
    Data(const Data&) { std::cout << "Data copied\n"; }
    Data()  { std::cout << "Data created\n"; }
};

struct Spec {
    Data *ptr;
    
    Spec() : ptr(new Data()) {};
    
    Spec(const Spec& other) : ptr(new Data{*other.ptr}) {};
    
    Spec(Spec && other) : ptr(other.ptr) { 
          other.ptr = nullptr;
          std::cout << "Data moved\n";                      
    }
    
    Spec& operator=(const Spec& other) { ptr = new Data{*other.ptr};
                                        std::cout << "Data copied\n";
                                        return *this; }
    Spec& operator=(Spec&& other) { ptr = other.ptr; other.ptr = nullptr; 
                                    std::cout << "Data moved\n";  return *this; 
                                  }
    
    ~Spec() { delete ptr; }
};


struct foo {
    Spec d;
    
    template < typename T, std::enable_if_t<std::is_convertible<T, Spec>::value> * = nullptr>
    foo(T&& v) : d(std::forward<T>(v)) { }
    
    template <typename T>
    auto set_spec(T&& v) -> decltype(v = std::forward<Spec>(v), void())
    { d = std::forward<T>(v); }
};

int main()
{
    std::cout << "Move\n";
    foo a {Spec()};
    a.set_spec(Spec());
   
    
    std::cout << "Copy\n";
    Spec s;
    foo b {s};
    a.set_spec(s);
}

You have to modify whole chain of responsibility to use that, starting with overloading Inventory's method:

void addGuitar(const string &serialNumber, double price, GuitarSpec&& spec) {
     // move, do we want move string?
     inventory.emplace_back(serialNumber, price, std::move(spec));
}

Or using perfect forwarding, this template can copy OR move, when appropriate (example without SFINAE):

template <class SN, class SP>
void addGuitar(SN&& serialNumber, double price, SP&& spec) 
{
  
      inventory.emplace_back(std::forward<std::string>(serialNumber), 
                             price, std::forward<GuitarSpec>(spec));
}

Technically addGuitar might just be that if we don't want to bother about restricting interface by SFINAE, assuming we would always use it right and nothing wrong may happen (Murphy, put your hand down) if it's not a public interface. A bad assumption in large project with long life and multiple developers.

How to move an object instead of copying it in c++?

1 Answers1