Static_cast, dynamic_cast, const_cast ve reinterpret_cast ne zaman kullan─▒lmal─▒d─▒r?


Al─▒nan cevaba git


Uygun kullan─▒m alanlar─▒ nelerdir:

  • static_cast
  • dynamic_cast
  • const_cast
  • reinterpret_cast
  • C tarz─▒ d├Âk├╝m (type)value
  • ─░┼člev stili d├Âk├╝m type(value)

Hangi durumlarda hangisinin kullan─▒laca─č─▒na nas─▒l karar verilir?


2346









Cevap say─▒s─▒n─▒ say: 8






static_cast kullanmaya ├žal─▒┼čman gereken ilk oyuncu. Bu ├Ârt├╝k (├Ârne─čin t├╝rleri aras─▒ndaki d├Ân├╝┼č├╝mler gibi ┼čeyler yapar int i├žin float veya i┼čaret├ži void* ) ve ayn─▒ zamanda a├ž─▒k d├Ân├╝┼čt├╝rme i┼člevleri (veya ├Ârt├╝l├╝ olanlar) ├ža─č─▒rabilir. ├ço─ču durumda, a├ž─▒k├ža belirtmek static_cast gerekli de─čildir, ancak T(something) s├Âzdiziminin e┼čde─čer oldu─čunu (T)something ve bundan ka├ž─▒n─▒lmas─▒ gerekti─čine dikkat etmek ├Ânemlidir (bundan sonra daha fazlas─▒). T(something, something_else) Bununla birlikte, A g├╝venlidir ve yap─▒c─▒y─▒ ├ža─č─▒rmas─▒ garanti edilir.

static_cast Kal─▒t─▒m hiyerar┼čileri yoluyla da rol oynayabilir. Yukar─▒ya do─čru d├Âk├╝l├╝rken (taban s─▒n─▒f─▒na do─čru) gereksizdir, ancak a┼ča─č─▒ya do─čru d├Âk├╝m yaparken, virtual kal─▒t─▒m yoluyla at─▒lmad─▒─č─▒ s├╝rece kullan─▒labilir . Bununla birlikte, kontrol yapmaz ve static_cast asl─▒nda nesnenin t├╝r├╝ olmayan bir t├╝r i├žin bir hiyerar┼čiyi a┼ča─č─▒lamak tan─▒ms─▒z bir davran─▒┼čt─▒r .


const_cast const bir de─či┼čkeni kald─▒rmak veya eklemek i├žin kullan─▒labilir ; ba┼čka hi├žbir C ++ cast'─▒ kald─▒ramaz (hatta de─čil reinterpret_cast ). Eski bir const de─čerin de─či┼čtirilmesinin yaln─▒zca orijinal de─či┼čken oldu─čunda tan─▒ms─▒z oldu─čunu not etmek ├Ânemlidir const ; E─čer yok etmek i├žin kullanmama durumunda const olan beyan edilmedi bir┼čeye referans kapal─▒ const , bu g├╝venlidir. const ├ľrne─čin, ├╝ye i┼člevlerini a┼č─▒r─▒ y├╝klerken bu yararl─▒ olabilir . const Bir ├╝ye fonksiyonu a┼č─▒r─▒ y├╝k├╝ ├ža─č─▒rmak gibi bir nesneye eklemek i├žin de kullan─▒labilir .

const_cast Daha volatile az yayg─▒n olsa da, benzer ┼čekilde ├žal─▒┼č─▒r .


dynamic_cast m├╝nhas─▒ran polimorfizmi i┼člemek i├žin kullan─▒l─▒r. Herhangi bir polimorfik t├╝re herhangi bir s─▒n─▒f tipine i┼čaret├ži veya referans verebilir (polimorfik bir tipin ilan edilmi┼č veya miras al─▒nm─▒┼č en az bir sanal i┼člevi vard─▒r). Sadece a┼ča─č─▒ do─čru d├Âk├╝m yapmaktan daha fazlas─▒ i├žin kullanabilirsiniz - yandan veya hatta ba┼čka bir zincire kadar d├Âk├╝m yapabilirsiniz. dynamic_cast ─░stenen nesneyi ararlar ve m├╝mk├╝nse bunu d├Ânecektir. nullptr Bulamazsa, bir i┼čaret├ži durumunda geri d├Âner veya std::bad_cast bir referans durumunda at─▒l─▒r.

