─░┼čaret├ži de─či┼čkeni ile C++ 'daki referans de─či┼čkeni aras─▒ndaki farklar nelerdir?


Al─▒nan cevaba git


Referanslar─▒n s├Âzdizimsel ┼čeker oldu─čunu biliyorum, bu y├╝zden kodun okunmas─▒ ve yaz─▒lmas─▒ daha kolay.

Fakat farklar nelerdir?


A┼ča─č─▒daki cevaplardan ve linklerden bir ├Âzet:

  1. Ba─člay─▒c─▒dan sonra bir referans atanamazken bir i┼čaret├žiye herhangi bir say─▒da yeniden atanabilir.
  2. ─░┼čaret├žiler hi├žbir yere i┼čaret edemez ( NULL ), referans ise her zaman bir nesneye i┼čaret eder.
  3. ─░┼čaret├žilerle oldu─ču gibi bir referans─▒n adresini alamazs─▒n─▒z.
  4. "Referans aritmetik" yoktur (ancak referans ile g├Âsterilen bir nesnenin adresini alabilir ve ├╝zerinde oldu─ču gibi i┼čaret├ži aritmetik yapabilirsiniz &obj + 5 ).

Bir yan─▒lg─▒y─▒ a├ž─▒kl─▒─ča kavu┼čturmak i├žin:

C ++ standard─▒, bir derleyicinin referanslar─▒ nas─▒l uygulayabilece─čini dikte etmekten ka├ž─▒nmak i├žin ├žok dikkatlidir, ancak her C ++ derleyicisi referanslar─▒ i┼čaret├žiler olarak uygular. Yani, ┼č├Âyle bir beyan:

 int &ri = i;
 

uzak tamamen optimize edilmemi┼č ise , bir i┼čaret├ži olarak ayn─▒ boyutta depolama alan─▒na ay─▒r─▒r ve adresini yerle┼čtirir i o depoya.

Dolay─▒s─▒yla, bir i┼čaret├ži ve bir referans hem ayn─▒ miktarda belle─či kullan─▒r.

Genel bir kural olarak,

  • Faydal─▒ ve kendi kendini belgeleyen aray├╝zler sa─člamak i├žin i┼člev parametrelerinde referanslar─▒ ve d├Ân├╝┼č t├╝rlerini kullan─▒n.
  • Algoritmalar─▒ ve veri yap─▒lar─▒n─▒ uygulamak i├žin i┼čaret├žiler kullan─▒n.

─░lgin├ž bir okuma:


3083









