A├ž─▒k anahtar kelime ne anlama geliyor?


Al─▒nan cevaba git


explicit Anahtar kelime C ++ 'da ne anlama geliyor?


2714









Cevap say─▒s─▒n─▒ say: 11






Derleyicinin, parametreleri bir i┼čleve ├ž├Âzmek i├žin bir ├Ârt├╝k d├Ân├╝┼čt├╝rme i┼člemi yapmas─▒na izin verilir. Bunun anlam─▒, derleyicinin bir parametre i├žin do─čru tip almak amac─▒yla bir tipten di─čerine d├Ân├╝┼čt├╝rmek i├žin tek bir parametreyle ├ža─čr─▒labilir yap─▒c─▒lar─▒ kullanabilmesidir .

─░┼čte ├Ârt├╝k d├Ân├╝┼č├╝mler i├žin kullan─▒labilecek bir yap─▒c─▒ ile birlikte ├Ârnek bir s─▒n─▒f:

 class Foo
{
public:
  // single parameter constructor, can be used as an implicit conversion
  Foo (int foo) : m_foo (foo) 
  {
  }

  int GetFoo () { return m_foo; }

private:
  int m_foo;
};
 

─░┼čte bir Foo nesneyi alan basit bir fonksiyon :

 void DoBar (Foo foo)
{
  int i = foo.GetFoo ();
}
 

ve i┼čte DoBar fonksiyonun ├ža─čr─▒ld─▒─č─▒ yer.

 int main ()
{
  DoBar (42);
}
 

Arg├╝man bir Foo nesne de─čil , bir int . Bununla birlikte, bunun i├žin bir yap─▒c─▒ vard─▒r, Foo bu int y├╝zden bu yap─▒c─▒, parametreyi do─čru t├╝re d├Ân├╝┼čt├╝rmek i├žin kullan─▒labilir.

Derleyici her parametre i├žin bunu bir kez yapabilir.

explicit Anahtar s├Âzc├╝─č├╝n yap─▒c─▒ya ├Âneklenmesi, derleyicinin bu yap─▒c─▒y─▒ ├Ârt├╝k d├Ân├╝┼č├╝mler i├žin kullanmas─▒n─▒ ├Ânler. Yukar─▒daki s─▒n─▒fa eklemek, i┼člev ├ža─čr─▒s─▒nda bir derleyici hatas─▒ yaratacakt─▒r DoBar (42) . ┼×imdi a├ž─▒k├ža d├Ân├╝┼č├╝m i├žin arama yapmak gerekli DoBar (Foo (42))

Bunu yapmak isteyip istemedi─činizin nedeni, b├Âcekleri gizleyebilecek yanl─▒┼čl─▒kla in┼ča etmekten ka├ž─▒nmakt─▒r. Tart─▒┼č─▒lan ├Ârnek:

  • MyString(int size) Belirtilen boyutta bir dize olu┼čturan bir yap─▒c─▒ ile bir s─▒n─▒f var . Bir i┼čleve sahipsiniz print(const MyString&) ve siz ├ža─č─▒r─▒yorsunuz print(3) ( ger├žekten aramak istedi─činizde print("3") ). "3" yazmas─▒n─▒ beklersiniz, ancak bunun yerine bo┼č bir uzunluk 3 dizesini yazd─▒r─▒r.

3131







Diyelim ki bir s─▒n─▒f─▒n─▒z var String :

 class String {
public:
    String(int n); // allocate n bytes to the String object
    String(const char *p); // initializes object with char *p
};
 

┼×imdi, denersen:

 String mystring = 'x';
 

Karakter 'x' dolayl─▒ olarak d├Ân├╝┼čt├╝r├╝l├╝r int ve daha sonra String(int) yap─▒c─▒ ├ža─čr─▒l─▒r. Ancak, kullan─▒c─▒n─▒n istedi─či ┼čey bu de─čildir. Bu nedenle, bu ko┼čullar─▒ ├Ânlemek i├žin yap─▒c─▒y─▒ ┼č├Âyle tan─▒mlayaca─č─▒z explicit :

 class String {
public:
    explicit String (int n); //allocate n bytes
    String(const char *p); // initialize sobject with string p
};
 

