Operat├Âr a┼č─▒r─▒ y├╝klemesi i├žin temel kurallar ve deyimler nelerdir?


Al─▒nan cevaba git


Not: Cevaplar belirli bir s─▒raya g├Âre verilmi┼čtir , ancak bir├žok kullan─▒c─▒ cevaplar─▒ verilen zaman yerine oylara g├Âre s─▒ralad─▒─č─▒ndan, cevaplar─▒n en anlaml─▒ oldu─ču s─▒raya g├Âre bir dizini a┼ča─č─▒da bulabilirsiniz :

(Not: Bu, Stack Overflow'un C ++ SSS'sine bir giri┼č anlam─▒na gelir . Bu formda bir SSS sa─člama fikrini ele┼čtirmek istiyorsan─▒z, t├╝m bunlar─▒ ba┼člatan metada kay─▒t yapmak bunun i├žin uygun olacakt─▒r. Bu soru , SSS fikrinin en ba┼čtan ba┼člad─▒─č─▒ C ++ sohbet odas─▒nda izlenir , bu nedenle cevab─▒n─▒z fikri ortaya ├ž─▒kanlar taraf─▒ndan okunmas─▒ ├žok muhtemeldir.)


2052





2010-12-12




Cevap say─▒s─▒n─▒ say: 7






Yayg─▒n olarak ├žal─▒┼čan operat├Ârler

A┼č─▒r─▒ y├╝kleme operat├Ârlerinde yap─▒lan ├žal─▒┼čmalar─▒n ├žo─ču kazan plakas─▒ kodudur. Operat├Ârler sadece s├Âzdizimsel ┼čeker olduklar─▒ i├žin, as─▒l i┼či d├╝z i┼člevlerle yap─▒labilir (ve genellikle iletilir). Ancak bu kazan plakas─▒ kodunu do─čru alman─▒z ├Ânemlidir. Ba┼čar─▒s─▒z olursan─▒z, operat├Âr kodunuz derlenmez veya kullan─▒c─▒ kodunuz derlenmez veya kullan─▒c─▒ kodunuz ┼ča┼č─▒rt─▒c─▒ ┼čekilde davran─▒r.

Atama operat├Âr├╝

├ľdev hakk─▒nda s├Âylenecek ├žok ┼čey var. Bununla birlikte, ├žo─ču GMan'─▒n ├╝nl├╝ Kopyala ve Takas SSS b├Âl├╝m├╝nde zaten s├Âylendi , bu y├╝zden ├žo─čunu atlayaca─č─▒m, sadece referans i├žin m├╝kemmel atama operat├Âr├╝n├╝ listeleyece─čim:

 X& X::operator=(X rhs)
{
  swap(rhs);
  return *this;
}
 

Bitshift Operat├Ârleri (Ak─▒┼č I / O i├žin kullan─▒l─▒r)

U├ž kayd─▒rma operat├Ârleri << ve >> yine de C'den devrald─▒klar─▒ bit i┼čleme fonksiyonlar─▒ i├žin donan─▒m ara y├╝z├╝nde kullan─▒lmas─▒na ra─čmen, ├žo─ču uygulamada a┼č─▒r─▒ y├╝klenen ak─▒┼č giri┼č ve ├ž─▒k─▒┼č operat├Ârleri olarak daha yayg─▒n hale gelmi┼čtir. Bit manip├╝lasyon operat├Ârleri olarak k─▒lavuz a┼č─▒r─▒ y├╝kleme i├žin, a┼ča─č─▒daki ─░kili Aritmetik Operat├Ârler b├Âl├╝m├╝ne bak─▒n─▒z. Kendi ├Âzel bi├žiminizi uygulamak ve nesneniz iostreams ile kullan─▒ld─▒─č─▒nda ayr─▒┼čt─▒rma mant─▒─č─▒n─▒ kullanmak i├žin devam edin.

Ak─▒m i┼čle├žleri, en fazla a┼č─▒r─▒ y├╝klenmi┼č i┼čle├žler aras─▒nda, s├Âzdiziminin, ├╝ye olup olmad─▒klar─▒na ili┼čkin herhangi bir k─▒s─▒tlama belirtmedi─či, ikili giri┼č ekli i┼člemcilerdir. Sol arg├╝manlar─▒n─▒ de─či┼čtirdikleri i├žin (derenin durumunu de─či┼čtirirler), temel kurallara g├Âre sol operand─▒n─▒n t├╝r├╝n├╝n ├╝yeleri olarak uygulanmalar─▒ gerekir. Ancak, sol i┼členenleri standart kitapl─▒ktan ak─▒┼člard─▒r ve standart kitapl─▒k taraf─▒ndan tan─▒mlanan ak─▒┼č ├ž─▒k─▒┼č ve giri┼č operat├Ârlerinin ├žo─ču ger├žekten kendi t├╝rleriniz i├žin ├ž─▒k─▒┼č ve giri┼č i┼člemlerini uygulad─▒─č─▒n─▒zda, ak─▒┼č s─▒n─▒flar─▒n─▒n ├╝yeleri olarak tan─▒mlan─▒r. standart k├╝t├╝phanenin yay─▒n t├╝rlerini de─či┼čtiremez. Bu y├╝zden bu operat├Ârleri ├╝ye olmayan fonksiyonlar olarak kendi tiplerinize uygulaman─▒z gerekiyor. ─░ki kanonik formlar─▒ ┼čunlard─▒r:

 std::ostream& operator<<(std::ostream& os, const T& obj)
{
  // write obj to stream

  return os;
}

std::istream& operator>>(std::istream& is, T& obj)
{
  // read obj from stream

  if( /* no valid object of T found in stream */ )
    is.setstate(std::ios::failbit);

  return is;
}
 

Uygulama yaparken operator>> , ak─▒m─▒n durumunu manuel olarak ayarlamak sadece okuma ba┼čar─▒l─▒ oldu─čunda gereklidir, ancak sonu├ž beklenece─či gibi de─čildir.

─░┼člev ├ža─čr─▒s─▒ operat├Âr├╝

Ayr─▒ca i┼člevler olarak da bilinen i┼člev nesnelerini olu┼čturmak i├žin kullan─▒lan i┼člev ├ža─čr─▒s─▒ i┼čleci, ├╝ye i┼člevi olarak tan─▒mlanmal─▒d─▒r , bu nedenle her zaman this ├╝ye i┼člevlerin ├Ârt├╝k arg├╝man─▒na sahiptir. Bunun d─▒┼č─▒nda, s─▒f─▒r dahil herhangi bir say─▒da ek arg├╝man almak i├žin a┼č─▒r─▒ y├╝klenebilir.