Cevap say─▒s─▒n─▒ say: 30






  1. Bir i┼čaret├ži yeniden atanabilir:

     int x = 5;
    int y = 6;
    int *p;
    p = &x;
    p = &y;
    *p = 10;
    assert(x == 5);
    assert(y == 10);
     

    Bir referans ba┼člat─▒lam─▒yor ve atanmal─▒d─▒r:

     int x = 5;
    int y = 6;
    int &r = x;
     
  2. Bir i┼čaret├ži y─▒─č─▒nda kendi haf─▒za adresine ve boyutuna (x86'da 4 bayt) sahipken, bir referans ayn─▒ haf─▒za adresini (orjinal de─či┼čkenle) payla┼č─▒rken ayn─▒ zamanda y─▒─č─▒n ├╝zerinde biraz yer kaplar. Bir referans orijinal de─či┼čkenle ayn─▒ adrese sahip oldu─čundan, ayn─▒ de─či┼čken i├žin bir referans olarak d├╝┼č├╝nmek g├╝venlidir. Not: Y─▒─č─▒n ya da ├Âbek ├╝zerinde bir i┼čaret├ži olabilece─čine i┼čaret eder. Referansa dala. Bu ifadedeki iddiam, bir i┼čaret├žinin y─▒─č─▒na i┼čaret etmesi gerekti─či de─čildir. Bir i┼čaret├ži sadece bir haf─▒za adresini tutan bir de─či┼čkendir. Bu de─či┼čken y─▒─č─▒nda. Bir referans─▒n y─▒─č─▒nda kendine ait bir alan─▒ oldu─čundan ve adres referans ald─▒─č─▒ de─či┼čkenle ayn─▒ oldu─čundan. Y─▒─č─▒n vs y─▒─č─▒n ├╝zerinde daha fazlas─▒https://stackoverflow.com/questions/79923/what-and-where-are-the-stack-and-heap%2379936#79936. Bu, derleyicinin size s├Âylemeyece─či bir referans─▒n ger├žek bir adresinin oldu─ču anlam─▒na gelir.

     int x = 0;
    int &r = x;
    int *p = &x;
    int *p2 = &r;
    assert(p == p2);
     
  3. Ekstra y├Ânlendirme sunan i┼čaret├žilere i┼čaret├žilere i┼čaret├žileriniz olabilir. Oysa referanslar sadece bir seviyede dolayl─▒ teklif sunmaktad─▒r.

     int x = 0;
    int y = 0;
    int *p = &x;
    int *q = &y;
    int **pp = &p;
    pp = &q;//*pp = q
    **pp = 4;
    assert(y == 4);
    assert(x == 0);
     
  4. ─░┼čaret├ži nullptr do─črudan atanabilir , oysa referans olamaz. Yeterince s─▒k─▒ ├žal─▒┼č─▒rsan─▒z ve nas─▒l yap─▒laca─č─▒n─▒ bilirseniz, bir referans─▒n adresini yapabilirsiniz nullptr . Ayn─▒ ┼čekilde, yeterince s─▒k─▒ ├žal─▒┼č─▒rsan─▒z bir i┼čaret├žiye bir referans─▒n─▒z olabilir ve sonra bu referans─▒ i├žerebilir nullptr .

     int *p = nullptr;
    int &r = nullptr; <--- compiling error
    int &r = *p;  <--- likely no compiling error, especially if the nullptr is hidden behind a function call, yet it refers to a non-existent int at address 0
     
  5. ─░┼čaret├žiler bir dizi ├╝zerinde yinelenebilir, ++ i┼čaret├žinin i┼čaret etti─či bir sonraki ├Â─čeye + 4 gitmek ve 5. ├Â─čeye gitmek i├žin kullanabilirsiniz. Bu, i┼čaret├žinin i┼čaret etti─či nesnenin boyutu ne olursa olsun.

  6. Bir * referans─▒n do─črudan kullan─▒labildi─či bir i┼čaret├žinin, i┼čaret etti─či haf─▒za konumuna eri┼čmek i├žin farkl─▒ k─▒l─▒nmas─▒ gerekir. Bir s─▒n─▒fa / yap─▒ya i┼čaret├ži -> ├╝yelerine eri┼čmek i├žin kullan─▒l─▒r, bir referans ise a kullan─▒r . .

  7. ─░┼čaret├ži, bir haf─▒za adresini tutan bir de─či┼čkendir. Bir referans─▒n nas─▒l uyguland─▒─č─▒na bak─▒lmaks─▒z─▒n, referans referans ald─▒─č─▒ ├Â─čeyle ayn─▒ haf─▒za adresine sahiptir.

  8. Referanslar bir diziye doldurulamaz, oysa i┼čaret├žiler olabilir (user @litb taraf─▒ndan bahsetti)

  9. Const referanslar─▒ ge├žici i┼člere ba─članabilir. ─░┼čaret├žiler olamaz (baz─▒ dolayl─▒ i┼člemler olmadan):

     const int &x = int(12); //legal C++
    int *y = &int(12); //illegal to dereference a temporary.
     

    Bu, const& tart─▒┼čma listelerinde vb. Kullan─▒m i├žin daha g├╝venli hale getirir .


1599







C ++ referans─▒ nedir ( C programc─▒lar─▒ i├žin )

Bir referans bir ┼čekilde d├╝┼č├╝n├╝lebilir sabit i┼čaret├ži (sabit bir de─čere bir i┼čaret├ži ile kar─▒┼čt─▒r─▒lmamal─▒d─▒r!) Otomatik dolaylama ile, yani ge├žerli olacakt─▒r derleyici * sizin i├žin operat├Âre.

T├╝m referanslar bo┼č olmayan bir de─čerle ba┼člat─▒lmal─▒d─▒r, aksi halde derleme ba┼čar─▒s─▒z olur. Referans adresi almak m├╝mk├╝n de─čildir - adres operat├Âr├╝ referans verilen de─čerin adresini d├Ând├╝r├╝r - referanslarda aritmetik yapmak da m├╝mk├╝n de─čildir.

C programc─▒lar─▒, C ++ referanslar─▒n─▒ be─čenmeyebilir ├ž├╝nk├╝ dolayl─▒ olarak ger├žekle┼čti─činde veya bir arg├╝man de─čere veya i┼čaret├ži ile fonksiyon imzalar─▒na bakmadan ge├žerse art─▒k belirgin olmayacakt─▒r.

C ++ programc─▒lar─▒, en ├Ânemsiz durumlar d─▒┼č─▒nda s├╝rekli i┼čaret├žilerden daha g├╝venli olmasa da i┼čaret├žileri kullanmaktan ho┼članmayabilirler - otomatik indirme i┼čleminin kolayl─▒─č─▒ yoktur ve farkl─▒ bir anlamsal ├ža─čr─▒┼č─▒m ta┼č─▒rlar.

C ++ SSS b├Âl├╝m├╝nden a┼ča─č─▒daki ifadeyi g├Âz ├Ân├╝nde bulundurun :

Bir referans genellikle altta yatan montaj dilde bir adres kullan─▒larak uygulan─▒r ra─čmen l├╝tfen de─čil bir nesneye komik g├Âr├╝n├╝ml├╝ i┼čaret├ži olarak bir referans d├╝┼č├╝n├╝yorum. Bir referans olan nesne. Nesneye bir i┼čaret├ži veya nesnenin bir kopyas─▒ de─čildir. O ise nesne.

Fakat e─čer bir referans ger├žekten nesne olsayd─▒ , sarkan referanslar nas─▒l olabilirdi? Y├Ânetilmeyen dillerde, referanslar─▒n i┼čaret├žilerden daha 'g├╝venli' olmas─▒ imkans─▒zd─▒r - genellikle kapsam s─▒n─▒rlar─▒ boyunca de─čerleri g├╝venilir ┼čekilde takma yolu yoktur!

Neden C ++ referanslar─▒n─▒ faydal─▒ buluyorum

C arka plandan geliyor, C ++ referanslar biraz sa├žma bir kavram gibi g├Âr├╝nebilir, ama hala m├╝mk├╝n i┼čaret├žiler yerine bunlar─▒ kullanmak gerekir: Otomatik indirection olan kullan─▒┼čl─▒ ve ilgilenirken referanslar ├Âzellikle yararl─▒d─▒r haline de ray - ancak herhangi alg─▒lanan g├╝venlik Avantaj, ancak daha do─črusu deyimsel kod yazmay─▒ daha az garip hale getirdikleri i├žin.

RAII, C ++ 'n─▒n temel kavramlar─▒ndan biridir, ancak ├Ânemsiz bir ┼čekilde kopyalama anlambilimi ile etkile┼čime girer. Nesnelerin referans olarak iletilmesi, kopyalama s├Âz konusu olmad─▒─č─▒ndan bu sorunlar─▒ ├Ânler. E─čer dilde referanslar olmasayd─▒, bunun yerine daha hantal olan i┼čaret├žiler kullanmak zorunda kalacaks─▒n─▒z, bu nedenle dil tasar─▒m prensibini ihlal ederek en iyi uygulama ├ž├Âz├╝m├╝n├╝n alternatiflerden daha kolay olmas─▒ gerekirdi.


357







E─čer ger├žekten bilgili olmak istiyorsan─▒z, bir i┼čaret├ži ile yapamayaca─č─▒n─▒z bir referansla yapabilece─činiz bir ┼čey var: ge├žici bir nesnenin ├Âmr├╝n├╝ uzatmak. C ++ 'da ge├žici bir nesneye const referans─▒n─▒ ba─člarsan─▒z, bu nesnenin ├Âmr├╝ referans─▒n ├Âmr├╝ olur.

 std::string s1 = "123";
std::string s2 = "456";

std::string s3_copy = s1 + s2;
const std::string& s3_reference = s1 + s2;
 

Bu ├Ârnekte s3_copy, birle┼čtirme i┼čleminin sonucu olan ge├žici nesneyi kopyalar. Oysa s3_reference ├Âz├╝nde ge├žici nesne haline gelir. Bu, ┼čimdi referansla ayn─▒ ├Âmre sahip ge├žici bir nesneye referanst─▒r.

Bunu olmadan denerseniz bu const derleme ba┼čar─▒s─▒z olur. Const olmayan bir referans─▒ ge├žici bir nesneye ba─člayamazs─▒n─▒z ya da bu konuda adresini alamazs─▒n─▒z.


175







Pop├╝ler d├╝┼č├╝ncenin aksine, NULL olan bir referans olmas─▒ m├╝mk├╝nd├╝r.

 int * p = NULL;
int & r = *p;
r = 1;  // crash! (if you're lucky)
 

Kabul ediyorum, referansla yapmak ├žok daha zor - ama y├Ânetirseniz, sa├ž─▒n─▒z─▒ bulmaya ├žal─▒┼č─▒rken y─▒rtars─▒n─▒z. Referanslar do─čal olarak C ++ 'da g├╝venli de─čil !

Teknik olarak bu ge├žersiz bir referanst─▒r , bo┼č bir referans de─čildir. C ++, null referanslar─▒ di─čer dillerde bulabilece─činiz bir kavram olarak desteklememektedir. Ba┼čka t├╝rl├╝ de ge├žersiz referanslar var. Herhangi bir ge├žersiz ba┼čvuru, ge├žersiz bir i┼čaret├ži kullanmak gibi tan─▒ms─▒z davran─▒┼č bi├žimini y├╝kseltir .

As─▒l hata, NULL i┼čaret├žisinin referans─▒nda, bir referansa atanmadan ├Ânce. Ancak bu durumda herhangi bir hata ├╝retecek herhangi bir derleyiciden haberdar de─čilim - hata kodda daha ileri bir noktaya yay─▒l─▒r. Bu sorunu bu kadar sinsi yapan da bu. ├ço─ču zaman, NULL bir g├Âstergeye ba┼čvurmazsan─▒z, tam o noktada ├žarp─▒┼č─▒rs─▒n─▒z ve bunu anlamak i├žin fazla hata ay─▒klama gerekmez.

Yukar─▒daki ├Ârne─čim k─▒sa ve tart─▒┼čmal─▒. ─░┼čte daha ger├žek d├╝nyadan bir ├Ârnek.

 class MyClass
{
    ...
    virtual void DoSomething(int,int,int,int,int);
};

void Foo(const MyClass & bar)
{
    ...
    bar.DoSomething(i1,i2,i3,i4,i5);  // crash occurs here due to memory access violation - obvious why?
}

MyClass * GetInstance()
{
    if (somecondition)
        return NULL;
    ...
}

MyClass * p = GetInstance();
Foo(*p);
 

Bo┼č bir referans alman─▒n tek yolunun hatal─▒ bi├žimlendirilmi┼č kodla oldu─čunu ve bir kez bunu tan─▒ms─▒z davran─▒┼člar elde etti─činizi yinelemek istiyorum. Bu asla bir null ba┼čvuru olup olmad─▒─č─▒n─▒ kontrol etmek mant─▒kl─▒; ├Ârne─čin deneyebilirsiniz, if(&bar==NULL)... ancak derleyici ifadeyi varolu┼čtan optimize edebilir! Ge├žerli bir ba┼čvuru asla NULL olamaz, bu nedenle derleyicinin g├Âr├╝┼č├╝ne g├Âre kar┼č─▒la┼čt─▒rma her zaman yanl─▒┼čt─▒r ve if f─▒kray─▒ ├Âl├╝ kod olarak kald─▒rmak ├╝cretsizdir - bu tan─▒ms─▒z davran─▒┼č─▒n ├Âz├╝d├╝r.

Beladan uzak durman─▒n do─čru yolu, bir referans olu┼čturmak i├žin NULL i┼čaretleyicinin referans─▒n─▒n kald─▒r─▒lmas─▒n─▒ ├Ânlemektir. ─░┼čte bunu ba┼čarman─▒n otomatik bir yolu.

 template<typename T>
T& deref(T* p)
{
    if (p == NULL)
        throw std::invalid_argument(std::string("NULL reference"));
    return *p;
}

MyClass * p = GetInstance();
Foo(deref(p));
 

Bu soruna daha iyi yazma becerisine sahip birinden daha eski bir bak─▒┼č i├žin Jim Hyslop ve Herb Sutter'dan Null Referanslar─▒na bak─▒n─▒z .

Bo┼č bir g├Âstergeyi kald─▒rman─▒n tehlikelerine ba┼čka bir ├Ârnek i├žin bkz . Raymond Chen taraf─▒ndan ba┼čka bir platforma kod kodu koymaya ├žal─▒┼č─▒rken tan─▒ms─▒z davran─▒┼č─▒ g├Âstermek .


119







Yan─▒ s─▒ra s├Âzdizimsel ┼čeker, bir referans, bir const i┼čaret├ži ( de─čil bir i┼čaret├ži const ). Referans de─či┼čkenini bildirirken ne anlama geldi─čini belirlemelisiniz ve daha sonra de─či┼čtiremezsiniz.

G├╝ncelleme: ┼čimdi biraz daha d├╝┼č├╝n├╝yorum, ├Ânemli bir fark var.

Bir const pointer'─▒n hedefi, adresi al─▒narak ve bir const cast kullan─▒larak de─či┼čtirilebilir.

Bir referans─▒n hedefi UBÔÇÖden k─▒sa bir ┼čekilde de─či┼čtirilemez.

Bu, derleyicinin bir referansta daha fazla optimizasyon yapmas─▒na izin vermelidir.


117


2008-09-11





En ├Ânemli k─▒sm─▒ unuttun:

i┼čaret├žilerle ->
├╝ye eri┼čimi referanslar─▒ kullanan ├╝ye eri┼čimi kullan─▒r .

foo.bar oldu─ču a├ž─▒k├ža daha ├╝st├╝n foo->bar oldu─ču ayn─▒ ┼čekilde vi oldu─čunu a├ž─▒k bir ┼čekilde daha ├╝st├╝n Emacs :-)


109







Referanslar i┼čaret├žilere ├žok benzer, ancak derleyicileri optimize etmek i├žin ├Âzel olarak haz─▒rlanm─▒┼člard─▒r.

  • Referanslar, derleyicinin hangi de─či┼čken takma adlar─▒n─▒ izlemesini ├Ânemli ├Âl├ž├╝de kolayla┼čt─▒racak ┼čekilde tasarlanm─▒┼čt─▒r. ─░ki ana ├Âzellik ├žok ├Ânemlidir: "referans aritmeti─či" yoktur ve referanslar─▒n yeniden atanmas─▒ yoktur. Bunlar, derleyicinin, derleme zaman─▒nda hangi de─či┼čkenlerin hangi takma adlar─▒ referans ald─▒─č─▒n─▒ bulmas─▒n─▒ sa─člar.
  • Referanslar─▒n, derleyicinin kay─▒t alt─▒na almay─▒ se├žti─či gibi, haf─▒za adresleri olmayan de─či┼čkenlere g├Ânderme yapmas─▒na izin verilir. Yerel bir de─či┼čkenin adresini al─▒rsan─▒z, derleyicinin onu bir kay─▒t defterine koymas─▒ ├žok zordur.

├ľrnek olarak:

 void maybeModify(int& x); // may modify x in some way