dynamic_cast olsa da, baz─▒ s─▒n─▒rlamalar─▒ vard─▒r. Kal─▒t─▒m hiyerar┼čisinde ayn─▒ t├╝rden birden fazla nesne varsa ('korkutucu elmas' olarak adland─▒r─▒l─▒r) ├žal─▒┼čmaz ve virtual kal─▒t─▒m kullanmazs─▒n─▒z . Ayn─▒ zamanda sadece halk miras─▒ yoluyla ge├žebilir - her zaman seyahat etme protected veya private miras alma konusunda ba┼čar─▒s─▒z olur . Bu nadiren bir konudur, ancak bu t├╝r miras t├╝rleri nadirdir.


reinterpret_cast en tehlikeli oyunculard─▒r ve ├žok az kullan─▒lmal─▒d─▒rlar. Bir t├╝r├╝ do─črudan di─čerine d├Ân├╝┼čt├╝r├╝r - ├Ârne─čin bir i┼čaret├židen di─čerine de─čer d├Âkmek veya bir i┼čaret├žiyi bir int veya ba┼čka t├╝rl├╝ k├Ât├╝ ┼čeylere depolamak gibi . B├╝y├╝k ├Âl├ž├╝de, sadece birlikte olsun garanti reinterpret_cast orijinal t├╝r├╝ne sonucu geri d├Âkme normalde bile, tam olarak ayn─▒ de─čere alacak (ancak de─čil orta tip orijinal tip k├╝├ž├╝kse). Yapamayaca─č─▒n─▒z ├žok say─▒da d├Ân├╝┼č├╝m var reinterpret_cast . ├ľncelikle, ├Âzellikle bir veri ak─▒┼č─▒n─▒ ger├žek verilere d├Ân├╝┼čt├╝rmek veya bir i┼čaret├žinin d├╝┼č├╝k bitlerinde verileri hizalanm─▒┼č verilere depolamak gibi ├Âzellikle garip d├Ân├╝┼č├╝mler ve bit manip├╝lasyonlar─▒ i├žin kullan─▒l─▒r.


C tarz─▒ d├Âk├╝m ve i┼člev stili d├Âk├╝m , s─▒ras─▒yla (type)object veya kullanan kal─▒plard─▒r type(object) ve i┼člevsel olarak e┼čde─čerdir. Ba┼čar─▒l─▒ olan a┼ča─č─▒dakilerden ilki olarak tan─▒mlan─▒rlar:

  • const_cast
  • static_cast (eri┼čim k─▒s─▒tlamalar─▒n─▒ dikkate almamakla birlikte)
  • static_cast (yukar─▒ya bak─▒n), sonra const_cast
  • reinterpret_cast
  • reinterpret_cast , sonra const_cast

Bu nedenle, baz─▒ durumlarda di─čer atmalar─▒n yerine ge├žebilir, ancak a'ya d├Ân├╝┼čme kabiliyeti nedeniyle a┼č─▒r─▒ derecede tehlikeli olabilir reinterpret_cast ve a├ž─▒k d├Âk├╝m yap─▒lmas─▒ gerekti─činde, static_cast ba┼čar─▒l─▒ reinterpret_cast olaca─č─▒n─▒zdan veya ba┼čar─▒s─▒z olaca─č─▒n─▒zdan emin olmad─▒k├ža, sonuncusu tercih edilmelidir. . O zaman bile, daha uzun ve daha a├ž─▒k olan se├žene─či d├╝┼č├╝n├╝n.

