Как правильно передать параметры?

САМЫЙ ВАЖНЫЙ ВОПРОС ПЕРВЫЙ:

есть ли какие-либо рекомендации по отправке параметров в C++, потому что я действительно нахожу это, скажем так, не тривиальным

если ваша функция должна изменить исходный объект передается, так что после возврата вызова, изменения этого объекта будут видны вызывающему, то вы должны пройти мимо lvalue ссылка:

void foo(my_class& obj)
{
    // Modify obj here...
}

если функция не нужно изменять исходный объект, и не нужно создавать его копию (другими словами, ему нужно только наблюдать его состояние), тогда вы должны пройти мимо lvalue ссылка на const:

void foo(my_class const& obj)
{
    // Observe obj here
}

это позволит вам, чтобы вызвать функцию с значениями lvalue (значения lvalue-это объекты с устойчивой идентичности) и с правосторонние значения (значений rvalue, например Вэнс, или объекты, из которых вы собираетесь перейти в результате вызова std::move()).

можно также утверждать, что для основных типов или типов, для которых копирование быстро, например int,bool или char, нет необходимости передавать по ссылке, если функция просто должна соблюдать значение, и передача по значению должна быть одобрена. Это правильно, если ссылочной семантики не нужен, Но какой если функция хотела сохранить указатель на тот же самый объект ввода где-то, так что будущее читает через этот указатель будет видеть изменения значения, которые были выполнены в какой-то другой части кода? В этом случае передача по ссылке является правильным решением.

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

void foo(my_class obj) // One copy or one move here, but not working on
                       // the original object...
{
    // Working on obj...

    // Possibly move from obj if the result has to be stored somewhere...
}

вызов приведенной выше функции всегда будут в одном экземпляре, при передаче значений lvalue, и в движении при прохождении значений rvalue. Если ваша функция должна хранить этот объект где-то, вы можете выполнить дополнительный движение от него (например, в случае foo() и функция-член, которая должна хранить значение в элементе данных).

в случае, если ходы стоят дорого для объектов типа my_class, тогда вы можете рассмотреть возможность перегрузки foo() и предоставить одну версию для lvalues (принимая ссылку lvalue на const) и одна версия для rvalues (принимая ссылку rvalue):

// Overload for lvalues
void foo(my_class const& obj) // No copy, no move (just reference binding)
{
    my_class copyOfObj = obj; // Copy!
    // Working on copyOfObj...
}

// Overload for rvalues
void foo(my_class&& obj) // No copy, no move (just reference binding)
{
    my_class copyOfObj = std::move(obj); // Move! 
                                         // Notice, that invoking std::move() is 
                                         // necessary here, because obj is an
                                         // *lvalue*, even though its type is 
                                         // "rvalue reference to my_class".
    // Working on copyOfObj...
}

вышеуказанные функции настолько похожи, что вы можете сделать из них одну единственную функцию:foo() может стать функция шаблон и вы могли бы использовать идеальный переадресации для определения того, будет ли внутренне сгенерировано перемещение или копия передаваемого объекта:

template<typename C>
void foo(C&& obj) // No copy, no move (just reference binding)
//       ^^^
//       Beware, this is not always an rvalue reference! This will "magically"
//       resolve into my_class& if an lvalue is passed, and my_class&& if an
//       rvalue is passed
{
    my_class copyOfObj = std::forward<C>(obj); // Copy if lvalue, move if rvalue
    // Working on copyOfObj...
}

вы можете узнать больше об этом проекте, посмотрев это выступление Скотта Мейерса (просто имейте в виду, что термин "Универсальный Ссылок " то, что он использует, является нестандартным).

одна вещь, чтобы иметь в виду, что std::forward обычно заканчивается движение для rvalues, таким образом, даже если это выглядит относительно невинно, пересылка одного и того же объекта несколько раз может быть источником проблем - например, перемещение из одного и того же объекта дважды! Поэтому будьте осторожны, чтобы не поместить это в цикл и не переадресовывать один и тот же аргумент несколько раз в вызове функции:

template<typename C>
void foo(C&& obj)
{
    bar(std::forward<C>(obj), std::forward<C>(obj)); // Dangerous!
}

также обратите внимание, что вы обычно не прибегаете к шаблонному решению, если у вас нет веской причины для этого, так как это затрудняет чтение вашего кода. как правило, вы должны сосредоточиться на ясность и простота.

выше приведены только простые рекомендации, но в большинстве случаев они укажут вам на хорошие дизайнерские решения.

---

ОТНОСИТЕЛЬНО ОСТАЛЬНОЙ ЧАСТИ ВАШЕГО ПОСТА:

если я перепишу его как [...] будет 2 хода и не копия.

это не правильно. Начнем с того, что ссылка rvalue не может привязываться к lvalue, поэтому она будет компилироваться только при передаче значение rvalue типа CreditCard к вашему конструктору. Например:

// Here you are passing a temporary (OK! temporaries are rvalues)
Account acc("asdasd",345, CreditCard("12345",2,2015,1001));

CreditCard cc("12345",2,2015,1001);
// Here you are passing the result of std::move (OK! that's also an rvalue)
Account acc("asdasd",345, std::move(cc));

но это не сработает, если вы попытаетесь сделать это:

CreditCard cc("12345",2,2015,1001);
Account acc("asdasd",345, cc); // ERROR! cc is an lvalue

, потому что cc является lvalue и rvalue ссылки не могут привязываться к lvalues. Более того,при привязке ссылки к объекту перемещение не выполняется: это просто привязка ссылки. Таким образом, будет только один переместить.

---

таким образом, на основе руководящих принципов, приведенных в первой части этот ответ, если вы обеспокоены количеством ходов, генерируемых, когда вы берете CreditCard по значению можно определить две перегрузки конструктора, одна из которых принимает ссылку lvalue на const (CreditCard const&) и один принимает ссылку rvalue (CreditCard&&).

разрешение перегрузки будет выбрано первое при передаче значения lvalue (в этом случае будет выполнена одна копия) и последнее при передаче значения rvalue (в этом случае будет выполнен один ход).

Account(std::string number, float amount, CreditCard const& creditCard) 
: number(number), amount(amount), creditCard(creditCard) // copy here
{ }

Account(std::string number, float amount, CreditCard&& creditCard) 
: number(number), amount(amount), creditCard(std::move(creditCard)) // move here
{ }

---

использование std::forward<> обычно видно, когда вы хотите достичь идеальный переадресации. В этом случае ваш конструктор будет фактически конструктором шаблон, и выглядел бы более или менее следующим образом

template<typename C>
Account(std::string number, float amount, C&& creditCard) 
: number(number), amount(amount), creditCard(std::forward<C>(creditCard)) { }

в некотором смысле, это сочетает в себе обе перегрузки, которые я показал ранее в одной функции: C будет выведено, чтобы быть CreditCard& в случае, если вы передаете значение lvalue, и из-за ссылки сворачивая правила, это приведет к созданию экземпляра этой функции:

Account(std::string number, float amount, CreditCard& creditCard) : 
number(num), amount(amount), creditCard(std::forward<CreditCard&>(creditCard)) 
{ }

это copy-construction на creditCard, как вам хотелось бы. С другой стороны, когда rvalue передается,C будет выведено, чтобы быть CreditCard, и эта функция будет инстанцирован:

Account(std::string number, float amount, CreditCard&& creditCard) : 
number(num), amount(amount), creditCard(std::forward<CreditCard>(creditCard)) 
{ }

это move-construction на creditCard, который является то, что вы хотите (потому что передаваемое значение является rvalue, и что значит мы уполномочены переехать из него).