void hurtTheCompilersOptimizer(short size, int array[])
{
    // This function is designed to do something particularly troublesome
    // for optimizers. It will constantly call maybeModify on array[0] while
    // adding array[1] to array[2]..array[size-1]. There's no real reason to
    // do this, other than to demonstrate the power of references.
    for (int i = 2; i < (int)size; i++) {
        maybeModify(array[0]);
        array[i] += array[1];
    }
}
 

Bir optimizasyon derleyicisi bir [0] ve [1] grubuna tam olarak eri┼čti─čimizi fark edebilir. Algoritmay─▒ a┼ča─č─▒dakilere g├Âre optimize etmek ister:

 void hurtTheCompilersOptimizer(short size, int array[])
{
    // Do the same thing as above, but instead of accessing array[1]
    // all the time, access it once and store the result in a register,
    // which is much faster to do arithmetic with.
    register int a0 = a[0];
    register int a1 = a[1]; // access a[1] once
    for (int i = 2; i < (int)size; i++) {
        maybeModify(a0); // Give maybeModify a reference to a register
        array[i] += a1;  // Use the saved register value over and over
    }
    a[0] = a0; // Store the modified a[0] back into the array
}
 

B├Âyle bir optimizasyon yapmak i├žin, ├ža─čr─▒ s─▒ras─▒nda hi├žbir dizinin [1] de─či┼čemeyece─čini ispatlamas─▒ gerekir. Bunu yapmak olduk├ža kolayd─▒r. i hi├žbir zaman 2'den az de─čildir, bu nedenle [i] dizisi asla [1] dizisine ba┼čvuruda bulunamaz. maybeModify () referans olarak a0 olarak verilir (aliasing array [0]). "Referans" aritmeti─či olmad─▒─č─▒ i├žin, derleyici sadece belkiModify'nin asla x'in adresini alamad─▒─č─▒n─▒ kan─▒tlamak zorundad─▒r ve hi├žbir ┼čeyin diziyi de─či┼čtiremedi─čini kan─▒tlam─▒┼čt─▒r [1].

Ayr─▒ca, gelecekteki bir ├ža─čr─▒n─▒n a0'da ge├žici bir siciline sahipken bir [0] okuma / yazma yolu bulunmad─▒─č─▒n─▒ kan─▒tlamas─▒ gerekir. Bu genellikle kan─▒tlamak i├žin ├Ânemsizdir, ├ž├╝nk├╝ ├žo─ču durumda referans─▒n hi├žbir zaman bir s─▒n─▒f ├Ârne─či gibi kal─▒c─▒ bir yap─▒da saklanmad─▒─č─▒ a├ž─▒kt─▒r.

┼×imdi ayn─▒ ┼čeyi i┼čaret├žilerle de yap─▒n

 void maybeModify(int* x); // May modify x in some way

void hurtTheCompilersOptimizer(short size, int array[])
{
    // Same operation, only now with pointers, making the
    // optimization trickier.
    for (int i = 2; i < (int)size; i++) {
        maybeModify(&(array[0]));
        array[i] += array[1];
    }
}
 

Davran─▒┼č ayn─▒d─▒r; ancak ┼čimdi, belki deModdify'nin diziyi [1] hi├ž de─či┼čtirmedi─čini ispatlamak ├žok daha zor, ├ž├╝nk├╝ biz zaten bir i┼čaret├ži verdik; kedi ├žantadan ├ž─▒kt─▒. ┼×imdi ├žok daha zor bir kan─▒t─▒ yapmal─▒: asla & x + 1'e yazmad─▒─č─▒n─▒ ispatlamak i├žin maybeModify'nin statik bir analizi. Ayr─▒ca [0] dizisine ba┼čvurabilecek bir g├Âstergeden asla tasarruf etmedi─čini de kan─▒tlamak zorunda. zor gibi.

Modern derleyiciler statik analizde daha iyi ve daha iyi hale geliyorlar, ancak referanslar─▒ kullanmak ve bunlar─▒ kullanmak her zaman g├╝zeldir.

Elbette, b├Âyle ak─▒ll─▒ optimizasyonlar─▒ engelleyen derleyiciler, gerekti─činde referanslar─▒ i┼čaret├žilere d├Ân├╝┼čt├╝recektir.

EDIT: Bu cevab─▒ g├Ânderdikten be┼č y─▒l sonra, referanslar─▒n ayn─▒ adresleme konseptine bakman─▒n farkl─▒ bir yolundan farkl─▒ oldu─ču ger├žek bir teknik fark buldum. Referanslar, ge├žici nesnelerin ├Âmr├╝n├╝, i┼čaret├žilerin yapamayaca─č─▒ ┼čekilde de─či┼čtirebilir.

 F createF(int argument);

void extending()
{
    const F& ref = createF(5);
    std::cout << ref.getArgument() << std::endl;
};
 

Normal olarak, ├ža─čr─▒n─▒n yaratt─▒─č─▒ gibi ge├žici nesneler createF(5) , ifadenin sonunda imha edilir. Bununla birlikte, bu nesneyi bir referansa ba─člayarak ref , C ++ bu ge├žici nesnenin ├Âmr├╝n├╝ ref kapsam d─▒┼č─▒na ├ž─▒kana kadar uzatacakt─▒r .


66







Asl─▒nda, referans ger├žekten bir i┼čaret├ži gibi de─čildir.

Bir derleyici de─či┼čkenleri "referanslar─▒" tutar, bir ismi haf─▒za adresiyle ili┼čkilendirir; Derleme yaparken herhangi bir de─či┼čken ismini bir haf─▒za adresine ├ževirmek i┼či budur.

Bir referans olu┼čtururken, derleyiciye sadece pointer de─či┼čkenine ba┼čka bir isim atad─▒─č─▒n─▒z─▒ s├Âyleyin; bu nedenle referanslar "bo┼č g├Âsteremez", ├ž├╝nk├╝ bir de─či┼čken olamaz ve olamaz.

─░┼čaret├žiler de─či┼čkendir; ba┼čka bir de─či┼čkenin adresini i├žeriyorlar veya bo┼č olabilirler. ├ľnemli olan, bir g├Âstergenin bir de─čere sahip olmas─▒d─▒r, bir referans ise sadece referans verdi─či de─či┼čkendir.

┼×imdi ger├žek kodun bir a├ž─▒klamas─▒:

 int a = 0;
int& b = a;
 

Burada, i┼čaret eden ba┼čka bir de─či┼čken yaratm─▒yorsunuz a ; sadece de─čerini tutan haf─▒za i├žeri─čine ba┼čka bir isim ekliyorsunuz a . Bu bellek ┼čimdi iki ismi vard─▒r, a ve b , ve o da ad─▒n─▒ kullanarak ele al─▒nabilir.

 void increment(int& n)
{
    n = n + 1;
}

int a;
increment(a);
 

Bir i┼člev ├ža─č─▒r─▒rken, derleyici genellikle kopyalanacak arg├╝manlar i├žin haf─▒za alanlar─▒ olu┼čturur. ─░┼člev imzas─▒, yarat─▒lmas─▒ gereken alanlar─▒ tan─▒mlar ve bu alanlar i├žin kullan─▒lmas─▒ gereken ad─▒ verir. Bir parametreyi referans olarak bildirmek derleyiciye, y├Ântem ├ža─čr─▒s─▒ s─▒ras─▒nda yeni bir bellek alan─▒ tahsis etmek yerine giri┼č de─či┼čkeni bellek alan─▒n─▒ kullanmas─▒n─▒ s├Âyler. ─░┼člevinizin ├ža─č─▒ran kapsamda bildirilen bir de─či┼čkeni do─črudan i┼čleme koyaca─č─▒n─▒ s├Âylemek garip gelebilir, ancak derlenmi┼č kod y├╝r├╝t├╝l├╝rken ba┼čka bir kapsam olmad─▒─č─▒n─▒ unutmay─▒n; sadece d├╝z d├╝z haf─▒za var ve fonksiyon kodunuz herhangi bir de─či┼čkende de─či┼čiklik yapabilir.

┼×imdi, derleyicinizin, bir d─▒┼č de─či┼čken kullan─▒rken oldu─ču gibi derleme s─▒ras─▒nda referans─▒ bilemeyece─či baz─▒ durumlar olabilir. Bu nedenle referans, temel kodda bir i┼čaret├ži olarak uygulanabilir veya uygulanmayabilir. Ancak size verdi─čim ├Ârneklerde, b├╝y├╝k olas─▒l─▒kla bir i┼čaret├ži ile uygulanmayacakt─▒r.


63







Bir referans asla olamaz NULL .


39


2008-09-11





Hem referanslar hem de i┼čaret├žiler dolayl─▒ olarak ba┼čka bir de─čere eri┼čmek i├žin kullan─▒l─▒rken, referanslar ve i┼čaret├žiler aras─▒nda iki ├Ânemli fark vard─▒r. Birincisi, referans─▒n her zaman bir nesneye g├Ânderme yapt─▒─č─▒d─▒r: Bir referans─▒ ba┼člatmadan tan─▒mlamak bir hatad─▒r. Atama davran─▒┼č─▒ ikinci ├Ânemli farkt─▒r: Bir referansa atanmak referans─▒n ba─čl─▒ oldu─ču nesneyi de─či┼čtirir; ba┼čvuruyu ba┼čka bir nesneye yeniden ba─člamad─▒. Ba┼člat─▒ld─▒ktan sonra, referans her zaman ayn─▒ temel nesneye at─▒fta bulunur.

Bu iki program par├žas─▒n─▒ g├Âz ├Ân├╝nde bulundurun. ─░lk ├Ânce, bir i┼čaret├žiyi di─čerine atar─▒z:

 int ival = 1024, ival2 = 2048;
int *pi = &ival, *pi2 = &ival2;
pi = pi2;    // pi now points to ival2
 