1078







C ++ 'da yaln─▒zca bir gerekli parametreye sahip bir yap─▒c─▒, ├Ârt├╝k bir d├Ân├╝┼čt├╝rme i┼člevi olarak kabul edilir. Parametre tipini s─▒n─▒f tipine d├Ân├╝┼čt├╝r├╝r. Bunun iyi bir ┼čey olup olmad─▒─č─▒, yap─▒c─▒n─▒n anlam─▒na ba─čl─▒d─▒r.

├ľrne─čin, yap─▒c─▒ ile bir dize s─▒n─▒f─▒n─▒z varsa String(const char* s) , tam olarak istedi─činiz ┼čey budur. const char* A i┼člevini bekleyen bir i┼čleve ge├žebilirsiniz String ; derleyici String sizin i├žin otomatik olarak ge├žici bir nesne olu┼čturacakt─▒r.

├ľte yandan, yap─▒c─▒s─▒ arabellek Buffer(int size) boyutunu bayt olarak alan bir arabellek s─▒n─▒f─▒n─▒z varsa, muhtemelen derleyicinin int s'yi sessizce de─či┼čtirmesini istemezsiniz Buffer . Bunu ├Ânlemek i├žin yap─▒c─▒y─▒ explicit anahtar kelime ile beyan edersiniz :

 class Buffer { explicit Buffer(int size); ... }
 

Bu ┼čekilde,

 void useBuffer(Buffer& buf);
useBuffer(4);
 

derleme zaman─▒ hatas─▒ olur. Ge├žici bir Buffer nesneyi ge├žmek istiyorsan─▒z, bunu a├ž─▒k├ža yapman─▒z gerekir:

 useBuffer(Buffer(4));
 

├ľzet olarak, tek parametreli kurucunuz parametreyi s─▒n─▒f─▒n─▒z─▒n bir nesnesine d├Ân├╝┼čt├╝r├╝yorsa, muhtemelen explicit anahtar kelimeyi kullanmak istemezsiniz . Ancak, basit├že tek bir parametre explicit alan bir kurucunuz varsa, derleyicinin beklenmedik d├Ân├╝┼č├╝mlerle sizi ┼ča┼č─▒rtmas─▒n─▒ ├Ânleyecek ┼čekilde ilan etmelisiniz .


151


2008-09-23





Bu cevap, a├ž─▒k bir kurucu ile / olmadan nesne olu┼čturma ile ilgilidir, ├ž├╝nk├╝ di─čer cevaplarda ele al─▒nmam─▒┼čt─▒r.

A├ž─▒k bir yap─▒c─▒ olmadan a┼ča─č─▒daki s─▒n─▒f─▒ g├Âz ├Ân├╝nde bulundurun:

 class Foo
{
public:
    Foo(int x) : m_x(x)
    {
    }

private:
    int m_x;
};
 

Foo s─▒n─▒f─▒n─▒n nesneleri 2 ┼čekilde olu┼čturulabilir:

 Foo bar1(10);

Foo bar2 = 20;
 

Uygulamaya ba─čl─▒ olarak, Foo s─▒n─▒f─▒n─▒ ba┼člatman─▒n ikinci yolu, programc─▒n─▒n ama├žlad─▒─č─▒ ┼čeyi kar─▒┼čt─▒r─▒c─▒ olabilir veya olmayabilir. explicit Anahtar kelimeyi yap─▒c─▒ya ├Ânceden eklemek, adresinde bir derleyici hatas─▒ olu┼čturur Foo bar2 = 20; .

├ľyle genellikle gibi tek arg├╝man kurucular ilan etmek iyi bir uygulama explicit i├žin uygulama onu ├Âzellikle yasaklamaktad─▒r s├╝rece,.