─░┼čte s├Âzdiziminin bir ├Ârne─či:

 class foo {
public:
    // Overloaded call operator
    int operator()(const std::string& y) {
        // ...
    }
};
 

Kullan─▒m─▒:

 foo f;
int a = f("hello");
 

C ++ standart k├╝t├╝phanesi boyunca, fonksiyon nesneleri daima kopyalan─▒r. Bu nedenle kendi i┼člev nesneleriniz kopyalamak i├žin ucuz olmal─▒d─▒r. Bir i┼člev nesnesinin kesinlikle kopyalanmas─▒ pahal─▒ olan verileri kullanmas─▒ gerekiyorsa, bu verileri ba┼čka bir yerde saklamak ve i┼člev nesnesine ba┼čvurmak daha iyidir.

Kar┼č─▒la┼čt─▒rma operat├Ârleri

─░kili infix kar┼č─▒la┼čt─▒rma operat├Ârleri, kurallara g├Âre ├╝ye olmayan fonksiyonlar 1 olarak uygulanmal─▒d─▒r . Unary ├Ânek ihmali ! (ayn─▒ kurallara g├Âre) bir ├╝ye i┼člevi olarak uygulanmal─▒d─▒r. (ama genellikle a┼č─▒r─▒ y├╝klemesi iyi bir fikir de─čildir.)

Standart k├╝t├╝phanenin algoritmalar─▒ (├Âr. std::sort() ) Ve t├╝rleri (├Âr. std::map ) Daima operator< mevcut olmay─▒ bekler . Bununla birlikte, t├╝r├╝n├╝z├╝n kullan─▒c─▒lar─▒ di─čer t├╝m operat├Ârlerin de bulunmas─▒n─▒ bekler , bu nedenle tan─▒mlarsan─▒z operator< , operat├Âr├╝n a┼č─▒r─▒ y├╝klenmesinin ├╝├ž├╝nc├╝ temel kural─▒na uydu─čunuzdan ve di─čer t├╝m Boole kar┼č─▒la┼čt─▒rma operat├Ârlerini tan─▒mlad─▒─č─▒n─▒zdan emin olun. Bunlar─▒ uygulaman─▒n kurall─▒ yolu ┼čudur:

 inline bool operator==(const X& lhs, const X& rhs){ /* do actual comparison */ }
inline bool operator!=(const X& lhs, const X& rhs){return !operator==(lhs,rhs);}
inline bool operator< (const X& lhs, const X& rhs){ /* do actual comparison */ }
inline bool operator> (const X& lhs, const X& rhs){return  operator< (rhs,lhs);}
inline bool operator<=(const X& lhs, const X& rhs){return !operator> (lhs,rhs);}
inline bool operator>=(const X& lhs, const X& rhs){return !operator< (lhs,rhs);}
 

Burada dikkat edilmesi gereken ├Ânemli nokta, bu operat├Ârlerin sadece ikisinin asl─▒nda bir ┼čey yapmas─▒, di─čerleri ise as─▒l i┼či yapmak i├žin arg├╝manlar─▒n─▒ bu ikisinden birine iletiyor olmas─▒d─▒r.

Kalan ikili boole i┼čle├žlerini ( || , && ) a┼č─▒r─▒ y├╝kleme s├Âzdizimi , kar┼č─▒la┼čt─▒rma i┼čle├žlerinin kurallar─▒na uyar. Ancak, bu 2 i├žin makul bir kullan─▒m vakas─▒ bulman─▒z ├žok olas─▒ de─čildir .

1 T├╝m kurallarda oldu─ču gibi, bazen bunu da k─▒rmak i├žin sebepler olabilir. ├ľyleyse, ├╝ye i┼člevler i├žin olacak olan ikili kar┼č─▒la┼čt─▒rma operat├Ârlerinin sol i┼členeninin de olmas─▒ *this gerekti─čini unutmay─▒n const . Dolay─▒s─▒yla, ├╝ye i┼člevi olarak uygulanan bir kar┼č─▒la┼čt─▒rma i┼člecinin ┼ču imzay─▒ ta┼č─▒mas─▒ gerekir:

 bool operator<(const X& rhs) const { /* do actual comparison with *this */ }
 

( const Sonunda not edin .)

2 Yerle┼čik s├╝r├╝m├╝n k─▒sayol anlambilimi kulland─▒─č─▒ || ve && kulland─▒─č─▒ belirtilmelidir. Kullan─▒c─▒ tan─▒ml─▒ olanlar ise (├ž├╝nk├╝ y├Ântem ├ža─čr─▒lar─▒ i├žin s├Âzdizimsel ┼čeker olduklar─▒ i├žin) k─▒sayol anlambilimi kullanmazlar. Kullan─▒c─▒ bu operat├Ârlerden k─▒sayol anlambilimine sahip olmas─▒n─▒ bekler ve kodlar─▒ buna ba─čl─▒ olabilir, Bu nedenle onlar─▒ tan─▒mlamak ASLA tavsiye edilmez.

Aritmetik operat├Ârler

Unary aritmetik operat├Ârler

Unary art─▒m ve azal─▒┼č operat├Ârleri hem prefix hem postfix lezzetlerinde gelir. Birinden di─čerine s├Âylemek gerekirse, postfix varyantlar─▒ ek bir kukla int arg├╝man─▒ al─▒r. Art─▒┼č veya azalmay─▒ a┼č─▒r─▒ y├╝klerseniz, her zaman hem ├Ânek hem de sonek s├╝r├╝mlerini uygulad─▒─č─▒n─▒zdan emin olun. ─░┼čte art─▒m─▒n kanonik uygulamas─▒d─▒r, azal─▒┼č ayn─▒ kurallar─▒ izler:

 class X {
  X& operator++()
  {
    // do actual increment
    return *this;
  }
  X operator++(int)
  {
    X tmp(*this);
    operator++();
    return tmp;
  }
};
 

Postfix varyant─▒n─▒n ├Ânek olarak uyguland─▒─č─▒na dikkat edin. Ayr─▒ca postfix ek bir kopya yapt─▒─č─▒n─▒ unutmay─▒n. 2

A┼č─▒r─▒ eksi ve art─▒ a┼č─▒r─▒ y├╝kleme ├žok yayg─▒n de─čildir ve muhtemelen en iyi ┼čekilde ka├ž─▒n─▒lmal─▒d─▒r. Gerekirse, muhtemelen ├╝ye i┼člevleri olarak a┼č─▒r─▒ y├╝klenmeleri gerekir.