├ľdevden sonra, ival, pi taraf─▒ndan adreslenen nesne de─či┼čmeden kal─▒r. Atama, pi'nin de─čerini de─či┼čtirerek farkl─▒ bir nesneye i┼čaret eder. ┼×imdi iki referans atanan benzer bir program d├╝┼č├╝n├╝n:

 int &ri = ival, &ri2 = ival2;
ri = ri2;    // assigns ival2 to ival
 

Bu atama referans─▒n kendisinde de─čil, ri taraf─▒ndan referans al─▒nan de─čer olan ival'yi de─či┼čtirir. ├ľdevden sonra, iki referans hala orijinal nesnelerine at─▒fta bulunur ve bu nesnelerin de─čeri ┼čimdi de ayn─▒d─▒r.


33







Bilgisayar dillerini soyut veya akademik bir ┼čekilde ├Â─črenmeye a┼čina de─čilseniz, ezoterik g├Âr├╝nebilecek anlamsal bir fark vard─▒r.

En ├╝st d├╝zeyde, referanslar fikri ┼čeffaf "takma" olmalar─▒d─▒r. Bilgisayar─▒n─▒z─▒n ├žal─▒┼čmas─▒n─▒ sa─člamak i├žin bir adres kullanabilir, ancak bunun i├žin endi┼čelenmeniz gerekmiyor: onlar─▒ varolan bir nesne i├žin "ba┼čka bir ad" olarak d├╝┼č├╝nmeniz gerekiyor ve s├Âzdizimi bunu yans─▒t─▒yor. ─░┼čaret├žilerden daha kat─▒ olduklar─▒ndan derleyiciniz sarkan bir referans olu┼čturmak ├╝zereyken sarkan bir i┼čaret├ži olu┼čturmak ├╝zereyken oldu─čundan daha g├╝venilir bir ┼čekilde sizi uyarabilir.

Bunun ├Âtesinde, elbette i┼čaret├žiler ve referanslar aras─▒nda baz─▒ pratik farkl─▒l─▒klar vard─▒r. Bunlar─▒ kullanmak i├žin kullan─▒lan s├Âzdizimi a├ž─▒k├ža farkl─▒d─▒r ve referanslar─▒ "yeniden s─▒ralayamaz", hi├žlik referanslar─▒ veya referanslara i┼čaret├žileriniz olamaz.


28







Bir referans, ba┼čka bir de─či┼čken i├žin bir takma isimdir, oysa bir i┼čaret├ži bir de─či┼čkenin haf─▒za adresini tutar. Referanslar genellikle i┼člev parametreleri olarak kullan─▒l─▒r, b├Âylece iletilen nesne kopya de─čil nesnenin kendisidir.

     void fun(int &a, int &b); // A common usage of references.
    int a = 0;
    int &b = a; // b is an alias for a. Not so common to use. 
 

24







Ne kadar yer kaplad─▒─č─▒ ├Ânemli de─čildir, ├ž├╝nk├╝ ne kadar yer kaplayaca─č─▒n─▒n herhangi bir yan etkisini (kod ├žal─▒┼čt─▒rmadan) g├Âremezsiniz.

├ľte yandan, referanslar ve i┼čaret├žiler aras─▒ndaki en b├╝y├╝k farklardan biri, ba┼čvuru referanslar─▒ i├žin atanan ge├žicilerin, ba┼čvuru referans─▒ kapsam d─▒┼č─▒nda olana kadar devam etmesidir.

├ľrne─čin:

 class scope_test
{
public:
    ~scope_test() { printf("scope_test done!\n"); }
};

...

{
    const scope_test &test= scope_test();
    printf("in scope\n");
}
 

yazd─▒racak:

 in scope
scope_test done!
 

ScopeGuard'─▒n ├žal─▒┼čmas─▒n─▒ sa─člayan dil mekanizmas─▒ budur.


18


2008-09-12





Bu ├Â─čretici dayanmaktad─▒r . Yaz─▒lan ne daha net hale getirir:

 >>> The address that locates a variable within memory is
    what we call a reference to that variable. (5th paragraph at page 63)

>>> The variable that stores the reference to another
    variable is what we call a pointer. (3rd paragraph at page 64)
 

Bunu hat─▒rlamak i├žin basit├že

 >>> reference stands for memory location
>>> pointer is a reference container (Maybe because we will use it for
several times, it is better to remember that reference.)
 

Dahas─▒, herhangi bir i┼čaret├ži e─čitimine ba┼čvurabilece─čimiz gibi, i┼čaret├ži, i┼čaret├žiyi bir diziye benzer yapan i┼čaret├ži aritmetik ile desteklenen bir nesnedir.

A┼ča─č─▒daki ifadeye bak─▒n,

 int Tom(0);
int & alias_Tom = Tom;
 

alias_Tom bir ┼čekilde anla┼č─▒labilir alias of a variable (ile farkl─▒ typedef olan, alias of a type ) Tom . Ayr─▒ca b├Âyle bir ifadenin terminolojisini unutmamak da bir referans olu┼čturmakt─▒r Tom .


18


2014-01-13





Referans, baz─▒ haf─▒zalara verilen ba┼čka bir isim de─čildir. Kullan─▒mda otomatik olarak referanstan kald─▒r─▒lan de─či┼čmez bir i┼čaret├židir. Temelde a┼ča─č─▒ kaynar:

 int& j = i;
 

Dahili olarak olur

 int* const j = &i;
 

18







Bunlardan birine ihtiyac─▒m olmad─▒─č─▒ s├╝rece referanslar─▒ kullan─▒yorum:

  • Bo┼č i┼čaret├žiler, a┼č─▒r─▒ y├╝klenme veya bir bool kullan─▒m─▒n─▒ ├Ânlemek i├žin ucuz bir y├Ântem olan bir sentinel de─čeri olarak kullan─▒labilir.

  • Bir i┼čaret├ži ├╝zerinde aritmetik yapabilirsiniz. ├ľrne─čin, p += offset;


15







─░┼čaret├žiye ba┼čvuru C ++ 'da m├╝mk├╝nd├╝r, ancak bunun tersi m├╝mk├╝n de─čildir, referans i├žin i┼čaret├ži m├╝mk├╝n de─čildir. Bir i┼čaret├žiye yap─▒lan bir referans, i┼čaret├žiyi de─či┼čtirmek i├žin daha temiz bir s├Âzdizimi sa─člar. ┼×u ├Ârne─če bak─▒n:

 #include<iostream>
using namespace std;

void swap(char * &str1, char * &str2)
{
  char *temp = str1;
  str1 = str2;
  str2 = temp;
}

int main()
{
  char *str1 = "Hi";
  char *str2 = "Hello";
  swap(str1, str2);
  cout<<"str1 is "<<str1<<endl;
  cout<<"str2 is "<<str2<<endl;
  return 0;
}
 

Ve yukar─▒daki program─▒n C versiyonunu d├╝┼č├╝n├╝n. C'de i┼čaret├ži i├žin i┼čaret├ži kullanman─▒z gerekir (├žoklu dolayl─▒) ve bu kar─▒┼č─▒kl─▒─ča yol a├žar ve program karma┼č─▒k g├Âr├╝nebilir.

 #include<stdio.h>
/* Swaps strings by swapping pointers */
void swap1(char **str1_ptr, char **str2_ptr)
{
  char *temp = *str1_ptr;
  *str1_ptr = *str2_ptr;
  *str2_ptr = temp;
}

int main()
{
  char *str1 = "Hi";
  char *str2 = "Hello";
  swap1(&str1, &str2);
  printf("str1 is %s, str2 is %s", str1, str2);
  return 0;
}
 

─░┼čaret├žiye ba┼čvuru hakk─▒nda daha fazla bilgi i├žin a┼ča─č─▒dakileri ziyaret edin:

Dedi─čim gibi, referans i├žin bir i┼čaret├ži m├╝mk├╝n de─čildir. A┼ča─č─▒daki program─▒ deneyin:

 #include <iostream>
using namespace std;

int main()
{
   int x = 10;
   int *ptr = &x;
   int &*ptr1 = ptr;
}
 

15







─░┼čaret├žiler ve referanslar aras─▒nda kimsenin bahsetmedi─čini g├Ârmedi─čim temel bir fark var: referanslar, fonksiyon arg├╝manlar─▒nda referans referans anlambilimine olanak tan─▒yor. ─░┼čaret├žiler, ilk ba┼čta g├Âr├╝nmese de, ┼čunlar─▒ yapmazlar: yaln─▒zca de─čer-de─čer anlambilimi sa─člarlar. Bu, bu makalede ├žok g├╝zel bir ┼čekilde tarif edilmi┼čtir .

Sayg─▒lar, & rzej


14







Do─črudan cevap

C ++ 'da ba┼čvuru nedir? Nesne t├╝r├╝ olmayan belirli bir t├╝r ├Ârne─či .

C ++ 'da i┼čaret├ži nedir? Nesne t├╝r├╝ olan belirli bir t├╝r ├Ârne─či .

G├Ânderen nesne t├╝r├╝n├╝n ISO C ++ tan─▒m─▒ :

Bir nesne tipi, bir fonksiyon tipi olmayan, bir referans tipi olmayan ve cv bo┼člu─ču olmayan (muhtemelen cv- nitelendirilmi┼č) bir t├╝rd├╝r .

Nesne tipinin, C ++ 'daki evren tipinin en ├╝st d├╝zey bir kategorisi oldu─čunu bilmek ├Ânemli olabilir. Referans ayn─▒ zamanda ├╝st seviye bir kategoridir. Ancak i┼čaret├ži de─čil.