Ayr─▒ca, bu in┼čaat├ž─▒lar

  • t├╝m parametreler i├žin varsay─▒lan de─či┼čkenler veya
  • ikinci parametre i├žin varsay─▒lan arg├╝manlar

her ikisi de tek ba─č─▒ms─▒z de─či┼čken yap─▒c─▒lar olarak kullan─▒labilir. Yani bunlar─▒ da yapmak isteyebilirsiniz explicit .

E─čer kas─▒tl─▒ ediyorum bir ├Ârnek de─čil senin tek arg├╝man yap─▒c─▒ a├ž─▒k olmak istiyoruz (bakmak 'add_x' yap─▒ bildirilen bir functor olu┼čturuyorsan─▒z olan bu cevap). B├Âyle bir durumda, add_x add30 = 30; muhtemelen mant─▒kl─▒ olacak bir nesne olu┼čturma .

─░┼čte a├ž─▒k in┼čaat├ž─▒lar hakk─▒nda iyi bir yaz─▒.


39







explicit Anahtar kelime olmayan d├Ân├╝┼č├╝m kurucusuna bir d├Ân├╝┼č├╝m yap─▒c─▒ hale getirir. Sonu├ž olarak, kod daha az hataya a├ž─▒kt─▒r.


38







Anahtar kelime explicit ya da e┼člik eder

  • first (yaln─▒zca herhangi bir) parametresini X t├╝r├╝ne dolayl─▒ olarak d├Ân├╝┼čt├╝rmek i├žin kullan─▒lamayan X s─▒n─▒f─▒ bir yap─▒c─▒

C ++ [class.conv.ctor]

1) ─░┼člev belirteci a├ž─▒k├ža belirtilmemi┼č bir yap─▒c─▒, parametre t├╝rlerinden s─▒n─▒f─▒n─▒n t├╝r├╝ne bir d├Ân├╝┼č├╝m├╝ belirtir. B├Âyle bir kurucuya d├Ân├╝┼čt├╝r├╝c├╝ kurucu denir.

2) A├ž─▒k bir yap─▒c─▒, a├ž─▒k olmayan yap─▒c─▒lar gibi nesneleri olu┼čturur, ancak bunu yaln─▒zca do─črudan ba┼člatma s├Âzdiziminin (8.5) veya yay─▒nlar─▒n (5.2.9, 5.4) a├ž─▒k├ža kullan─▒ld─▒─č─▒ yerlerde yapar. Varsay─▒lan bir yap─▒c─▒, a├ž─▒k bir yap─▒c─▒ olabilir; b├Âyle bir kurucu varsay─▒lan ba┼člatma veya de─čer ba┼člatma i┼člemini ger├žekle┼čtirmek i├žin kullan─▒lacakt─▒r (8.5).

  • veya yaln─▒zca do─črudan ba┼člatma ve a├ž─▒k d├Ân├╝┼č├╝m i├žin kabul edilen bir d├Ân├╝┼čt├╝rme i┼člevi.

C ++ [class.conv.fct]

2) Bir d├Ân├╝┼čt├╝rme fonksiyonu a├ž─▒k (7.1.2) olabilir; bu durumda do─črudan ba┼člatma i├žin sadece kullan─▒c─▒ taraf─▒ndan tan─▒mlanan bir d├Ân├╝┼č├╝m olarak kabul edilir (8.5). Aksi takdirde, kullan─▒c─▒ tan─▒ml─▒ d├Ân├╝┼č├╝mlerin atama ve ba┼člatma i┼člemlerinde kullan─▒m─▒ s─▒n─▒rland─▒r─▒lmaz.

genel bak─▒┼č