C-tarz─▒ yay─▒nlar ayn─▒ zamanda a ger├žekle┼čtirirken eri┼čim kontrol├╝n├╝ yok sayarlar static_cast ; bu, ba┼čka hi├žbir oyuncunun yapamayaca─č─▒ bir i┼člemi ger├žekle┼čtirebilecekleri anlam─▒na gelir. Bu ├žo─čunlukla bir kirlilik, ve akl─▒mda C tarz─▒ atmalar─▒n─▒ ├Ânlemek i├žin ba┼čka bir neden.


2441







dynamic_cast Kal─▒t─▒m hiyerar┼čisindeki i┼čaret├žileri / referanslar─▒ d├Ân├╝┼čt├╝rmek i├žin kullan─▒n .

static_cast Normal tip d├Ân├╝┼č├╝mler i├žin kullan─▒n .

reinterpret_cast Bit desenlerinin d├╝┼č├╝k seviyeli yeniden yorumlanmas─▒ i├žin kullan─▒n . ├çok dikkatli kullan─▒n.

const_cast D├Âk├╝m i├žin kullan─▒n const/volatile . Const yanl─▒┼č bir API kullanarak s─▒k─▒┼čm─▒┼č s├╝rece bu ka├ž─▒n─▒n.


315







(Yukar─▒da bir├žok teorik ve kavramsal a├ž─▒klama verilmi┼čtir)

A┼ča─č─▒da baz─▒ pratik ├Ârnekler kulland─▒─č─▒m static_cast , dynamic_cast , const_cast , reinterpret_cast .