─░┼čaret├žiler ve referanslar bile┼čik t├╝r├╝ ba─člam─▒nda birlikte belirtilmi┼čtir . Bu, temel olarak, referanslar─▒ olmayan, C'den miras kalan (ve geni┼čletilmi┼č) bildirgenin s├Âzdiziminin niteli─či nedeniyledir. (Ayr─▒ca, C ++ 11'den beri birden fazla referans bildirgesi var, ancak i┼čaret├žiler hala ÔÇťbir aradaÔÇŁ bulunmuyorlard─▒: & + && vs.. * ) Bu nedenle, bu ba─člamda benzer C stiline sahip ÔÇťeklentiÔÇŁ ile spesifik bir dil haz─▒rlamak biraz makul. . (Hala declarators at─▒klar─▒n s├Âzdizimsel anlaml─▒l─▒k s├Âzdizimi oldu─čunu iddia edecektir ├žok insan kullan─▒c─▒lar ve uygulamalar hem sinir bozucu hale getirir. B├Âylece, hepsi edilecek kalifiye de─čilseniz yerle┼čik yeni bir dil tasar─▒m─▒nda. Bu tamamen farkl─▒ bir konudur PL tasar─▒m─▒ hakk─▒nda olsa da.)

Aksi halde, i┼čaret├žilerin birlikte referanslarla belirli t├╝r tipleri olarak nitelendirilebilmesi ├Ânemsizdir. Onlar sadece s├Âzdizimi benzerli─činin yan─▒ s─▒ra ├žok az ortak ├Âzelli─či payla┼č─▒rlar, bu nedenle ├žo─ču durumda bunlar─▒ bir araya getirmeye gerek yoktur.

Yukar─▒daki a├ž─▒klamalar─▒n sadece "i┼čaret├žiler" ve "referanslar" olarak verildi─čini not edin. ├ľrnekleriyle ilgili baz─▒ ilgi ├žekici sorular var (de─či┼čkenler gibi). Ayr─▒ca ├žok fazla yan─▒lg─▒ geliyor.

├ťst d├╝zey kategorilerin farkl─▒l─▒klar─▒, i┼čaret├žilere do─črudan ba─čl─▒ olmayan bir├žok somut farkl─▒l─▒─č─▒ zaten ortaya ├ž─▒karabilir:

  • Nesne t├╝rleri ├╝st d├╝zey cv niteleyicilere sahip olabilir . Referanslar olamaz.
  • Nesne tiplerinin de─či┼čkenli─či , soyut makine anlambilimine g├Âre depolar . Referanslar saklama gerektirmez (ayr─▒nt─▒lar i├žin a┼ča─č─▒daki yanl─▒┼č anlamalarla ilgili b├Âl├╝me bak─▒n).
  • ...

Referanslarla ilgili birka├ž ├Âzel kural:

  • Bile┼čik bildiriciler referanslar konusunda daha k─▒s─▒tlay─▒c─▒d─▒r.
  • Referanslar ├ž├Âkebilir .
    • && ┼×ablon parametresi indirimi s─▒ras─▒ndaki referans ├ž├Âk├╝┼č├╝ne dayanan parametreler ├╝zerine ├Âzel kurallar ("y├Ânlendirme referanslar─▒" olarak) parametrelerin "m├╝kemmel ┼čekilde iletilmesine" izin verir .
  • Referanslar─▒n ba┼člang─▒├žta ├Âzel kurallar─▒ vard─▒r. Referans tipi olarak bildirilen de─či┼čkenin ├Âmr├╝, uzatma yoluyla s─▒radan nesnelerden farkl─▒ olabilir.
    • BTW, ilk kullan─▒ma ba┼člama gibi di─čer birka├ž ba─člam std::initializer_list , referans ├Âmr├╝n├╝n uzamas─▒na ili┼čkin baz─▒ benzer kurallar─▒ izler. Bir ba┼čka solucan kutusudur.
  • ...

Kavram yan─▒lg─▒lar─▒

S├Âzdizimsel ┼čeker

Referanslar─▒n s├Âzdizimsel ┼čeker oldu─čunu biliyorum, bu y├╝zden kodun okunmas─▒ ve yaz─▒lmas─▒ daha kolay.

Teknik olarak, bu d├╝z yanl─▒┼č. Referanslar, C ++ 'daki herhangi bir ba┼čka ├Âzelli─čin s├Âzdizimsel ┼čekeri de─čildir, ├ž├╝nk├╝ herhangi bir anlamsal farkl─▒l─▒k g├Âstermeden ba┼čka ├Âzelliklerin yerini alamazlar.