A├ž─▒k d├Ân├╝┼č├╝m i┼člevleri ve yap─▒c─▒lar yaln─▒zca a├ž─▒k d├Ân├╝┼č├╝mler (do─črudan ba┼člatma veya a├ž─▒k d├Âk├╝m i┼člemi) i├žin kullan─▒labilir; a├ž─▒k olmayan yap─▒c─▒lar ve d├Ân├╝┼č├╝m i┼člevleri de a├ž─▒k ve kapal─▒ d├Ân├╝┼č├╝mler i├žin kullan─▒labilir.

 /*
                                 explicit conversion          implicit conversion

 explicit constructor                    yes                          no

 constructor                             yes                          yes

 explicit conversion function            yes                          no

 conversion function                     yes                          yes

*/
 

Yap─▒lar─▒ X, Y, Z ve fonksiyonlar─▒ kullanarak ├Ârnek foo, bar, baz :

D├Ân├╝┼č├╝mler aras─▒ndaki explicit ve olmayanlar aras─▒ndaki fark─▒ g├Ârmek i├žin k├╝├ž├╝k bir yap─▒ ve fonksiyon kurulumuna bakal─▒m explicit .

 struct Z { };

struct X { 
  explicit X(int a); // X can be constructed from int explicitly
  explicit operator Z (); // X can be converted to Z explicitly
};

struct Y{
  Y(int a); // int can be implicitly converted to Y
  operator Z (); // Y can be implicitly converted to Z
};

void foo(X x) { }
void bar(Y y) { }
void baz(Z z) { }
 

Yap─▒c─▒ya ili┼čkin ├Ârnekler:

Bir fonksiyon arg├╝man─▒n─▒n ├ževrimi:

 foo(2);                     // error: no implicit conversion int to X possible
foo(X(2));                  // OK: direct initialization: explicit conversion
foo(static_cast<X>(2));     // OK: explicit conversion

bar(2);                     // OK: implicit conversion via Y(int) 
bar(Y(2));                  // OK: direct initialization
bar(static_cast<Y>(2));     // OK: explicit conversion
 

Nesne ba┼člatma:

 X x2 = 2;                   // error: no implicit conversion int to X possible
X x3(2);                    // OK: direct initialization
X x4 = X(2);                // OK: direct initialization
X x5 = static_cast<X>(2);   // OK: explicit conversion 

Y y2 = 2;                   // OK: implicit conversion via Y(int)
Y y3(2);                    // OK: direct initialization
Y y4 = Y(2);                // OK: direct initialization
Y y5 = static_cast<Y>(2);   // OK: explicit conversion
 

D├Ân├╝┼č├╝m fonksiyonlar─▒na ili┼čkin ├Ârnekler:

 X x1{ 0 };
Y y1{ 0 };
 

Bir fonksiyon arg├╝man─▒n─▒n ├ževrimi:

 baz(x1);                    // error: X not implicitly convertible to Z
baz(Z(x1));                 // OK: explicit initialization
baz(static_cast<Z>(x1));    // OK: explicit conversion

baz(y1);                    // OK: implicit conversion via Y::operator Z()
baz(Z(y1));                 // OK: direct initialization
baz(static_cast<Z>(y1));    // OK: explicit conversion
 

Nesne ba┼člatma:

 Z z1 = x1;                  // error: X not implicitly convertible to Z
Z z2(x1);                   // OK: explicit initialization
Z z3 = Z(x1);               // OK: explicit initialization
Z z4 = static_cast<Z>(x1);  // OK: explicit conversion

Z z1 = y1;                  // OK: implicit conversion via Y::operator Z()
Z z2(y1);                   // OK: direct initialization
Z z3 = Z(y1);               // OK: direct initialization
Z z4 = static_cast<Z>(y1);  // OK: explicit conversion
 

Neden explicit d├Ân├╝┼čt├╝rme i┼člevlerini veya yap─▒c─▒lar─▒n─▒ kullan─▒yorsunuz?

D├Ân├╝┼č├╝m yap─▒c─▒lar─▒ ve a├ž─▒k olmayan d├Ân├╝┼č├╝m i┼člevleri belirsizli─če neden olabilir.

