Diğer sorularıma da söylediğim gibi, C acemi ama programlama bir acemi değilim. C (c 11) öğrenmeye çalışıyorum ve bana çok önemli bir şey için biraz belirsiz: parametreleri passing.

Basit örnekler olarak bunlar

• Tüm üyeler ilkel türleri olan bir sınıf
  CreditCard(std::string number, int expMonth, int expYear,int pin):number(number), expMonth(expMonth), expYear(expYear), pin(pin)

• Üye olarak bir sınıf ilkel tip 1 kompleks türü:
  Account(std::string number, float amount, CreditCard creditCard) : number(number), amount(amount), creditCard(creditCard)

• Biraz karmaşık tür ilkel türleri 1 Üye toplama gibi bir sınıf: Client(std::string firstName, std::string lastName, std::vector<Account> accounts):firstName(firstName), lastName(lastName), accounts(accounts)

Bir hesap oluşturmak:

    CreditCard cc("12345",2,2015,1001);
    Account acc("asdasd",345, cc);

Belli ki kredi kartı iki kez bu senaryoda kopyalanacaktır. Ben bu kadar yapıcı yeniden yazmak durumunda

Account(std::string number, float amount, CreditCard& creditCard) 
    : number(number)
    , amount(amount)
    , creditCard(creditCard)

bir kopyası olacak. Benim gibi yeniden yazmak

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

2 hamle ve kopya yok.

Bazen bazı parametre kopyalamak isteyebilirsiniz düşünüyorum, bazen o nesne oluşturduğunuzda kopyalamak istemiyorum.
C geldiğim# ve referanslar için kullanılan, bana biraz garip geliyor ve her parametre için 2 aşırı olmalı diye düşünüyorum ama yanılıyorum biliyorum.
Gerçekten bulmak çünkü C parametreleri göndermek için nasıl en iyi uygulamaları, diyelim ki, önemsiz değildir. Nasıl benim yukarıdaki örnekler sundu yapardın?
Bu okuma için teşekkürler. Yeni bir şeyler öğrenebilirim diye yanıt bekliyoruz ben.

EN ÖNEMLİ SORU İLK:

Gerçekten bulmak çünkü C parametreleri göndermek için nasıl en iyi uygulamaları, diyelim ki, önemsiz değildir

Eğer bilgisayarınızın çalışması için ihtiyacı varsadeğiştirinorijinal çağrı döndükten sonra, bu nesne için değişiklik arayana görünür olarak geçti, nesne, sonra geçerlvalue başvuru:

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

Fonksiyonorijinal nesneyi değiştirmek için gerekli değildir, ve bir kopyasını oluşturmak için gerekli değildir(diğer bir deyişle, sadece kendi durumunu gözlemek gerekiyor), sonra geçerconst referans lvalue:

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

Bu rvalues ile lvalues (lvalues istikrarlı bir kimlik ile nesneleri) ve (rvalues, örneğin . her iki işlevi çağırmak için izin verir ^em>geçici** 24) arama sonucu yere gitmek üzeresin , ya da nesneleri.

Ayrıca iddia olabilirtemel tür veya türleri için hızlı kopyalama,*,* 26 int veya işlevi sadece değer gözlemlemek gerekiyorsa referans geçmek için gerek yoktur, ve. char gibi ^strong>değer olarak geçirilmesi tercih edilmelidir. Bu doğru eğerbaşvuru anlambilimgerekli değildir, ama ne olursa işlevi istedim saklamak için bir işaretçi için aynı giriş nesnesi bir yere, böylece gelecekteki okur ile bir işaretçi göreceksiniz değeri değişiklikleri gerçekleştirildiğini başka bölüm kodu? Bu durumda, başvuru olarak geçirilmesi doğru bir çözüm değildir.

Fonksiyonorijinal nesneyi değiştirmek için gerekli değildir, ama o nesnenin bir kopyasını saklamak gerekir(muhtemelen giriş değiştirmeden giriş dönüşümün bir sonucu dönmek için), o zaman düşünebilirizdeğer alarak:

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...
}

Yukarıdaki fonksiyon çağırma her zaman lvalues geçerken bir kopyasını neden olur, ve rvalues geçerken bir hamle. Eğer işlevi, bu nesne bir yere saklamak gerekiyorsa, ek gerçekleştirebilirhareket ettirin(örneğin, bu durumda foo() a member function that needs to store the value in a data member).

Durumda hareket pahalıdıriçin nesne türü my_class, sonra da bir düşünün aşırı yükleme foo() ve size bir sürümü için lvalues (kabul eden bir lvalue başvuru için const) ve bir sürüm için rvalues (kabul eden bir rvalue reference):

// 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...
}

Fonksiyonları tek bir fonksiyon yapman çok benzer, aslında, yukarıdaki: foo() bir fonksiyonu haline gelebilirşablonve kullanabilirsinizmükemmel iletmebir hareket ya da nesne geçirilen bir kopyasını DAHİLİ olarak oluşturulan olup olmadığını belirlemek için:

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...
}

Daha bu tasarım hakkında this talk by Scott Meyers izleyerek öğrenmek isteyebilirsiniz (sadece gerçeği terimi zihin "Evrensel Referanslar"kullanıyor bu standart olmayan) em.

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

// 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

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
{ }

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

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

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