2 Ayr─▒ca, postfix varyant─▒n─▒n daha fazla i┼č yapt─▒─č─▒n─▒ ve bu nedenle, prefix varyant─▒ndan daha az verimli oldu─čunu unutmay─▒n. Bu genellikle ├Ân ek art─▒┼čtan sonra ├Ânek art─▒┼č─▒n─▒ tercih etmek i├žin iyi bir nedendir. Derleyiciler, yerle┼čik t├╝rler i├žin ek postfix art─▒┼č ├žal─▒┼čmalar─▒n─▒ genellikle en iyi duruma getirebilse de, kullan─▒c─▒ tan─▒ml─▒ t├╝rler i├žin ayn─▒ ┼čeyi yapamayabilirler (bu, bir liste yineleyici gibi g├Âr├╝nen bir ┼čey olabilir). Bir kez al─▒┼čmaya ba┼člad─▒─č─▒n─▒zda , yerle┼čik bir tip olmad─▒─č─▒ zaman ( bunun yerine bir tip de─či┼čtirirken kodu de─či┼čtirmeniz gerekecektir) i++ yapmay─▒ hat─▒rlamak ├žok zorla┼č─▒r , bu y├╝zden her zaman al─▒┼čkanl─▒k edinmeniz daha iyi olur. Postfix a├ž─▒k├ža gerekli olmad─▒k├ža, ├Ânek art─▒┼č─▒n─▒ kullanarak. ++i i

─░kili aritmetik operat├Ârler

─░kili aritmetik operat├Ârleri i├žin, ├╝├ž├╝nc├╝ temel kural operat├Âr├╝ a┼č─▒r─▒ y├╝klemesine uymay─▒ unutmay─▒n─▒z: E─čer + sa─člarsan─▒z += , e─čer sa─člarsan─▒z - , ihmal etmeyin -= , vs. de ihmal etmeyin . operat├Ârler, bile┼čik olmayan meslekta┼člar─▒ i├žin baz olarak kullan─▒labilir. Yani, operat├Âr oldu─ču + anlam─▒nda uygulanan += , - a├ž─▒s─▒ndan uygulanmaktad─▒r -= vb

Temel kurallar─▒m─▒za g├Âre + , yolda┼člar─▒ ├╝ye olmamal─▒, bile┼čik atamalar─▒ ( += vb.), Sol arg├╝manlar─▒n─▒ de─či┼čtirerek, bir ├╝ye olmal─▒d─▒r. Burada i├žin ├Ârnek te┼čkil eden bir kod += ve + ; di─čer ikili aritmetik operat├Ârleri de ayn─▒ ┼čekilde uygulanmal─▒d─▒r:

 class X {
  X& operator+=(const X& rhs)
  {
    // actual addition of rhs to *this
    return *this;
  }
};
inline X operator+(X lhs, const X& rhs)
{
  lhs += rhs;
  return lhs;
}
 

operator+= sonucuna g├Âre sonucunu, sonucunun operator+ bir kopyas─▒n─▒ d├Ând├╝r├╝r. Tabii ki, bir referans─▒n geri g├Ânderilmesi, genellikle bir kopyay─▒ geri g├Ândermekten daha etkilidir, ancak, bu durumda operator+ , kopyalaman─▒n etraf─▒nda bir yol yoktur. E─čer yazarken a + b , sonu├ž neden olan yeni bir de─čer, olmas─▒n─▒ bekliyoruz operator+ yeni bir de─čer d├Ând├╝rmek zorundad─▒r. 3 Ayr─▒ca operator+ sol operand─▒n─▒ const referans─▒ yerine kopya ile ald─▒─č─▒na dikkat edin . Bunun nedeni operator= kopya ba┼č─▒na arg├╝man─▒n─▒ almas─▒ i├žin verilen sebeple ayn─▒d─▒r .

Bit manip├╝lasyon operat├Ârleri ~ & | ^ << >> , aritmetik operat├Ârler ile ayn─▒ ┼čekilde uygulanmal─▒d─▒r. Ancak, (a┼č─▒r─▒ y├╝kleme << ve >> ├ž─▒k─▒┼č ve giri┼č hari├ž) bunlar─▒ a┼č─▒r─▒ y├╝klemek i├žin ├žok az makul kullan─▒m durumu vard─▒r.

3 Yine, bundan al─▒nacak ders a += b , genel olarak, a + b e─čer m├╝mk├╝nse daha etkili ve tercih edilmelidir.

Dizi Aboneli─či

Dizi alt y├Âneticisi operat├Âr├╝, s─▒n─▒f ├╝yesi olarak uygulanmas─▒ gereken ikili bir operat├Ârd├╝r. Veri ├Â─čelerine bir anahtarla eri┼čime izin veren konteyner benzeri t├╝rler i├žin kullan─▒l─▒r. Bunlar─▒ sa─člaman─▒n kanonik ┼čekli ┼čudur:

 class X {
        value_type& operator[](index_type idx);
  const value_type& operator[](index_type idx) const;
  // ...
};
 

S─▒n─▒f─▒n─▒zdaki kullan─▒c─▒lar─▒n d├Ând├╝rd├╝─č├╝ veri ├Â─čelerini de─či┼čtirmelerini istemiyorsan─▒z operator[] (bu durumda const olmayan varyant─▒ ├ž─▒karamazs─▒n─▒z), her zaman operat├Âr├╝n her iki t├╝revini de sa─člaman─▒z gerekir.

Value_type'nin yerle┼čik bir t├╝re ba┼čvurdu─ču biliniyorsa, operat├Âr├╝n const varyant─▒, const referans─▒ yerine bir kopyas─▒na daha iyi d├Ând├╝rmelidir:

 class X {
  value_type& operator[](index_type idx);
  value_type  operator[](index_type idx) const;
  // ...
};
 

─░┼čaret├ži T├╝rleri i├žin Operat├Ârler

Kendi yineleyicilerinizi veya ak─▒ll─▒ i┼čaret├žilerinizi tan─▒mlamak i├žin, unary ├Âneki dereference operat├Âr├╝n├╝ * ve ikili infix pointer ├╝ye eri┼čim operat├Âr├╝n├╝ a┼č─▒r─▒ y├╝klemeniz gerekir -> :

 class my_ptr {
        value_type& operator*();
  const value_type& operator*() const;
        value_type* operator->();
  const value_type* operator->() const;
};
 