V D├Ân├╝┼čt├╝r├╝lebilir bir yap─▒ya , ├╝st├╝ kapal─▒ int bir yap─▒ya sahip bir yap─▒ya ve s─▒ras─▒yla ve bu i┼člem i├žin a┼č─▒r─▒ y├╝klenmi┼č bir i┼člev d├╝┼č├╝n├╝n . U V f U bool

 struct V {
  operator bool() const { return true; }
};

struct U { U(V) { } };

void f(U) { }
void f(bool) {  }
 

Bir f t├╝r nesnenin iletilmesi durumunda yap─▒lan ├ža─čr─▒ belirsizdir V .

 V x;
f(x);  // error: call of overloaded 'f(V&)' is ambiguous
 

Derleyici nesneyi ge├žmek i├žin bir t├╝re U d├Ân├╝┼čt├╝rmek i├žin yap─▒c─▒s─▒n─▒n veya d├Ân├╝┼č├╝m i┼člevinin kullan─▒l─▒p kullan─▒lmayaca─č─▒n─▒ bilmez . V f

Yap─▒c─▒s─▒n─▒n ya U da d├Ân├╝┼č├╝m i┼člevinin ya V olmas─▒ halinde explicit , sadece a├ž─▒k olmayan d├Ân├╝┼č├╝m dikkate al─▒naca─č─▒ i├žin belirsizlik olmazd─▒. Her ikisi de a├ž─▒ksa, f bir t├╝r nesneyi kullanma ├ža─čr─▒s─▒, V a├ž─▒k bir d├Ân├╝┼čt├╝rme veya d├Âk├╝m i┼člemi kullan─▒larak yap─▒lmal─▒d─▒r.

D├Ân├╝┼č├╝m yap─▒c─▒lar─▒ ve a├ž─▒k olmayan d├Ân├╝┼č├╝m i┼člevleri beklenmeyen davran─▒┼člara yol a├žabilir.

Baz─▒ vekt├Ârleri basan bir fonksiyon d├╝┼č├╝n├╝n:

 void print_intvector(std::vector<int> const &v) { for (int x : v) std::cout << x << '\n'; }
 

Vekt├Âr├╝n boyut yap─▒c─▒s─▒ a├ž─▒k olmazsa, i┼člevi ┼č├Âyle ├ža─č─▒rmak m├╝mk├╝n olacakt─▒r:

 print_intvector(3);
 

B├Âyle bir aramadan ne beklenir? Bir sat─▒r m─▒, 3 yoksa ├╝├ž sat─▒r 0 m─▒? (─░kincinin oldu─ču yerde.)

A├ž─▒k anahtar s├Âzc├╝─č├╝n bir s─▒n─▒f arabiriminde kullan─▒lmas─▒, arabirimin kullan─▒c─▒s─▒n─▒ istenen bir d├Ân├╝┼č├╝m hakk─▒nda a├ž─▒k olmaya zorlar.

Bjarne StroustrupÔÇÖun belirtti─či gibi ("C ++ Programlama Dili" nde, 4. Bask─▒, 35.2.1, pp. 1011) neden std::duration a├ž─▒k├ža d├╝z bir ┼čekilde yap─▒lamad─▒─č─▒ sorusu ├╝zerine :

Ne demek istedi─čini biliyorsan─▒z, bu konuda a├ž─▒k olun.


38







A├ž─▒k d├Ân├╝┼č├╝m yap─▒c─▒lar─▒ (yaln─▒zca C ++)

A├ž─▒k i┼člev belirticisi, istenmeyen ├Ârt├╝k t├╝r d├Ân├╝┼čt├╝rmelerini denetler. Sadece s─▒n─▒f beyan─▒ dahilindeki in┼čaat├ž─▒ beyanlar─▒nda kullan─▒labilir. ├ľrne─čin, varsay─▒lan kurucu d─▒┼č─▒nda, a┼ča─č─▒daki s─▒n─▒ftaki kurucular d├Ân├╝┼č├╝m kurucular─▒d─▒r.

 class A
{
public:
    A();
    A(int);
    A(const char*, int = 0);
};
 