(Benzer ┼čekilde, lambda-ekspresyonlar─▒ s, C ++ 'da di─čer herhangi bir ├Âzelli─čin s├Âzdizimsel ┼čekeri de─čildir , ├ž├╝nk├╝ yakalanan de─či┼čkenlerin bildirim s─▒ras─▒ gibi "belirtilmemi┼č" ├Âzelliklerle tam olarak sim├╝le edilemez , ├ž├╝nk├╝ bu de─či┼čkenlerin ba┼člang─▒├ž ÔÇőÔÇős─▒ras─▒ olabilir; ├Ânemli.)

C ++ bu anlamda sadece birka├ž ├že┼čit s├Âzdizimsel ┼čekere sahiptir. Bir ├Ârnek (C miras) yerle┼čik (non-a┼č─▒r─▒) operat├Âr [] , tam olarak ├╝zerinde yerle┼čik operat├Âr tekli kombinasyon spesifik formlar─▒n─▒n, ayn─▒ anlam ├Âzelliklere sahip tan─▒mlan─▒r * ve ikili + .

Depolama

Dolay─▒s─▒yla, bir i┼čaret├ži ve bir referans hem ayn─▒ miktarda belle─či kullan─▒r.

Yukar─▒daki ifade sadece yanl─▒┼čt─▒r. Bu t├╝r yanl─▒┼č anlamalar─▒ ├Ânlemek i├žin, bunun yerine ISO C ++ kurallar─▒na bak─▒n:

Kaynaktan [intro.object] / 1 :

... Bir nesne, in┼čaat s├╝resi boyunca, ├Âmr├╝ boyunca ve imha s├╝resince bir depolama b├Âlgesini i┼čgal eder. ...

Kaynaktan [dcl.ref] / 4 :

Bir referans─▒n depolama gerektirip gerektirmedi─či belirtilmemi┼č.

Bunlar─▒n anlamsal ├Âzellikleri oldu─čuna dikkat edin .

Edimbilim

Bu i┼čaret├žiler, dil tasar─▒m─▒ anlam─▒nda referanslarla bir araya getirilebilecek kadar nitelikli olmasalar da, ├Ârne─čin parametre t├╝rlerinde se├žimler yaparken, di─čer baz─▒ ba─člamlarda aralar─▒nda se├žim yapmay─▒ tart─▒┼č─▒lmaz k─▒lan baz─▒ arg├╝manlar var.

Ama bu t├╝m hikaye de─čil. Demek istedi─čim, i┼čaret├žilerden daha ├žok ┼čey var - referanslar─▒ g├Âz ├Ân├╝nde bulundurman─▒z gerekir.

Bu kadar spesifik se├žimlere ba─čl─▒ kalmak zorunda kalmazsan─▒z, ├žo─ču durumda cevap k─▒sad─▒r: i┼čaret├ži kullanma zorunlulu─čunuz yoktur, bu y├╝zden kullanmazs─▒n─▒z . ─░┼čaret├žiler genellikle yeterince k├Ât├╝d├╝r, ├ž├╝nk├╝ beklemeyece─činiz ├žok fazla ┼čey ima ederler ve kodun korunabilirli─čini ve (hatta) ta┼č─▒nabilirli─čini zay─▒flatan ├žok fazla gizli varsay─▒mlara g├╝venirler. Gereksiz yere i┼čaret├žilere g├╝venmek kesinlikle k├Ât├╝ bir stildir ve modern C ++ anlam─▒nda kullan─▒lmamal─▒d─▒r. Amac─▒n─▒z─▒ yeniden g├Âzden ge├žirin ; ├žo─ču durumda bu i┼čaret├žinin son t├╝r ├Âzelliklerden biri oldu─čunu g├Âreceksiniz .

  • Bazen dil kurallar─▒ a├ž─▒k├ža kullan─▒lacak ├Âzel tipler gerektirir. Bu ├Âzellikleri kullanmak istiyorsan─▒z kurallara uyun.
    • Kopya yap─▒c─▒lar , ilk parametre t├╝r├╝ olarak belirli t├╝rlerde cv - & referans tipi gerektirir . (Ve genellikle const nitelikli olmal─▒d─▒r .)
    • Move yap─▒c─▒lar─▒ , ilk parametre t├╝r├╝ olarak belirli t├╝rlerde cv - && referans tipi gerektirir . (Genelde niteleyici olmamal─▒d─▒r.)
    • Operat├Ârlerin belirli a┼č─▒r─▒ y├╝kleri referans veya referans olmayan tipler gerektirir. ├ľrne─čin:
      • operator= ├ľzel ├╝ye i┼člevleri olarak a┼č─▒r─▒ y├╝kleme , kopyalama / ta┼č─▒ma yap─▒c─▒lar─▒n─▒n 1. parametresine benzer referans t├╝rleri gerektirir.
      • Postfix ++ kukla gerektirir int .
      • ...
  • Parola de─čeri (├Ârne─čin referans olmayan t├╝rleri kullanmak) yeterliyse, ├Âzellikle C ++ 17 zorunlu kopya se├žimini destekleyen bir uygulama kullan─▒rken do─črudan kullan─▒n. ( Uyar─▒ : Bununla birlikte, gereklilik hakk─▒nda ayr─▒nt─▒l─▒ bir sebepten dolay─▒ ├žok karma┼č─▒k olabilir .)
  • Baz─▒ tutama├žlar─▒ sahiplikle ├žal─▒┼čt─▒rmak istiyorsan─▒z , ham i┼čaret├žiler yerine, unique_ptr ve shared_ptr (veya bunlar─▒n opak olmalar─▒n─▒ istiyorsan─▒z, kendi ba┼č─▒n─▒za bile homebrew olanlar) gibi ak─▒ll─▒ i┼čaret├žiler kullan─▒n .
  • Bir aral─▒ktaki baz─▒ yinelemeler yap─▒yorsan─▒z, ham i┼čaret├žiler ├žok ├Âzel bir ┼čekilde daha iyi olaca─č─▒na (├Ârne─čin daha az ba┼čl─▒k ba─č─▒ml─▒l─▒─č─▒ i├žin) ikna olmad─▒k├ža yineleyiciler (veya hen├╝z standart k├╝t├╝phane taraf─▒ndan sa─članmayan baz─▒ aral─▒klar) kullan─▒n. vakalar.
  • Parola de─čerinin yeterli oldu─čunu biliyorsan─▒z ve baz─▒ a├ž─▒k nullabilimsel anlambilim istiyorsan─▒z std::optional , ham i┼čaret├žiler yerine, gibi bir sar─▒c─▒ kullan─▒n .
  • Parola de─čerinin yukar─▒daki nedenlerden dolay─▒ ideal olmad─▒─č─▒n─▒ biliyorsan─▒z ve bo┼č anlamsal anlambilim istemiyorsan─▒z, {lvalue, rvalue, forwarding} -references komutunu kullan─▒n.
  • Geleneksel i┼čaret├ži gibi anlambilgisi istemeseniz bile observer_ptr , K├╝t├╝phane Temel TS'de oldu─ču gibi, genellikle daha uygun bir ┼čeyler vard─▒r .

Tek istisnalar ┼ču anki dilde ├ž├Âz├╝lemez:

  • Yukar─▒daki ak─▒ll─▒ i┼čaret├žileri uygulad─▒─č─▒n─▒zda, ham i┼čaret├žilerle u─čra┼čman─▒z gerekebilir.
  • Belirli bir dil-birlikte ├žal─▒┼čma rutinleri, gibi i┼čaret├žiler gerektirir operator new . (Ancak, cv - void* s─▒radan nesne i┼čaret├žilerine k─▒yasla hala olduk├ža farkl─▒ ve daha g├╝venlidir, ├ž├╝nk├╝ GNU'larda oldu─ču gibi baz─▒ uygun olmayan uzant─▒lara g├╝venmiyorsan─▒z, beklenmeyen imle├ž aritmetiklerini ekarte eder void* .)
  • ─░┼člev i┼čaret├žileri yakalama olmadan lambda ifadelerinden d├Ân├╝┼čt├╝r├╝lebilir, i┼člev referanslar─▒ olamaz. Bu gibi durumlarda, genel olmayan kodda i┼člev i┼čaret├žileri kullanman─▒z gerekir, hatta kas─▒tl─▒ olarak null de─čerlerini istemezsiniz.

Bu y├╝zden pratikte cevap ├žok a├ž─▒k: ┼č├╝pheliyken i┼čaret├žilerden ka├ž─▒n─▒n . ─░┼čaret├žileri yaln─▒zca ba┼čka hi├žbir ┼čeyin daha uygun olmamas─▒n─▒n ├žok a├ž─▒k nedenleri oldu─čunda kullanman─▒z gerekir. Yukar─▒da belirtilen birka├ž istisnai durum d─▒┼č─▒nda, bu se├žimler neredeyse her zaman yaln─▒zca tamamen C ++ 'ya ├Âzg├╝ de─čildir (ancak dile g├Âre uygulamaya ├Âzg├╝ olmas─▒ muhtemeldir). Bu gibi durumlar olabilir:

  • Eski tarz (C) APIÔÇÖlere sunman─▒z gerekir.
  • Belirli C ++ uygulamalar─▒n─▒n ABI gereksinimlerini kar┼č─▒laman─▒z gerekir.
  • Belirli uygulamalar─▒n varsay─▒mlar─▒na dayanarak, ├žal─▒┼čma zaman─▒nda farkl─▒ dil uygulamalar─▒yla (├že┼čitli derlemeler, dil ├žal─▒┼čma zaman─▒ ve baz─▒ ├╝st d├╝zey istemci dillerinin FFI'si dahil) birlikte ├žal─▒┼čman─▒z gerekir.
  • Baz─▒ a┼č─▒r─▒ durumlarda ├ževirinin etkinli─čini (derleme ve ba─člant─▒) geli┼čtirmelisin.
  • Baz─▒ a┼č─▒r─▒ durumlarda sembol ┼či┼čmesinden ka├ž─▒nmal─▒s─▒n─▒z.

Dil tarafs─▒zl─▒─č─▒ uyar─▒lar─▒

Soruyu baz─▒ Google arama sonu├žlar─▒yla (C ++ 'a ├Âzg├╝ de─čil) g├Ârmeye gelirseniz , bunun yanl─▒┼č yer olmas─▒ ├žok muhtemeldir.

C ++ 'da yap─▒lan referanslar olduk├ža "tuhaf" t─▒r, ├ž├╝nk├╝ temelde birinci s─▒n─▒f de─čildir: ba┼čvurulan nesneler veya i┼člevler olarak de─čerlendirilirler; bu nedenle, birinci s─▒n─▒f i┼člemlerin sol i┼členeni gibi baz─▒ birinci s─▒n─▒f i┼člemleri destekleme ┼čanslar─▒ yoktur . ├╝ye eri┼čim operat├Âr├╝ , belirtilen nesnenin t├╝r├╝nden ba─č─▒ms─▒z olarak. Di─čer diller referanslar─▒nda benzer k─▒s─▒tlamalara sahip olabilir veya olmayabilir.

C ++ 'daki referanslar muhtemelen farkl─▒ dillerde anlam ifade etmeyecektir. ├ľrne─čin, genel olarak yap─▒lan referanslar, C ++ 'da oldu─ču gibi de─čerler ├╝zerindeki bo┼č olmayan ├Âzellikleri ima etmez, bu nedenle bu varsay─▒mlar di─čer baz─▒ dillerde ├žal─▒┼čmayabilir (ve kar┼č─▒ ├Ârnekleri kolayca bulabilirsiniz, ├Ârne─čin Java, C #, ...).

Genel olarak farkl─▒ programlama dillerindeki referanslar aras─▒nda hala baz─▒ ortak ├Âzellikler olabilir, ancak bunu SO'daki di─čer baz─▒ sorular i├žin b─▒rakal─▒m.

(Bir not: soru, ALGOL 68'e kar┼č─▒ PL / I gibi herhangi bir "C benzeri" dilin dahil edilmesinden daha ├Ânemli olabilir .)


14







Kar─▒┼č─▒kl─▒─ča neden olma riski alt─▒nda baz─▒ girdiler yazmak istiyorum, bunun ├žo─čunlukla derleyicinin referanslar─▒ nas─▒l uygulad─▒─č─▒na ba─čl─▒ oldu─čuna eminim, ancak gcc olmas─▒ durumunda, bir referans─▒n y─▒─č─▒nda sadece bir de─či┼čkeni g├Âsterebilece─či fikri asl─▒nda do─čru de─čil, ├Ârne─čin ┼čunu al:

 #include <iostream>
int main(int argc, char** argv) {
    // Create a string on the heap
    std::string *str_ptr = new std::string("THIS IS A STRING");
    // Dereference the string on the heap, and assign it to the reference
    std::string &str_ref = *str_ptr;
    // Not even a compiler warning! At least with gcc
    // Now lets try to print it's value!
    std::cout << str_ref << std::endl;
    // It works! Now lets print and compare actual memory addresses
    std::cout << str_ptr << " : " << &str_ref << std::endl;
    // Exactly the same, now remember to free the memory on the heap
    delete str_ptr;
}
 

Bunu ├ž─▒karan hangisi:

 THIS IS A STRING
0xbb2070 : 0xbb2070
 

Haf─▒za adreslerinin bile tamamen ayn─▒ oldu─čunu fark ederseniz, referans ba┼čar─▒yla ├Âbek ├╝zerindeki bir de─či┼čkeni i┼čaret eder! ┼×imdi ger├žekten garip olmak istiyorsan─▒z, bu da i┼če yar─▒yor:

 int main(int argc, char** argv) {
    // In the actual new declaration let immediately de-reference and assign it to the reference
    std::string &str_ref = *(new std::string("THIS IS A STRING"));
    // Once again, it works! (at least in gcc)
    std::cout << str_ref;
    // Once again it prints fine, however we have no pointer to the heap allocation, right? So how do we free the space we just ignorantly created?
    delete &str_ref;
    /*And, it works, because we are taking the memory address that the reference is
    storing, and deleting it, which is all a pointer is doing, just we have to specify
    the address with '&' whereas a pointer does that implicitly, this is sort of like
    calling delete &(*str_ptr); (which also compiles and runs fine).*/
}
 

Bunu ├ž─▒karan hangisi:

 THIS IS A STRING
 

Bu nedenle bir referans ba┼čl─▒k alt─▒nda bir i┼čaret├židir, her ikisi de sadece adresin i┼čaret etti─či yerde bir bellek adresi sakl─▒yorlar, std :: cout << str_ref olarak adland─▒r─▒l─▒rsam ne olaca─č─▒n─▒ d├╝┼č├╝n├╝yorsunuz; ├ça─čr─▒n─▒n SONRA delete & str_ref? Belli ki iyi derler, ancak ├žal─▒┼čma zaman─▒nda bir b├Âl├╝mleme hatas─▒na neden olur ├ž├╝nk├╝ art─▒k ge├žerli bir de─či┼čkeni i┼čaret etmiyor, temelde hala var olan (kapsam d─▒┼č─▒na d├╝┼čene kadar) k─▒r─▒lm─▒┼č bir referans─▒m─▒z var.

Ba┼čka bir deyi┼čle, referans, i┼čaret├ži mekani─činin soyutlanm─▒┼č olan bir i┼čaret├židen ba┼čka bir ┼čey de─čildir, kullan─▒m─▒ daha g├╝venli ve daha kolay hale getirir (yanl─▒┼čl─▒kla i┼čaret├ži matemati─či yok, '.' Ve '->' vb. Kar─▒┼čmaz). yukar─▒daki ├Ârneklerim gibi sa├žma sapanlar─▒ denemeyin;)

┼×imdi bir derleyicinin referanslar─▒ nas─▒l ele ald─▒─č─▒na bak─▒lmaks─▒z─▒n , ba┼čl─▒k alt─▒nda her zaman bir t├╝r i┼čaret├ži olacakt─▒r , ├ž├╝nk├╝ bir referans─▒n beklendi─či gibi ├žal─▒┼čmas─▒ i├žin belirli bir haf─▒za adresindeki belirli bir de─či┼čkene ba┼čvurmas─▒ gerekir , bu nedenle bu konuda bir sorun yoktur. 'referans' terimi.

Referanslarla hat─▒rlanmas─▒ gereken tek ├Ânemli kural, beyan s─▒ras─▒nda tan─▒mlanmalar─▒ gerekti─čidir (bir ba┼čl─▒ktaki bir referans hari├ž, bu durumda yap─▒c─▒da tan─▒mlanmal─▒d─▒r, i├žinde bulundu─ču nesne onu tan─▒mlamak i├žin ├žok ge├ž in┼ča etti).

Unutmay─▒n, yukar─▒daki ├Ârneklerim, referans─▒n ne oldu─čunu g├Âsteren ├Ârneklerdir, bir referans─▒ asla bu ┼čekilde kullanmak istemezsiniz! Bir referans─▒n do─čru kullan─▒m─▒ i├žin zaten kafan─▒n ├╝zerinde ├živiyi vuran ├žok say─▒da cevap var.


13


2014-10-14





Ba┼čka bir fark, ge├žersiz bir tipte i┼čaret├žileriniz olabilir (ve bu herhangi bir ┼čeye i┼čaret├ži anlam─▒na gelir) ancak bo┼člu─ča referanslar yasakt─▒r.

 int a;
void * p = &a; // ok
void & p = a;  //  forbidden
 

Bu ├Âzel farktan ger├žekten ├žok mutlu oldu─čumu s├Âyleyemem. Adrese sahip herhangi bir ┼čeye anlam referans─▒ ve referanslar i├žin ayn─▒ davran─▒┼ča izin verilmesini ├žok tercih ederim. Referanslar kullanarak memcpy gibi baz─▒ C k├╝t├╝phanesi i┼člevlerinin tan─▒mlanmas─▒na izin verir.


12







Ayr─▒ca, s─▒ral─▒ bir i┼člevin parametresi olan bir referans, bir i┼čaret├židen farkl─▒ ┼čekilde ele al─▒nabilir.

 void increment(int *ptrint) { (*ptrint)++; }
void increment(int &refint) { refint++; }
void incptrtest()
{
    int testptr=0;
    increment(&testptr);
}
void increftest()
{
    int testref=0;
    increment(testref);
}
 

─░┼čaret├ži versiyonunu ilk sat─▒rlara yerle┼čtirirken ├žo─ču derleyici asl─▒nda belle─če yazmaya zorlar (adresi a├ž─▒k├ža al─▒yoruz). Bununla birlikte, referans─▒ daha uygun olan bir kay─▒t defterinde b─▒rakacaklar.

Tabii ki, ├žizgisiz olmayan fonksiyonlar i├žin i┼čaret├ži ve referans ayn─▒ kodu ├╝retir ve fonksiyon taraf─▒ndan de─či┼čtirilmez ve d├Ând├╝r├╝lmezlerse, referans olarak de─čere g├Âre ger├žekleri iletmek her zaman daha iyidir.


11







Referanslar─▒n ba┼čka bir ilgin├ž kullan─▒m─▒, kullan─▒c─▒ tan─▒ml─▒ bir t├╝r├╝n varsay─▒lan arg├╝man─▒n─▒ sa─člamakt─▒r:

 class UDT
{
public:
   UDT() : val_d(33) {};
   UDT(int val) : val_d(val) {};
   virtual ~UDT() {};
private:
   int val_d;
};

class UDT_Derived : public UDT
{
public:
   UDT_Derived() : UDT() {};
   virtual ~UDT_Derived() {};
};

class Behavior
{
public:
   Behavior(
      const UDT &udt = UDT()
   )  {};
};

int main()
{
   Behavior b; // take default

   UDT u(88);
   Behavior c(u);

   UDT_Derived ud;
   Behavior d(ud);

   return 1;
}
 

Varsay─▒lan lezzet, referanslar─▒n 'ge├žici const referans─▒n─▒ ge├žici' olarak kullan─▒r.


10







Bu program, sorunun cevab─▒n─▒ anlamada yard─▒mc─▒ olabilir. Bu "j" referans─▒n─▒n basit bir program─▒ ve "x" de─či┼čkenine i┼čaret eden "ptr" i┼čaret├žisidir.

 #include<iostream>

using namespace std;

int main()
{
int *ptr=0, x=9; // pointer and variable declaration
ptr=&x; // pointer to variable "x"
int & j=x; // reference declaration; reference to variable "x"

cout << "x=" << x << endl;

cout << "&x=" << &x << endl;

cout << "j=" << j << endl;

cout << "&j=" << &j << endl;

cout << "*ptr=" << *ptr << endl;

cout << "ptr=" << ptr << endl;

cout << "&ptr=" << &ptr << endl;
    getch();
}
 

Program─▒ ├žal─▒┼čt─▒r─▒n ve ├ž─▒kt─▒ya bir g├Âz at─▒n, anlayacaks─▒n─▒z.

Ayr─▒ca, 10 dakika ay─▒r─▒n ve bu videoyu izleyin: https://www.youtube.com/watch?v=rlJrrGV0iOg


10







Burada ele al─▒nmayan ba┼čka bir nokta oldu─čunu hissediyorum.

─░┼čaret├žilerden farkl─▒ olarak, ba┼čvurular ba┼čvuruda bulunduklar─▒ nesneye s├Âzdizimsel olarak e┼čde─čerdir , yani bir nesneye uygulanabilecek herhangi bir i┼člem referans i├žin ├žal─▒┼č─▒r ve ayn─▒ s├Âzdizimiyle (istisna elbette ba┼člang─▒├žt─▒r).

Bu y├╝zeysel g├Âr├╝nse de, bu ├Âzelli─čin baz─▒ C ++ ├Âzellikleri i├žin ├žok ├Ânemli oldu─čuna inan─▒yorum, ├Ârne─čin:

  • ┼×ablonlar . ┼×ablon parametreleri ├Ârdek tipinde oldu─čundan, bir t├╝r├╝n s├Âzdizimsel ├Âzellikleri ├Ânemli olan ┼čeydir, bu nedenle s─▒k s─▒k ayn─▒ ┼čablon hem T ve hem de kullan─▒labilir T& .
    (ya std::reference_wrapper<T> da hala ├Ârt├╝l├╝ bir oyuncuya dayan─▒yor T& )
    Her ikisini de kapsayan T& ve T&& daha yayg─▒n olan ┼čablonlar .

  • SolDe─čerler . ─░fadesini g├Âz ├Ân├╝nde bulundurun str[0] = 'X'; Referanslar olmadan sadece c-string'ler ( char* str ) i├žin i┼če yarar . Karakteri referansa g├Âre d├Ând├╝rmek, kullan─▒c─▒ tan─▒ml─▒ s─▒n─▒flar─▒n ayn─▒ notaya sahip olmas─▒n─▒ sa─člar.

  • Olu┼čturucular─▒ kopyala . S├Âzdizimsel olarak, yap─▒c─▒lar─▒ kopyalamak i├žin nesneler iletmek anlaml─▒d─▒r, nesnelere i┼čaret├žiler de─čil. Ancak, bir kopya kurucusunun de─čeriyle bir nesneyi almas─▒n─▒n hi├žbir yolu yoktur - bu ayn─▒ kopya kurucuyu ├Âzyinelemeli bir ├ža─čr─▒ ile sonu├žlanacakt─▒r. Bu referanslar─▒ burada tek se├ženek olarak b─▒rak─▒r.

  • Operat├Âr a┼č─▒r─▒ y├╝kleniyor . Referanslarla, bir operat├Âr ├ža─čr─▒s─▒na dolayl─▒ olarak giri┼č yapmak m├╝mk├╝nd├╝r - ├Ârne─čin operator+(const T& a, const T& b) ayn─▒ ek g├Âsterimi koruyarak. Bu ayr─▒ca normal a┼č─▒r─▒ y├╝kl├╝ fonksiyonlar i├žin de ge├žerlidir.

Bu noktalar, C ++ 'n─▒n ├Ânemli bir b├Âl├╝m├╝n├╝ ve standart k├╝t├╝phaneyi g├╝├žlendirir, bu nedenle bu referanslar─▒n olduk├ža b├╝y├╝k bir ├Âzelli─čidir.


9


2017-07-06





Belki baz─▒ metaforlar yard─▒mc─▒ olabilir; Masa├╝st├╝ ekran alan─▒n─▒z ba─člam─▒nda -

  • Bir referans ger├žek bir pencere belirlemenizi gerektirir.
  • Bir i┼čaret├ži, ekran ├╝zerinde o pencere t├╝r├╝n├╝n s─▒f─▒r veya daha fazla ├Ârne─čini i├žerece─činden emin oldu─čunuz bir bo┼čluk par├žas─▒n─▒n konumunu gerektirir.

8







─░┼čaret├žiler ve referanslar aras─▒nda teknik olarak ├žok ├Ânemli bir fark var: ─░┼čaret├ži taraf─▒ndan bir i┼čleve iletilen bir arg├╝man, bir i┼čleve const olmayan ba┼čvuru taraf─▒ndan iletilen bir arg├╝mandan ├žok daha fazla g├Âr├╝n├╝r. ├ľrne─čin:

 void fn1(std::string s);
void fn2(const std::string& s);
void fn3(std::string& s);
void fn4(std::string* s);

void bar() {
    std::string x;
    fn1(x);  // Cannot modify x
    fn2(x);  // Cannot modify x (without const_cast)
    fn3(x);  // CAN modify x!
    fn4(&x); // Can modify x (but is obvious about it)
}
 

C'ye d├Ân├╝┼čt├╝─č├╝nde, benzeyen bir ├ža─čr─▒ fn(x) yaln─▒zca de─čere g├Âre aktar─▒labilir, bu nedenle kesinlikle de─či┼čtirilemez x ; Bir arg├╝man─▒ de─či┼čtirmek i├žin bir i┼čaret├žiyi ge├žmeniz gerekir fn(&x) . Yani e─čer bir arg├╝man & sizden ├Ânce gelmediyse, de─či┼čtirilmeyece─čini biliyordunuz. (Cone, & de─či┼čtirilmi┼č ara├žlar anlam─▒na gelmez, ├ž├╝nk├╝ bazen salt okunur b├╝y├╝k yap─▒lar─▒ const i┼čaret├ži ile ge├žmek zorunda kal─▒rs─▒n─▒z .)

Baz─▒lar─▒ bunun kodu okurken ├žok faydal─▒ bir ├Âzellik oldu─čunu, i┼čaret├ži parametrelerinin const referans atamadan ziyade de─či┼čtirilebilen parametreler i├žin her zaman , fonksiyonun hi├ž beklemese bile kullan─▒lmas─▒ gerekti─čini iddia eder nullptr . Yani, bu insanlar fn3() yukar─▒daki gibi i┼člev imzalar─▒n─▒n kabul edilmemesi gerekti─čini savunuyorlar . Google'─▒n C ++ stil kurallar─▒ buna bir ├Ârnektir.


8







─░┼čaret├ži ve referans aras─▒ndaki fark

Bir i┼čaret├ži 0 olarak ba┼člat─▒labilir ve bir referans de─čil. Asl─▒nda bir referans ayn─▒ zamanda bir nesneye de at─▒fta bulunmal─▒d─▒r, ancak bir i┼čaret├ži bo┼č g├Âsterici olabilir:

 int* p = 0;
 

Ama olamaz int& p = 0; da ve int& p=5 ; .

Asl─▒nda, do─čru bir ┼čekilde yapabilmek i├žin, ilk ├Ânce bir nesneyi tan─▒mlam─▒┼č ve tan─▒mlam─▒┼č olmal─▒y─▒z, o zaman bu nesneye referans verebiliriz, bu nedenle ├Ânceki kodun do─čru bir ┼čekilde uygulanmas─▒:

 Int x = 0;
Int y = 5;
Int& p = x;
Int& p1 = y;
 

Bir di─čer ├Ânemli nokta, g├Âstericinin bildirimini ba┼člatmadan yapabiliriz, ancak referans durumunda her zaman de─či┼čken veya nesneye referans olmas─▒ gereken b├Âyle bir ┼čey yap─▒lamaz. Bununla birlikte, bir i┼čaret├žinin bu ┼čekilde kullan─▒m─▒ risklidir, bu nedenle genellikle i┼čaret├žinin ger├žekte bir ┼čeye i┼čaret edip etmedi─čini kontrol ederiz. Bir referans olmas─▒ durumunda, b├Âyle bir kontrol gerekli de─čildir, ├ž├╝nk├╝ zaten bir bildirim s─▒ras─▒nda bir nesneye at─▒fta bulunman─▒n zorunlu oldu─čunu biliyoruz.

Ba┼čka bir fark, i┼čaret├žinin ba┼čka bir nesneyi g├Âsterebilmesidir, ancak referans her zaman ayn─▒ nesneye g├Ânderme yapar, hadi bu ├Ârne─či ele alal─▒m:

 Int a = 6, b = 5;
Int& rf = a;

Cout << rf << endl; // The result we will get is 6, because rf is referencing to the value of a.

rf = b;
cout << a << endl; // The result will be 5 because the value of b now will be stored into the address of a so the former value of a will be erased
 

Ba┼čka bir nokta: STL ┼čablonu gibi bir ┼čablona sahip oldu─čumuzda, bu t├╝r bir s─▒n─▒f ┼čablonu, [] i┼člecini kullanarak kolay okuma veya yeni de─čer atamak i├žin her zaman bir i┼čaret├ži de─čil bir referans d├Ând├╝recektir:

 Std ::vector<int>v(10); // Initialize a vector with 10 elements
V[5] = 5; // Writing the value 5 into the 6 element of our vector, so if the returned type of operator [] was a pointer and not a reference we should write this *v[5]=5, by making a reference we overwrite the element by using the assignment "="
 

6







Aradaki fark, sabit olmayan g├Âsterici de─či┼čkeninin (bir g├Âsterici ile sabitlenmeyecek ┼čekilde kar─▒┼čt─▒r─▒lmas─▒), program y├╝r├╝tme s─▒ras─▒nda bir anda de─či┼čtirilebilmesi, referanslar─▒n ba┼člat─▒lmas─▒ ├╝zerine ayarlanabilmesi i├žin kullan─▒lan i┼čaret├ži anlambilimine ihtiya├ž duymas─▒d─▒r (&, *) operat├Ârleri yaln─▒zca (bu nedenle bunlar─▒ yaln─▒zca yap─▒c─▒ ba┼člat─▒c─▒ listesinde ayarlayabilir, ancak ba┼čka bir ┼čekilde de─čil) ve s─▒radan de─čer eri┼čim anlambilimi kullanabilirsiniz. ├çok eski baz─▒ kitaplarda okudu─čum gibi operat├Ârlerin a┼č─▒r─▒ y├╝klenmesine destek vermek i├žin temel olarak referanslar tan─▒t─▒ld─▒. Bu i┼č par├žas─▒nda belirtildi─či gibi - i┼čaret├ži 0 olarak veya istedi─činiz de─čerde ayarlanabilir. 0 (NULL, nullptr), i┼čaret├žinin hi├žbir ┼čey olmadan ba┼člat─▒ld─▒─č─▒ anlam─▒na gelir. Bo┼č g├Âstericiyi ge├žersiz k─▒lmak bir hatad─▒r. Ancak asl─▒nda i┼čaret├ži, do─čru haf─▒za konumuna i┼čaret etmeyen bir de─čer i├žerebilir. S─▒ras─▒yla referanslar, kullan─▒c─▒n─▒n her zaman do─čru t├╝rde de─čer verdi─činizden dolay─▒ referans al─▒namayan bir ┼čeye referans ba┼člatmas─▒na izin vermemeye ├žal─▒┼č─▒r. Referans de─či┼čkeni yanl─▒┼č bir bellek konumuna ba┼člatmak i├žin bir├žok yol olsa da, bunu daha ayr─▒nt─▒l─▒ olarak incelemeyin. Makine seviyesinde, hem i┼čaret├ži hem de referans e┼čit ┼čekilde ├žal─▒┼č─▒r - i┼čaret├žiler arac─▒l─▒─č─▒yla. Diyelim ki temel referanslarda s├Âzdizimsel ┼čeker var. de─čer referanslar─▒ bundan farkl─▒d─▒r - bunlar do─čal olarak y─▒─č─▒n / y─▒─č─▒n nesneleridir.


5







Her zaman bu kurala C ++ Çekirdek İlkelerinden karar veririm :

T * yerine T * tercih et ve "arg├╝man yok" ge├žerli bir se├ženek oldu─čunda


2



─░lgili yay─▒nlar


Git taahh├╝tlerinde ├žift noktal─▒ ÔÇť..ÔÇŁ ve ├╝├ž noktal─▒ ÔÇťÔÇŽÔÇŁ aras─▒ndaki farklar nelerdir?

Char array ile C i├žindeki char pointer aras─▒ndaki fark nedir?

C# 'daki de─či┼čken ve de─či┼čken bir dize aras─▒ndaki fark nedir?

Git diff taahh├╝tlerinde ├žift noktal─▒ ÔÇť..ÔÇŁ ve ├╝├ž noktal─▒ ÔÇťÔÇŽÔÇŁ aras─▒ndaki farklar nelerdir?

Kullan─▒c─▒ de─či┼čkenleri ve sistem de─či┼čkenleri aras─▒ndaki fark nedir?

XSLÔÇÖde 'call-template' ve 'application-templates' aras─▒ndaki farklar nelerdir?

C++ 'da int ile uzun aras─▒ndaki fark nedir?

MySQL'deki BLOB ve TEXT veri tipleri aras─▒ndaki farklar nelerdir?

C'deki exit (0) ve exit (1) aras─▒ndaki fark nedir?

C#'daki myCustomer.GetType () ve typeof (Customer) aras─▒ndaki fark nedir?

Etiketle ilgili di─čer sorular [c++]


Bir s├╝tunu de─či┼čtirmek: bo┼č de─čil bo┼č

Scala 2.8 koleksiyon k├╝t├╝phanesi ÔÇťtarihteki en uzun intihar notuÔÇŁ ├Ârne─či mi? [kapal─▒]

JQuery kullanarak klavyede Enter tu┼čuna nas─▒l bas─▒l─▒r?

Kavanoza maven 2 build classpath ├╝r├╝n├╝n├╝ kurmadan ekleyebilir miyim?

YAML ve JSON aras─▒ndaki fark nedir?

INotifyPropertyChanged uygulamak - daha iyi bir yol var m─▒?

Bir ├Ânceki s├Âz sonu├žlar─▒na bir .then () zincirinde nas─▒l eri┼čirim?

T├╝m Unix grup adlar─▒n─▒ listelemek i├žin bir komut var m─▒? [kapal─▒]

Soyut bir s─▒n─▒f─▒n kurucusu olabilir mi?

Belirli alanlardaki kopyalar─▒ bulmak i├žin ifadeyi se├žin