Bunlar─▒n da hemen hemen her zaman bir const ve const olmayan bir s├╝r├╝me ihtiya├ž duyaca─č─▒na dikkat edin. ─░├žin -> operat├Âr├╝n, e─čer value_type ait class (ya da struct ya da union , ba┼čka bir) tip operator->() bir kadar ard─▒┼č─▒k olarak adland─▒r─▒l─▒r operator->() olmayan s─▒n─▒f t├╝r├╝ getirileri bir de─čer.

Tekli operat├Âr adresi asla a┼č─▒r─▒ y├╝klenmemelidir.

Bu soruyu operator->*() g├Ârmek i├žin . Nadiren kullan─▒l─▒r ve bu nedenle nadiren a┼č─▒r─▒ y├╝klenir. Asl─▒nda, yineleyiciler bile a┼č─▒r─▒ y├╝klemez.https://stackoverflow.com/q/8777845/140719


D├Ân├╝┼č├╝m Operat├Ârlerine Devam Ethttps://stackoverflow.com/questions/4421706/operator-overloading/16615725%2316615725#16615725


998


2010-12-12





C ++ 'da Operat├Âr A┼č─▒r─▒ Y├╝klemesinin ├ť├ž Temel Kural─▒

C ++ 'da operat├Âr├╝n a┼č─▒r─▒ y├╝klenmesi s├Âz konusu oldu─čunda izlemeniz gereken ├╝├ž temel kural vard─▒r . T├╝m bu kurallarda oldu─ču gibi, ger├žekten de istisnalar var. Bazen insanlar onlardan sapt─▒ ve sonu├ž k├Ât├╝ kod de─čildi, ancak bu t├╝r olumlu sapmalar ├žok azd─▒. En az─▒ndan, g├Ârd├╝─č├╝m bu 100 sapmadan 99'u haks─▒zd─▒. Bununla birlikte, 1000 ├╝zerinden 999 olabilir. Dolay─▒s─▒yla, a┼ča─č─▒daki kurallara uyman─▒z daha iyi olur.

  1. Ne zaman bir operat├Âr├╝n anlam─▒ a├ž─▒k├ža belli de─čilse ve tart─▒┼č─▒lmazsa, a┼č─▒r─▒ y├╝klenmemelidir. Bunun yerine, iyi se├žilmi┼č bir ada sahip bir i┼člev sa─člay─▒n.
    Temel olarak, operat├Ârlerin a┼č─▒r─▒ y├╝klenmesinin ilk ve en ├Ânemli kural─▒, ├Âz├╝nde diyor ki: Yapma . Bu garip g├Âr├╝nebilir, ├ž├╝nk├╝ operat├Âr├╝n a┼č─▒r─▒ y├╝klenmesi hakk─▒nda bilinmesi gereken ├žok ┼čey var ve bu y├╝zden bir├žok makale, kitap b├Âl├╝m├╝ ve di─čer metinler bunlarla ilgileniyor. Ancak bu a├ž─▒k├ža bariz kan─▒tlara ra─čmen, operat├Âr├╝n a┼č─▒r─▒ y├╝klenmesinin uygun oldu─ču ┼ča┼č─▒rt─▒c─▒ bir ┼čekilde birka├ž durum var . Bunun nedeni, operat├Âr├╝n uygulama alan─▒ndaki kullan─▒m─▒ iyi bilinmedi─či ve tart─▒┼čmas─▒z olmad─▒─č─▒ s├╝rece, bir operat├Âr uygulamas─▒n─▒n arkas─▒ndaki anlambilimin anla┼č─▒lmas─▒n─▒n zor olmas─▒d─▒r. Pop├╝ler inan─▒┼č─▒n aksine, bu hi├ž de b├Âyle de─čil.

  2. Her zaman operat├Âr├╝n bilinen semanti─čine ba─čl─▒ kal─▒n.
    C ++, a┼č─▒r─▒ y├╝klenmi┼č operat├Ârlerin anlamlar─▒yla ilgili herhangi bir s─▒n─▒rlama getirmemektedir. Derleyiciniz mutlu bir ┼čekilde + sa─č operat├Âr├╝nden ├ž─▒kartmaki├žin ikilii┼čleciuygulayan kodu kabul edecektir. Ancak, b├Âyle bir operat├Âr├╝n kullan─▒c─▒lar─▒ ifadesini ┼č├╝pheli asla a + b ├ž─▒karmak i├žin a gelen b . Tabii ki, bu uygulama alan─▒ndaki operat├Âr├╝n anlam─▒n─▒n tart─▒┼č─▒lmaz oldu─čunu varsayar.

  3. Daima bir dizi ilgili i┼člemi ger├žekle┼čtirin.
    Operat├Ârler birbirleriyle ve di─čer i┼člemlerle ilgilidir. T├╝r├╝n├╝z destekliyorsa a + b , kullan─▒c─▒lar da arayabilir a += b . ├ľn ek art─▒┼č─▒n─▒ destekliyorsa ++a , a++ ├žal─▒┼čmay─▒ dabekleyeceklerdir. E─čer olup olmad─▒─č─▒n─▒ kontrol edebiliyorlarsa a < b , kesinlikle kontrol edip etmeyeceklerini de bekleyeceklerdir a > b . T├╝r├╝n├╝z├╝ kopyalayabiliyorlarsa, ├žal─▒┼čman─▒n da ├žal─▒┼čmas─▒n─▒ beklerler.


├ťye ve ├ťye Olmayanlar Aras─▒ Karar─▒na Devam Etme .


475


2010-12-12





C ++ 'da operat├Âr├╝n a┼č─▒r─▒ y├╝klenmesinin genel s├Âzdizimi

C ++ 'da yerle┼čik t├╝rler i├žin operat├Ârlerin anlam─▒n─▒ de─či┼čtiremezsiniz, operat├Ârler yaln─▒zca kullan─▒c─▒ tan─▒ml─▒ t├╝rler 1 i├žin a┼č─▒r─▒ y├╝klenebilir . Yani, i┼členenlerden en az birinin kullan─▒c─▒ tan─▒ml─▒ t├╝rde olmas─▒ gerekir. Di─čer a┼č─▒r─▒ y├╝klenmi┼č fonksiyonlarda oldu─ču gibi, operat├Ârler belirli bir parametre seti i├žin yaln─▒zca bir kez a┼č─▒r─▒ y├╝klenebilir.

T├╝m operat├Ârler C ++ 'da a┼č─▒r─▒ y├╝klenemez. A┼č─▒r─▒ y├╝klenemeyen operat├Ârler aras─▒nda: . :: sizeof typeid .* ve C ++ 'da tek ├╝├žl├╝ operat├Âr, ?:

C ++ 'da a┼č─▒r─▒ y├╝klenebilen operat├Ârler aras─▒nda ┼čunlar vard─▒r:

  • aritmetik operat├Ârler: + - * / % ve += -= *= /= %= (t├╝m ikili ekler); + - (unary ├Âneki); ++ -- (unary ├Âneki ve postfix)
  • bit manip├╝lasyonu: & | ^ << >> ve &= |= ^= <<= >>= (t├╝m ikili ekler); ~ (unary ├Âneki)
  • boolean cebiri: == != < > <= >= || && (t├╝m ikili ekler); ! (unary ├Âneki)
  • bellek y├Ânetimi: new new[] delete delete[]
  • ├Ârt├╝l├╝ d├Ân├╝┼č├╝m operat├Ârleri
  • yanl─▒┼č: = [] -> ->* , (t├╝m ikili ekler); * & (t├╝m unary ├Âneki) () (i┼člev ├ža─čr─▒s─▒, n-ary eki )

Ancak, bunlar─▒n hepsini a┼č─▒r─▒ y├╝kleyebilece─činiz ger├že─či, yapman─▒z gerekti─či anlam─▒na gelmez . Operat├Âr a┼č─▒r─▒ y├╝klenmesinin temel kurallar─▒na bak─▒n.

C ++ 'da, operat├Ârler ├Âzel adlara sahip fonksiyonlar ┼čeklinde a┼č─▒r─▒ y├╝klenir . Di─čer fonksiyonlarda oldu─ču gibi, a┼č─▒r─▒ y├╝klenmi┼č operat├Ârler genellikle sol operand tipinin bir ├╝ye fonksiyonu veya ├╝ye olmayan fonksiyonlar olarak uygulanabilir . ─░kisinden birini se├žmekte veya kullanmakta serbest olmak, ├že┼čitli kriterlere ba─čl─▒d─▒r. 2 Tekli operat├Âr @ 3 bir amac─▒ x uygulanan olarak ya ├ža─čr─▒l─▒r o[email protected](x) ya da [email protected]() . @ Nesnelere uygulanan x ve y , olarak [email protected](x,y) veya olarak adland─▒r─▒lan bir ikili infix operat├Âr├╝ [email protected](y) . 4

├ťye olmayan fonksiyonlar olarak uygulanan operat├Ârler, bazen operand tipine arkada┼č olurlar.

1 ÔÇťKullan─▒c─▒ tan─▒ml─▒ÔÇŁ terimi biraz yan─▒lt─▒c─▒ olabilir. C ++ yerle┼čik t├╝rler ve kullan─▒c─▒ tan─▒ml─▒ t├╝rler aras─▒nda ayr─▒m yapar. Birincisine, ├Ârne─čin int, char ve double; Sonuncusu, kullan─▒c─▒lar taraf─▒ndan tan─▒mlanmad─▒─č─▒ halde standart k├╝t├╝phaneden olanlar da dahil olmak ├╝zere t├╝m yap─▒, s─▒n─▒f, birlik ve enum t├╝rlerine aittir.

2 Bu SSS'nin sonraki b├Âl├╝mlerinde ele al─▒nm─▒┼čt─▒r .

3 Ben bir yer tutucu olarak kullanabilirsiniz nedenle C ge├žerli bir operat├Âr ++ de─čil. @

4 C ++ 'da sadece ├╝├žl├╝ operat├Âr a┼č─▒r─▒ y├╝klenemez ve her zaman tek operat├Âr olan ├╝ye her zaman bir ├╝ye i┼člevi olarak uygulanmal─▒d─▒r.


C ++ 'da Operat├Âr A┼č─▒r─▒ Y├╝klemesinin ├ť├ž Temel Kural─▒na devam edin .


254


2010-12-12





├ťye ve ├ťye Olmayanlar Aras─▒ Karar

─░kili i┼čle├žler = (atama), [] (dizi aboneli─či), -> (├╝ye eri┼čimi) ve n-ary () (i┼člev ├ža─čr─▒s─▒) i┼čleci, her zaman dilin s├Âzdizimini gerektirdi─či i├žin ├╝ye i┼člevleri olarak uygulanmal─▒d─▒r .

Di─čer operat├Ârler, ├╝ye veya ├╝ye olmayan olarak uygulanabilir. Bununla birlikte, baz─▒lar─▒, genellikle ├╝ye olmayan i┼člevler olarak uygulanmal─▒d─▒r, ├ž├╝nk├╝ sol operandlar─▒ sizin taraf─▒n─▒zdan de─či┼čtirilemez. Bunlar─▒n en g├Âze ├žarpan─▒, giri┼č ve ├ž─▒k─▒┼č operat├Ârleri << ve >> sol operanlar─▒ de─či┼čtiremeyece─činiz standart k├╝t├╝phaneden ak─▒┼č s─▒n─▒flar─▒ olan.

Bunlar─▒ bir ├╝ye i┼člevi veya ├╝ye olmayan bir i┼člev olarak uygulamay─▒ se├žmeniz gereken t├╝m operat├Ârler i├žin, karar vermek i├žin a┼ča─č─▒daki kurallara uyun :

  1. Bir ise tekli operat├Âr , bir ┼čekilde bunu uygulamaya ├╝ye fonksiyonu.
  2. ─░kili bir operat├Âr her iki operat├Âr├╝ e┼čit olarak ele al─▒rsa (onlar─▒ de─či┼čmeden b─▒rak─▒r), bu operat├Âr├╝ ├╝ye olmayan bir fonksiyon olarak uygulay─▒n.
  3. ─░kili operat├Âr yoksa de─čil i┼členenlerinden hem tedavi e┼čit (genellikle sol i┼členen de─či┼čecek), bunu bir hale getirmek i├žin yararl─▒ olabilecek ├╝yesi ─░┼členen ├Âzel k─▒s─▒mlar─▒na eri┼čmek i├žin varsa, sol i┼členen en t├╝r├╝n├╝n i┼čleyi┼čini.

Elbette, t├╝m kurallarda oldu─ču gibi istisnalar da var. Senin tipin varsa

 enum Month {Jan, Feb, ..., Nov, Dec}
 

ve bunun i├žin art─▒rma ve azaltma i┼čle├žlerini a┼č─▒r─▒ y├╝klemek istiyorsan─▒z, bunu bir ├╝ye i┼člevi olarak yapamazs─▒n─▒z, ├ž├╝nk├╝ C ++ 'da enum tipleri ├╝ye i┼člevlere sahip olamaz. Bu y├╝zden serbest bir fonksiyon olarak a┼č─▒r─▒ y├╝klemeniz gerekir. Ve operator<() bir s─▒n─▒f ┼čablonu i├žine yerle┼čtirilmi┼č bir s─▒n─▒f ┼čablonu i├žin, s─▒n─▒f tan─▒m─▒ndaki sat─▒r i├ži bir ├╝ye i┼člevi olarak yap─▒ld─▒─č─▒nda yaz─▒lmas─▒ ve okunmas─▒ ├žok daha kolayd─▒r. Ancak bunlar ger├žekten nadir istisnalar.