A┼ča─č─▒daki beyanlar yasald─▒r:

 A c = 1;
A d = "Venditti";
 

─░lk bildirim e┼čde─čerdir A c = A( 1 ); .

S─▒n─▒f─▒n kurucusunu explicit ┼ču ┼čekilde bildirirseniz, ├Ânceki bildirimler yasad─▒┼č─▒ olacakt─▒r.

├ľrne─čin, s─▒n─▒f─▒ ┼č├Âyle ilan ederseniz:

 class A
{
public:
    explicit A();
    explicit A(int);
    explicit A(const char*, int = 0);
};
 

Yaln─▒zca s─▒n─▒f t├╝r├╝n├╝n de─čerleriyle e┼čle┼čen de─čerler atayabilirsiniz.

├ľrne─čin, a┼ča─č─▒daki ifadeler yasald─▒r:

   A a1;
  A a2 = A(1);
  A a3(1);
  A a4 = A("Venditti");
  A* p = new A(1);
  A a5 = (A)1;
  A a6 = static_cast<A>(1);
 

36







explicit -Kelime ├ža─čr─▒lacak bir kurucu zorlamak i├žin kullan─▒labilir a├ž─▒k├ža .

 class C{
public:
    explicit C(void) = default;
};

int main(void){
    C c();
    return 0;
}
 

explicit yap─▒c─▒ ├Ân├╝ndeki -keyword C(void) , derleyiciye yaln─▒zca bu yap─▒c─▒ya yap─▒lan a├ž─▒k ├ža─čr─▒ya izin verildi─čini s├Âyler.

explicit -Anahtar ayn─▒ zamanda kullan─▒c─▒ tan─▒ml─▒ t├╝r d├Âk├╝m operat├Ârler de kullan─▒labilir:

 class C{
public:
    explicit inline operator bool(void) const{
        return true;
    }
};

int main(void){
    C c;
    bool b = static_cast<bool>(c);
    return 0;
}
 

Burada explicit -keyword , yaln─▒zca a├ž─▒k yay─▒nlar─▒ ge├žerli olmaya zorlar bool b = c; , bu durumda bu ge├žersiz bir d├Âk├╝m olacakt─▒r. Bunlar gibi explicit anahtar kelimeler, programc─▒n─▒n ├Ârt├╝l├╝, istenmeyen yay─▒nlardan ka├ž─▒nmas─▒na yard─▒mc─▒ olabilir. Bu kullan─▒m C ++ 11'de standardize edilmi┼čtir .


27







Cpp Referans her zaman yard─▒mc─▒ olur !!! A├ž─▒k belirtici ile ilgili ayr─▒nt─▒lar─▒ burada bulabilirsiniz . ├ľrt├╝k d├Ân├╝┼čt├╝rmelere ve kopya ba┼člatma i┼člemlerine de bakman─▒z gerekebilir .

H─▒zl─▒ bak─▒┼č