(Ayr─▒ca a├ž─▒klamay─▒ anlamak i├žin buna at─▒fta bulunur: http://www.cplusplus.com/doc/tutorial/typecasting/ )

static_cast:

 OnEventData(void* pData)

{
  ......

  //  pData is a void* pData, 

  //  EventData is a structure e.g. 
  //  typedef struct _EventData {
  //  std::string id;
  //  std:: string remote_id;
  //  } EventData;

  // On Some Situation a void pointer *pData
  // has been static_casted as 
  // EventData* pointer 

  EventData *evtdata = static_cast<EventData*>(pData);
  .....
}
 

dynamic_cast:

 void DebugLog::OnMessage(Message *msg)
{
    static DebugMsgData *debug;
    static XYZMsgData *xyz;

    if(debug = dynamic_cast<DebugMsgData*>(msg->pdata)){
        // debug message
    }
    else if(xyz = dynamic_cast<XYZMsgData*>(msg->pdata)){
        // xyz message
    }
    else/* if( ... )*/{
        // ...
    }
}
 

const_cast:

 // *Passwd declared as a const

const unsigned char *Passwd


// on some situation it require to remove its constness

const_cast<unsigned char*>(Passwd)
 

reinterpret_cast:

 typedef unsigned short uint16;

// Read Bytes returns that 2 bytes got read. 

bool ByteBuffer::ReadUInt16(uint16& val) {
  return ReadBytes(reinterpret_cast<char*>(&val), 2);
}
 

186







Biraz i├ž organ─▒ tan─▒yorsan─▒z, yard─▒m─▒ olabilir ...

static_cast

  • C ++ derleyicisi, ┼čamand─▒ra gibi ├Âl├žekleyici t├╝rleri aras─▒nda int nas─▒l d├Ân├╝┼čt├╝r├╝lece─čini zaten biliyor. static_cast Onlar i├žin kullan─▒n .
  • E─čer t├╝r├╝nden d├Ân├╝┼čt├╝rmek i├žin derleyici sordu─čumda A i├žin B , static_cast ├ža─čr─▒lar B '─▒n yap─▒c─▒ ge├žen A param olarak. Alternatif olarak, A bir d├Ân├╝┼čt├╝rme operat├Âr├╝ne (yani A::operator B() ) sahip olabilir. B├Âyle bir B kurucuya sahip de─čilse veya A bir d├Ân├╝┼č├╝m i┼čleci yoksa, derleme zaman─▒ hatas─▒ al─▒rs─▒n─▒z.
  • Cast A* i├žin B* A ve B kal─▒t─▒m hiyerar┼čisi (veya bo┼čluk) ise her zaman aksi takdirde derleme hatas─▒ al─▒yorum ba┼čar─▒r.
  • Gotcha : E─čer temel g├Âstericiyi t├╝retilmi┼č g├Âstergeye ├ževirirseniz, ancak ger├žek nesne ger├žekten t├╝retilmi┼č de─čilse , hata alamazs─▒n─▒z . K├Ât├╝ i┼čaret├ži ve b├╝y├╝k olas─▒l─▒kla ├žal─▒┼čma zaman─▒nda bir segfault olsun. Ayn─▒ ┼čey i├žin A& de ge├žerli B& .
  • Gotcha : Derived'den Base'e oyuncular ya da viceversa yeni bir kopya yarat─▒yor ! C # / Java'dan gelen insanlar i├žin bu b├╝y├╝k bir s├╝rpriz olabilir, ├ž├╝nk├╝ sonu├ž temelde Derived'den yarat─▒lm─▒┼č kesilmi┼č bir nesnedir.

dynamic_cast

  • dynamic_cast, cast'─▒n ge├žerli olup olmad─▒─č─▒n─▒ anlamak i├žin ├žal─▒┼čma zaman─▒ t├╝r├╝ bilgilerini kullan─▒r. ├ľrne─čin, (Base*) i├žin (Derived*) i┼čaret├ži asl─▒nda t├╝retilmi┼č bir t├╝r de─čilse ba┼čar─▒s─▒z olabilir.
  • Bunun anlam─▒, dynamic_cast, static_cast ile kar┼č─▒la┼čt─▒r─▒ld─▒─č─▒nda ├žok pahal─▒!
  • ─░├žin A* i├žin B* d├Âk├╝m ise, ge├žersiz sonra dynamic_cast nullptr d├Ânecektir.
  • ─░├žin A& i├žin B& d├Âkme ge├žersizse sonra dynamic_cast bad_cast ├Âzel durum olu┼čturur.
  • Di─čer yay─▒nlardan farkl─▒ olarak, ├žal─▒┼čma zaman─▒ ek y├╝k├╝ var.

const_cast

  • Static_cast const yapmak i├žin const yapamazken, ba┼čka yollardan gidemez. Const_cast her iki yolu da yapabilir.
  • Bunun kullan─▒┼čl─▒ oldu─ču bir ├Ârnek set<T> , anahtar─▒n─▒ de─či┼čtirmedi─činizden emin olmak i├žin ├Â─čelerini yaln─▒zca const olarak d├Ând├╝ren baz─▒ kaplar aras─▒nda yineleme yapmakt─▒r. Ancak, amac─▒n─▒z nesnenin kilit olmayan ├╝yelerini de─či┼čtirmekse, o zaman tamam olmal─▒d─▒r. Constness kald─▒rmak i├žin const_cast kullanabilirsiniz.
  • Uygulamak istedi─činiz ba┼čka bir ├Ârnektir T& SomeClass::foo() yan─▒ s─▒ra const T& SomeClass::foo() const . Kod ├žo─čalt─▒lmas─▒n─▒ ├Ânlemek i├žin, bir i┼člevin de─čerini di─čerinden d├Ând├╝rmek i├žin const_cast uygulayabilirsiniz.

reinterpret_cast

  • Bu, temel olarak, bu baytlar─▒ bu haf─▒za konumuna al─▒p verilen nesne olarak d├╝┼č├╝nd├╝─č├╝n├╝ s├Âyler.
  • ├ľrne─čin, floattaki bitlerin nas─▒l g├Âr├╝nd├╝─č├╝n├╝ g├Ârmek i├žin 4 baytl─▒k float'─▒ 4 bayt int'e y├╝kleyebilirsiniz.
  • A├ž─▒k├žas─▒, veri t├╝r├╝ i├žin do─čru de─čilse, segfault alabilirsiniz.
  • Bu yay─▒n i├žin ├žal─▒┼čma zaman─▒ ek y├╝k├╝ yok.

80







Does bu sorunuza cevap?

Hi├ž kullanmad─▒m reinterpret_cast ve ihtiyac─▒ olan bir davaya girmenin k├Ât├╝ bir tasar─▒m kokusu olmad─▒─č─▒n─▒ merak ediyorum. ├çal─▒┼čt─▒─č─▒m kod taban─▒nda dynamic_cast ├žok kullan─▒l─▒r. Aradaki fark static_cast , istedi─činiz dynamic_cast (daha g├╝venli) olan veya olmayan (daha fazla ek y├╝k) istedi─činiz bir ├žal─▒┼čma zaman─▒ kontrol├╝n├╝n yap─▒lmas─▒d─▒r ( msdn'ye bak─▒n─▒z ).


16







┼×imdiye kadar verilen di─čer cevaplara ek olarak, burada gerekli static_cast olmad─▒─č─▒ i├žin yeterli olmad─▒─č─▒ a├ž─▒k bir ├Ârnek var reinterpret_cast . Bir ├ž─▒k─▒┼č parametresinde, i┼čaret├žileri farkl─▒ s─▒n─▒ftaki nesnelere (ortak bir temel s─▒n─▒f─▒ payla┼čmayan) d├Ând├╝ren bir i┼člev oldu─čunu varsayal─▒m. B├Âyle bir i┼člevin ger├žek bir ├Ârne─či (ger├žekte CoCreateInstance() olan son parametreye bak─▒n void** ). Bu i┼člevden belirli bir nesne s─▒n─▒f─▒ istedi─činizi varsayal─▒m, bu nedenle i┼čaret├žinin t├╝r├╝n├╝ ├Ânceden (ki genellikle COM nesneleri i├žin yapars─▒n─▒z) bilirsiniz. Bu durumda i├žine i┼čaret├ži i┼čaret├ži d├Âk├╝m olamaz void** ile static_cast ─░htiyac─▒n─▒z: reinterpret_cast<void**>(&yourPointer) .

Kodunda:

 #include <windows.h>
#include <netfw.h>
.....
INetFwPolicy2* pNetFwPolicy2 = nullptr;
HRESULT hr = CoCreateInstance(__uuidof(NetFwPolicy2), nullptr,
    CLSCTX_INPROC_SERVER, __uuidof(INetFwPolicy2),
    //static_cast<void**>(&pNetFwPolicy2) would give a compile error
    reinterpret_cast<void**>(&pNetFwPolicy2) );
 

Bununla birlikte, static_cast basit i┼čaret├žiler i├žin ├žal─▒┼č─▒r (i┼čaret├žiler i├žin i┼čaret├žiler de─čil), bu nedenle yukar─▒daki kod a┼ča─č─▒daki ┼čekilde reinterpret_cast (ekstra bir de─či┼čken fiyat─▒na g├Âre) a┼ča─č─▒daki ┼čekilde yeniden yaz─▒labilir :

 #include <windows.h>
#include <netfw.h>
.....
INetFwPolicy2* pNetFwPolicy2 = nullptr;
void* tmp = nullptr;
HRESULT hr = CoCreateInstance(__uuidof(NetFwPolicy2), nullptr,
    CLSCTX_INPROC_SERVER, __uuidof(INetFwPolicy2),
    &tmp );
pNetFwPolicy2 = static_cast<INetFwPolicy2*>(tmp);
 

15







Di─čer cevaplar g├╝zel C ++ atmalar─▒n─▒ aras─▒ndaki t├╝m farkl─▒l─▒klar─▒ tarif ederken, ben C tarz─▒ yay─▒nlar─▒ kullanmamal─▒s─▒n─▒z neden k─▒sa bir not eklemek istiyorum (Type) var ve Type(var) .

C ++ yeni ba┼člayanlar i├žin C tarz─▒ yay─▒nlar, C ++ yay─▒nlar─▒ (statik_ yay─▒n─▒ <> (), dynamic_cast <> (), const_cast <> (), reinterpret_cast <> ()) ├╝zerinden ├╝st d├╝zey bir i┼člem gibi g├Âr├╝n├╝r ve birisi bunlar─▒ C ++ d├Âk├╝m├╝ i├žin tercih edebilir . Asl─▒nda C tarz─▒ oyuncu se├žimi s├╝perset ve yazmak i├žin daha k─▒sa.

C tarz─▒ yay─▒nlar─▒n as─▒l sorunu, geli┼čtiricinin oyuncu kadrosunun ger├žek niyetini gizlemeleri. C tarz─▒ kal─▒plar, normalde g├╝venli kal─▒plardan statik_cast <> () ve dynamic_cast <> () taraf─▒ndan yap─▒lan const_cast <> () gibi potansiyel olarak tehlikeli kal─▒plardan konst de─či┼čkeninin kald─▒r─▒labilece─či ┼čekilde hemen hemen her t├╝rl├╝ d├Âk├╝m yapabilir. tamsay─▒ de─čerlerini i┼čaret├žilere bile yeniden yorumlayabilen modifiye edilebilir ve reinterpret_cast <> ().

─░┼čte ├Ârnek.

 int a=rand(); // Random number.

int* pa1=reinterpret_cast<int*>(a); // OK. Here developer clearly expressed he wanted to do this potentially dangerous operation.

int* pa2=static_cast<int*>(a); // Compiler error.
int* pa3=dynamic_cast<int*>(a); // Compiler error.

int* pa4=(int*) a; // OK. C-style cast can do such cast. The question is if it was intentional or developer just did some typo.

*pa4=5; // Program crashes.
 

C ++ yay─▒nlar─▒n─▒n dile eklenmesi i├žin temel neden, bir geli┼čtiricinin niyetlerini netle┼čtirmesine izin vermekti - neden bu se├žimi yapacakt─▒. C ++ 'ta m├╝kemmel bi├žimde ge├žerli olan C-tarz─▒ yay─▒nlar─▒ kullanarak, ├Âzellikle kodunuzu olu┼čturmayan di─čer geli┼čtiriciler i├žin kodunuzu daha az okunabilir ve daha fazla hataya a├ž─▒k hale getiriyorsunuz. Bu nedenle, kodunuzu daha okunakl─▒ ve a├ž─▒k hale getirmek i├žin, her zaman C ++ karakterlerini yerine C ++ karakterlerini tercih etmelisiniz.

─░┼čte Bjarne Stroustrup'un (C ++ yazar─▒) The C ++ Programming Language 4. bas─▒m kitab─▒ndan k─▒sa bir al─▒nt─▒ - sayfa 302.

Bu C-tarz─▒ yay─▒n, adland─▒r─▒lm─▒┼č d├Ân├╝┼č├╝m operat├Ârlerinden ├žok daha tehlikelidir ├ž├╝nk├╝ g├Âsterimin b├╝y├╝k bir programda g├Âr├╝lmesi daha zordur ve programc─▒n─▒n hedefledi─či d├Ân├╝┼č├╝m t├╝r├╝ a├ž─▒k de─čildir.


9







Anlamak i├žin, kod pasaj─▒n─▒ a┼ča─č─▒da d├╝┼č├╝nelim:

 struct Foo{};
struct Bar{};

int main(int argc, char** argv)
{
    Foo* f = new Foo;

    Bar* b1 = f;                              // (1)
    Bar* b2 = static_cast<Bar*>(f);           // (2)
    Bar* b3 = dynamic_cast<Bar*>(f);          // (3)
    Bar* b4 = reinterpret_cast<Bar*>(f);      // (4)
    Bar* b5 = const_cast<Bar*>(f);            // (5)

    return 0;
}
 

Sadece sat─▒r (4) hatas─▒z derlenir. ─░┼čaret├žiyi nesneye i┼čaret├žiyle ili┼čkisiz herhangi bir nesne t├╝r├╝ne d├Ân├╝┼čt├╝rmek i├žin yaln─▒zca reinterpret_cast kullan─▒labilir.

Dikkat edilmesi gereken bir ┼čey: dynamic_cast ├žal─▒┼čma zaman─▒nda ba┼čar─▒s─▒z olur, ancak ├žo─ču derleyicide de derleme ba┼čar─▒s─▒z olur; ├ž├╝nk├╝ i┼čaret├ži yap─▒s─▒nda sanal i┼člevler yoktur, yani dynamic_cast yaln─▒zca polimorfik s─▒n─▒f i┼čaret├žilerle ├žal─▒┼čacakt─▒r. .

C ++ cast ne zaman kullan─▒l─▒r :

  • Kullan─▒m static_cast de─čer d├Ân├╝┼č├╝m├╝ yapmaz ya da biz a├ž─▒k├ža gerekti─činde onun ├╝st s─▒n─▒fa s─▒n─▒ftan bir i┼čaret├ži yukar─▒ d├Âk├╝m C tarz─▒ d├Âk├╝m e┼čde─čer olarak.
  • Const niteleyicisini kald─▒rmak i├žin const_cast kullan─▒n .
  • Tamsay─▒ ve di─čer i┼čaret├ži t├╝rlerinden gelen ve olmayan i┼čaret├ži t├╝rlerinin g├╝venli olmayan d├Ân├╝┼č├╝mlerini yapmak i├žin reinterpret_cast kullan─▒n . Bunu sadece ne yapt─▒─č─▒m─▒z─▒ biliyorsak ve di─čer isimlendirme sorunlar─▒n─▒ anlarsak kullan─▒n.

3



─░lgili yay─▒nlar


Typeof ve instanceof aras─▒ndaki fark nedir ve biri di─čerine ne zaman kullan─▒lmal─▒d─▒r?

Scala'da parantezler ve parantezler aras─▒ndaki resmi fark nedir ve ne zaman kullan─▒lmalar─▒ gerekir?

.Build, .create ve .create aras─▒ndaki farklar! ve ne zaman kullan─▒lmalar─▒ gerekir?

Metod parametreleri ve yerel de─či┼čkenler i├žin final ne zaman kullan─▒lmal─▒d─▒r?

<F: meta veri>, <f: viewParam> ve <f: viewAction> ne i├žin kullan─▒labilir?

S─▒n─▒f de─či┼čkenine g├Âre yukar─▒-a┼ča─č─▒-d├Âk├╝m aras─▒ndaki fark nedir

Npm'yi ÔÇť-gÔÇŁ bayra─č─▒yla ne zaman kullanmal─▒y─▒m ve neden?

Java'da ne zaman kontrol edilen bir istisna olu┼čturmal─▒y─▒m ve ne zaman ├žal─▒┼čma zaman─▒ istisnas─▒ olmal─▒? [├žift]

Ne zaman ko┼čmal─▒y─▒z, ko┼čal─▒m, uygulamal─▒y─▒z ve ayn─▒ zamanda Kotlin'de

Yerel kopya ne zaman true olarak ayarlanmal─▒ ve ne zaman olmamal─▒d─▒r?

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


Bir dosyan─▒n istisnalar olmadan var olup olmad─▒─č─▒n─▒ nas─▒l kontrol ederim?

Python'da harici bir komut ├ža─č─▒rmak

ÔÇťGit add -AÔÇŁ ve ÔÇťgit addÔÇŁ aras─▒ndaki fark.

Sayfay─▒ yeniden y├╝klemeden URLÔÇÖyi nas─▒l de─či┼čtiririm?

Vim'deki remap, noremap, normal harita ve vnoremap haritalama komutlar─▒ aras─▒ndaki fark nedir?

JavaScript'in devre d─▒┼č─▒ b─▒rak─▒l─▒p b─▒rak─▒lmad─▒─č─▒ nas─▒l tespit edilir?

Python'da ortam de─či┼čkenleri nas─▒l ayarlan─▒r?

Fabrika ve Soyut Fabrika Tasar─▒m Kal─▒plar─▒ aras─▒ndaki temel fark nedir? [kapal─▒]

─░lk ma├žta durmas─▒ i├žin d├╝zenli ifade

Pip ortam─▒n─▒ sanal ortam─▒mdan nas─▒l g├╝ncellerim?