(Bununla birlikte, e─čer bir istisna yapmak, konusunu unutma const ├╝ye fonksiyonlar─▒ i├žin, ├Ârt├╝l├╝ olur, o i┼člem g├Âren i├žin -l─▒k this arg├╝man. ├ťye olmayan bir fonksiyonu olarak operat├Âr bir olarak en soldaki arg├╝man alacakt─▒ E─čer const referans bir ├╝ye fonksiyonu olarak ayn─▒ operat├Âr olmas─▒ gerekir const yapmak i├žin sonunda *this bir const referans).


Genel operat├Ârlere a┼č─▒r─▒ y├╝klenmeye devam edin .


237


2010-12-12





D├Ân├╝┼č├╝m ─░┼čle├žleri (Kullan─▒c─▒ Tan─▒ml─▒ D├Ân├╝┼č├╝mler olarak da bilinir)

C ++ 'ta d├Ân├╝┼čt├╝rme i┼čle├žleri, derleyicinin t├╝rlerinizle di─čer tan─▒mlanm─▒┼č t├╝rler aras─▒nda d├Ân├╝┼č├╝m yapmas─▒n─▒ sa─člayan i┼čle├žler olu┼čturabilirsiniz. ─░ki t├╝r d├Ân├╝┼čt├╝rme operat├Âr├╝ vard─▒r: ├Ârt├╝k ve a├ž─▒k olanlar.

├ľrt├╝k D├Ân├╝┼č├╝m ─░┼čle├žleri (C ++ 98 / C ++ 03 ve C ++ 11)

├ľrt├╝k bir d├Ân├╝┼čt├╝rme i┼čleci, derleyicinin, kullan─▒c─▒ tan─▒ml─▒ bir t├╝r├╝n de─čerini ba┼čka bir t├╝r i├žin ├Ârt├╝k olarak d├Ân├╝┼čt├╝rmesini ( int ve aras─▒ndaki d├Ân├╝┼č├╝m gibi long ) sa─člar.

A┼ča─č─▒dakiler ├Ârt├╝k bir d├Ân├╝┼čt├╝rme i┼člecine sahip basit bir s─▒n─▒ft─▒r:

 class my_string {
public:
  operator const char*() const {return data_;} // This is the conversion operator
private:
  const char* data_;
};
 

├ľrt├╝k d├Ân├╝┼čt├╝rme operat├Ârleri, tek de─či┼čkenli kurucular gibi, kullan─▒c─▒ tan─▒ml─▒ d├Ân├╝┼č├╝mlerdir. Derleyiciler bir ├ža─čr─▒y─▒ a┼č─▒r─▒ y├╝klenmi┼č bir i┼člevle e┼čle┼čtirmeye ├žal─▒┼č─▒rken kullan─▒c─▒ taraf─▒ndan tan─▒mlanm─▒┼č bir d├Ân├╝┼č├╝m sa─člar.

 void f(const char*);

my_string str;
f(str); // same as f( str.operator const char*() )
 

─░lk ba┼čta bu ├žok yararl─▒ g├Âr├╝n├╝yor, ancak bununla ilgili sorun, ├Ârt├╝k d├Ân├╝┼č├╝m├╝n beklendi─či zaman bile ba┼člamamas─▒. A┼ča─č─▒daki kodda, void f(const char*) ├ž├╝nk├╝ ad─▒ verilecek my_string() bir de─čil lvalue ilk uymuyor yani:

 void f(my_string&);
void f(const char*);

f(my_string());
 

Yeni ba┼člayanlar kolayca yanl─▒┼č anlarlar ve hatta deneyimli C ++ programc─▒lar─▒ bazen ┼ča┼č─▒r─▒r, ├ž├╝nk├╝ derleyici ┼č├╝phelendikleri bir a┼č─▒r─▒ y├╝k al─▒r. Bu sorunlar a├ž─▒k d├Ân├╝┼č├╝m operat├Ârleri taraf─▒ndan hafifletilebilir.

A├ž─▒k D├Ân├╝┼č├╝m Operat├Ârleri (C ++ 11)

├ľrt├╝k d├Ân├╝┼čt├╝rme i┼čle├žlerinden farkl─▒ olarak, a├ž─▒k├ža d├Ân├╝┼č├╝m i┼čle├žleri beklemeyince asla devreye girmez. A┼ča─č─▒da a├ž─▒k bir d├Ân├╝┼čt├╝rme i┼čleci olan basit bir s─▒n─▒ft─▒r:

 class my_string {
public:
  explicit operator const char*() const {return data_;}
private:
  const char* data_;
};
 

Dikkat edin explicit . Art─▒k, ├Ârt├╝k d├Ân├╝┼čt├╝rme i┼čle├žlerinden beklenmeyen kodu ├žal─▒┼čt─▒rmay─▒ denedi─činizde, bir derleyici hatas─▒ al─▒yorsunuz:

prog.cpp: 'int main ()' i┼člevinde:
prog.cpp: 15: 18: error: 'f (my_string)' ├ža─čr─▒s─▒nda e┼čle┼čen i┼člev yok
prog.cpp: 15: 18: not: Adaylar:
prog.cpp: 11: 10: not: ge├žersiz f (my_string &)
prog.cpp: 11: 10: not: arg├╝man 1 i├žin 'my_string' den 'my_string &' e bilinen bir d├Ân├╝┼č├╝m yok
prog.cpp: 12: 10: not: ge├žersiz f (const char *)
prog.cpp: 12: 10: not: 1 arg├╝man─▒ i├žin 'my_string' den 'const char *' e bilinen bir d├Ân├╝┼č├╝m yok

A├ž─▒k d├Âk├╝m operat├Âr├╝n├╝ ├ža─č─▒rmak i├žin static_cast , bir C tarz─▒ d├Âk├╝m veya bir yap─▒c─▒ stili d├Âk├╝m (yani T(value) ) kullanman─▒z gerekir.