A├ž─▒k belirtici, bir yap─▒c─▒ veya d├Ân├╝┼čt├╝rme i┼člevinin (C ++ 11'den beri) ├Ârt├╝k d├Ân├╝┼č├╝mlere veya kopya ba┼člatma i┼člemlerine izin vermedi─čini belirtir.

A┼ča─č─▒daki gibi ├Ârnek:

 struct A
{
    A(int) { }      // converting constructor
    A(int, int) { } // converting constructor (C++11)
    operator bool() const { return true; }
};

struct B
{
    explicit B(int) { }
    explicit B(int, int) { }
    explicit operator bool() const { return true; }
};

int main()
{
    A a1 = 1;      // OK: copy-initialization selects A::A(int)
    A a2(2);       // OK: direct-initialization selects A::A(int)
    A a3 {4, 5};   // OK: direct-list-initialization selects A::A(int, int)
    A a4 = {4, 5}; // OK: copy-list-initialization selects A::A(int, int)
    A a5 = (A)1;   // OK: explicit cast performs static_cast
    if (a1) cout << "true" << endl; // OK: A::operator bool()
    bool na1 = a1; // OK: copy-initialization selects A::operator bool()
    bool na2 = static_cast<bool>(a1); // OK: static_cast performs direct-initialization

//  B b1 = 1;      // error: copy-initialization does not consider B::B(int)
    B b2(2);       // OK: direct-initialization selects B::B(int)
    B b3 {4, 5};   // OK: direct-list-initialization selects B::B(int, int)
//  B b4 = {4, 5}; // error: copy-list-initialization does not consider B::B(int,int)
    B b5 = (B)1;   // OK: explicit cast performs static_cast
    if (b5) cout << "true" << endl; // OK: B::operator bool()
//  bool nb1 = b2; // error: copy-initialization does not consider B::operator bool()
    bool nb2 = static_cast<bool>(b2); // OK: static_cast performs direct-initialization
}
 

20







Bu daha ├Ânce tart─▒┼č─▒ld─▒ ( a├ž─▒k kurucu olan nedir ). Ancak ┼čunu s├Âylemeliyim ki, burada bulunan ayr─▒nt─▒l─▒ a├ž─▒klamalardan yoksun.

Ayr─▒ca, daha ├Ânce belirtildi─či gibi bir arg├╝man kurucunuzu (arg2, arg3, ... i├žin varsay─▒lan de─čerleri i├žerenler de dahil olmak ├╝zere) yapmak her zaman iyi bir kodlama uygulamas─▒d─▒r. Her zaman oldu─ču gibi C ++ ile: yapmazsan - yapman─▒ istersin ...

S─▒n─▒flar i├žin bir ba┼čka iyi uygulama da, ger├žekten uygulaman─▒z gerekmedik├že, kopya olu┼čturma ve atamay─▒ ├Âzel k─▒lmakt─▒r (aka devre d─▒┼č─▒ b─▒rakmak). Bu, C ++ 'n─▒n sizin i├žin varsay─▒lan olarak olu┼čturaca─č─▒ y├Ântemleri kullan─▒rken, i┼čaret├žilerin nihai kopyalar─▒n─▒n olmas─▒n─▒ ├Ânler. Bunu yapman─▒n ba┼čka bir yolu da art─▒rma :: hesaplanamaz.


18







Yap─▒c─▒lar ├Ârt├╝k d├Ân├╝┼č├╝m ekler. Bu ├Ârt├╝k d├Ân├╝┼čt├╝rmeyi bast─▒rmak i├žin, yap─▒c─▒y─▒ a├ž─▒k bir parametreyle bildirmek gerekir.

11 C ++ uygulamas─▒nda da b├Âyle anahtar kelimesiyle bir "operat├Âr t├╝r├╝ ()" belirtebilirsiniz http://en.cppreference.com/w/cpp/language/explicit m├╝stehcen d├Ân├╝┼č├╝mler a├ž─▒s─▒ndan operat├Âr├╝n├╝ kullanabilirsiniz B├Âyle ┼čartname ile, ve nesnenin do─črudan ba┼člat─▒lmas─▒.

PS KULLANICI TARAFINDAN tan─▒mlanm─▒┼č d├Ân├╝┼č├╝mleri kullan─▒rken (in┼čaat├ž─▒lar ve t├╝r d├Ân├╝┼č├╝m operat├Âr├╝ arac─▒l─▒─č─▒yla), yaln─▒zca bir ├Ârt├╝k d├╝zey d├Ân├╝┼č├╝m kullan─▒lmas─▒na izin verilir. Ancak bu d├Ân├╝┼č├╝mleri di─čer dil d├Ân├╝┼č├╝mleriyle birle┼čtirebilirsiniz.

  • entegral basamaklar─▒ (char - int, float - double);
  • standart d├Ân├╝┼č├╝mler (int ile ├žift);
  • nesnelerin i┼čaret├žilerini temel s─▒n─▒fa ve bo┼člu─ča d├Ân├╝┼čt├╝rmek *;

5