Bununla birlikte, bunun bir istisnas─▒ vard─▒r: Derleyicinin ├Ârt├╝k olarak d├Ân├╝┼čt├╝rmesine izin verilir bool . Ek olarak, derleyiciye d├Ân├╝┼čt├╝r├╝ld├╝kten sonra ba┼čka bir ├Ârt├╝l├╝ d├Ân├╝┼č├╝m bool yapmas─▒na izin verilmez (bir derleyicinin bir seferde 2 ├Ârt├╝l├╝ d├Ân├╝┼č├╝m yapmas─▒na izin verilir, ancak en fazla yaln─▒zca 1 kullan─▒c─▒ taraf─▒ndan tan─▒mlanm─▒┼č d├Ân├╝┼č├╝m).

Derleyici "ge├žmi┼č" i┼člemeyece─činden bool , a├ž─▒k d├Ân├╝┼č├╝m operat├Ârleri art─▒k G├╝venli Bool deyimine olan ihtiyac─▒ kald─▒rmaktad─▒r . ├ľrne─čin, C ++ 11'den ├Ânceki ak─▒ll─▒ i┼čaret├žiler, integral t├╝rlerine d├Ân├╝┼č├╝mleri ├Ânlemek i├žin Safe Bool deyimini kulland─▒. C ++ 11'de ak─▒ll─▒ i┼čaret├žiler a├ž─▒k bir i┼čle├ž kullan─▒rlar, ├ž├╝nk├╝ derleyicinin bir t├╝r├╝n boolmas─▒ i├žin a├ž─▒k├ža d├Ân├╝┼čt├╝r├╝ld├╝kten sonra derleyicinin bir integral t├╝r├╝ne ├Ârt├╝┼čmesine izin verilmez.

A┼č─▒r─▒ new delete Y├╝klemeye ve .


159


2013-05-17





A┼č─▒r─▒ new ve delete

Not: ile Bu yaln─▒zca f─▒rsatlar s├Âzdizimi a┼č─▒r─▒ y├╝kleme new ve delete de─čil ile uygulanmas─▒ bu t├╝r a┼č─▒r─▒ operat├Ârlerin. Ben a┼č─▒r─▒ semantik d├╝┼č├╝n├╝yorum new ve delete kendi SSS hak ─▒ adalet bunu asla a┼č─▒r─▒ y├╝kleme operat├Âr├╝n konu i├žinde.

temeller

C ++ 'da, bu ifade de─čerlendirildi─činde iki ┼čey oldu─ču gibi yeni bir ifade new T(arg) yazd─▒─č─▒n─▒zda: ├ľnce operator new ham bellek elde edilir, ard─▒ndan uygun ham yap─▒c─▒ T bu ham belle─či ge├žerli bir nesneye d├Ân├╝┼čt├╝rmek i├žin ├ža─čr─▒l─▒r. Ayn─▒ ┼čekilde, bir nesneyi sildi─činizde, ├Ânce onun y─▒k─▒c─▒s─▒ denir, sonra haf─▒za geri d├Ând├╝r├╝l├╝r operator delete .
C ++, bu i┼člemlerin ikisini de ayarlaman─▒za olanak tan─▒r: haf─▒za y├Ânetimi ve ayr─▒lan haf─▒zadaki nesnenin yap─▒m─▒ / imhas─▒. ─░kincisi, bir s─▒n─▒f i├žin yap─▒c─▒lar ve y─▒k─▒c─▒lar yazarak yap─▒l─▒r. ─░nce ayar haf─▒za y├Ânetimi kendi operator new ve yazarak yap─▒l─▒r operator delete .

Operat├Âr a┼č─▒r─▒ y├╝klemesinin temel kurallar─▒ndan ilki - yapmay─▒n - ├Âzellikle a┼č─▒r─▒ y├╝kleme i├žin ge├žerlidir new ve delete . Bu operat├Ârleri a┼č─▒r─▒ y├╝klemenin neredeyse tek nedeni performans problemleri ve bellek k─▒s─▒tlamalar─▒d─▒r ve ├žo─ču durumda, kullan─▒lan algoritmalardaki de─či┼čiklikler gibi di─čer eylemler, bellek y├Ânetimini ayarlamaya ├žal─▒┼čmaktan ├žok daha y├╝ksek bir maliyet / kazan├ž oran─▒ sa─člayacakt─▒r.

C ++ standart k├╝t├╝phanesi ├Ânceden tan─▒mlanm─▒┼č bir dizi new ve delete operat├Ârle birlikte gelir . Bunlardan en ├Ânemlileri:

 void* operator new(std::size_t) throw(std::bad_alloc); 
void  operator delete(void*) throw(); 
void* operator new[](std::size_t) throw(std::bad_alloc); 
void  operator delete[](void*) throw(); 
 

─░lk ikisi, bir nesne i├žin belle─či tahsis eder, ikincisi bir nesne dizisi i├žin iki tane tahsis eder. Bunlar─▒n kendi versiyonlar─▒n─▒ sa─člarsan─▒z, a┼č─▒r─▒ y├╝klenmeyeceklerdir, ancak standart k├╝t├╝phaneden olanlar─▒ de─či┼čtireceklerdir .
A┼č─▒r─▒ y├╝klerseniz operator new , operator delete asla aramaya niyetli olmasan─▒z bile e┼čle┼čtirmeyi her zaman a┼č─▒r─▒ y├╝klemelisiniz . Bunun nedeni, e─čer bir kurucu yeni bir ifadenin de─čerlendirilmesi s─▒ras─▒nda atarsa, ├žal─▒┼čma zaman─▒ sisteminin haf─▒zay─▒, i├žinde nesneyi olu┼čturmak i├žin haf─▒zay─▒ tahsis etmek i├žin ├ža─čr─▒lanla operator delete e┼čle┼čtirmeye d├Ând├╝rmesidir operator new . E┼čle┼čtirme sa─člamazsan─▒z operator delete , varsay─▒lan bir denir ve bu neredeyse her zaman yanl─▒┼čt─▒r.
E─čer a┼č─▒r─▒ olursa new ve delete sen de varyantlar─▒ dizi a┼č─▒r─▒ d├╝┼č├╝nmelisiniz.

Yerle┼čtirme new

C ++ yeni ve silme i┼čle├žlerinin ek arg├╝man almalar─▒na izin verir.
S├Âzde yerle┼čim yeni, belirli bir adreste iletilen bir nesne olu┼čturman─▒za olanak sa─člar:

 class X { /* ... */ };
char buffer[ sizeof(X) ];
void f()
{ 
  X* p = new(buffer) X(/*...*/);
  // ... 
  p->~X(); // call destructor 
} 
 

Standart k├╝t├╝phane, bunun i├žin yeni ve silme operat├Ârlerinin uygun a┼č─▒r─▒ y├╝klemeleriyle birlikte gelir:

 void* operator new(std::size_t,void* p) throw(std::bad_alloc); 
void  operator delete(void* p,void*) throw(); 
void* operator new[](std::size_t,void* p) throw(std::bad_alloc); 
void  operator delete[](void* p,void*) throw(); 
 

Yukar─▒da verilen yeni yerle┼čim i├žin ├Ârnek kodda operator delete , X'in kurucusu bir istisna atmad─▒─č─▒ s├╝rece hi├žbir zaman ├ža─čr─▒lmad─▒─č─▒n─▒ unutmay─▒n.

Ayr─▒ca new ve delete di─čer arg├╝manlarla a┼č─▒r─▒ y├╝kleyebilirsiniz . Yeni yerle┼čim i├žin ek arg├╝manlarda oldu─ču gibi, bu arg├╝manlar da anahtar kelimeden sonra parantez i├žinde listelenmi┼čtir new . Sadece tarihsel nedenlerden ├Ât├╝r├╝, bu t├╝r de─či┼čkenlere, arg├╝manlar─▒ belirli bir adrese yerle┼čtirilmeseler bile, yeni yerle┼čtirme denir.

S─▒n─▒fa ├Âzel yeni ve sil

En yayg─▒n olarak bellek y├Ânetiminde ince ayar yapmak isteyeceksiniz ├ž├╝nk├╝ ├Âl├ž├╝m, belirli bir s─▒n─▒f─▒n veya ilgili s─▒n─▒flar─▒n bir grubunun s─▒k s─▒k olu┼čturuldu─čunu ve imha edildi─čini ve ├žal─▒┼čma zaman─▒ sisteminin varsay─▒lan bellek y├Ânetiminin ayarland─▒─č─▒ Genel performans, bu ├Âzel durumda verimsiz olarak ilgilenir. Bunu geli┼čtirmek i├žin, yeni bir ┼čeyi a┼č─▒r─▒ y├╝kleyebilir ve belirli bir s─▒n─▒f i├žin silebilirsiniz:

 class my_class { 
  public: 
    // ... 
    void* operator new();
    void  operator delete(void*,std::size_t);
    void* operator new[](size_t);
    void  operator delete[](void*,std::size_t);
    // ... 
}; 
 

A┼č─▒r─▒ y├╝klenmi┼č, b├Âylece yeni ve silme statik ├╝ye i┼člevleri gibi davran─▒r. Nesneleri i├žin my_class , std::size_t arg├╝man her zaman olacakt─▒r sizeof(my_class) . Bununla birlikte, bu operat├Ârler, t├╝retilmi┼č s─▒n─▒flar─▒n dinamik olarak tahsis edilmi┼č nesneleri i├žin de ├ža─čr─▒l─▒r , bu durumda bundan daha b├╝y├╝k olabilir.

Global yeni ve sil

D├╝nya ├žap─▒ndaki yeniyi a┼č─▒r─▒ y├╝klemek ve silmek i├žin, standart k├╝t├╝phanenin ├Ânceden tan─▒mlanm─▒┼č operat├Ârlerini kendimiz ile de─či┼čtirin. Ancak, bu nadiren yap─▒lmas─▒ gerekenler.


145


2010-12-12





Neden bir dosyaya veya bir dosyaya operator<< aktarma std::cout i┼člevi bir ├╝ye i┼člevi olamaz?

Diyelim ki sahipsin:

 struct Foo
{
   int a;
   double b;

   std::ostream& operator<<(std::ostream& out) const
   {
      return out << a << " " << b;
   }
};
 

Bu verilen, kullanamazs─▒n─▒z:

 Foo f = {10, 20.0};
std::cout << f;
 

Bu yana operator<< bir ├╝yesi fonksiyonu olarak a┼č─▒r─▒ Foo , operat├Âr├╝n LHS a olmal─▒d─▒r Foo nesne. Bu, kullanman─▒z gerekece─či anlam─▒na gelir:

 Foo f = {10, 20.0};
f << std::cout
 

hangisi sezgisel de─čildir.

├ťye olmayan bir i┼člev olarak tan─▒mlarsan─▒z,

 struct Foo
{
   int a;
   double b;
};

std::ostream& operator<<(std::ostream& out, Foo const& f)
{
   return out << f.a << " " << f.b;
}
 

Kullanabileceksiniz:

 Foo f = {10, 20.0};
std::cout << f;
 

Bu ├žok sezgisel.


40



─░lgili yay─▒nlar


R'deki ÔÇť=ÔÇŁ ve ÔÇť<-ÔÇŁ atama i┼čle├žleri aras─▒ndaki farklar nelerdir?

Redis i├žin kullan─▒lan veri yap─▒lar─▒ nelerdir?

Windows FINDSTR komutunun belgelenmemi┼č ├Âzellikleri ve s─▒n─▒rlamalar─▒ nelerdir?

Git, Mercurial ve Bazaar'─▒n g├Âreceli g├╝├žl├╝ ve zay─▒f y├Ânleri nelerdir? [kapal─▒]

Java i├žin BDD ├žer├ževeleri aras─▒ndaki farklar nelerdir? [kapal─▒]

Parantez, noktalar, ka┼čl─▒ ayra├žlar, = (i┼člevler) vb.

H1-H6 etiketleri i├žin en yayg─▒n yaz─▒ tipi boyutlar─▒ nelerdir [kapal─▒]

Pandalar'─▒n concat fonksiyonunda 'seviyeler', 'anahtarlar' ve isimleri arg├╝manlar─▒ nelerdir?

R'de string-to-date d├Ân├╝┼č├╝m i├žin ÔÇťstandart kesin tarihÔÇŁ bi├žimleri nelerdir?

Her geli┼čtiricinin bilmesi gereken temel a├ž─▒k konseptler nelerdir? [kapal─▒]

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


Bir ├Â─čenin d─▒┼č─▒ndaki bir t─▒klamay─▒ nas─▒l tespit ederim?

Vim son arama vurgulama temizleyin

Belirli bir sat─▒r i├žin eslint kural─▒n─▒ kapatmak

Git reset - hard HEAD ~ 1'i nas─▒l geri alabilirim?

jQuery's jquery-1.10.2.min.map bir 404'├╝ tetikliyor (Bulunamad─▒)

AngularJS'deki kapsam prototip / prototipik kal─▒t─▒m─▒n n├╝anslar─▒ nelerdir?

C# yans─▒mas─▒n─▒ kullanarak dizgeden ├Âzellik de─čerini al

ÔÇťRastgelelikÔÇŁ kavram─▒n─▒ anlamak

Python try-else

Mocking nedir?