`decltype` (C++)

Tür tanımlayıcısı decltype , belirtilen ifadenin türünü verir. Tür tanımlayıcısıdecltype, anahtar sözcüğüyleauto birlikte öncelikle şablon kitaplıkları yazan geliştiriciler için yararlıdır. dönüş türü şablon bağımsız değişkenlerinin türlerine bağlı olan bir işlev şablonu bildirmek için ve decltype kullanınauto. Veya bir çağrıyı başka bir işleve sarmalayan ve sonra sarmalanan işlevin dönüş türünü döndüren bir işlev şablonu bildirmek için ve decltype kullanınauto.

Sözdizimi

decltype( expression )

Parametreler

expression
Bir ifade. Daha fazla bilgi için bkz. İfadeler.

Dönüş değeri

Parametresinin expression türü.

Açıklamalar

Tür decltype tanımlayıcısı Visual Studio 2010 veya sonraki sürümlerde desteklenir ve yerel veya yönetilen kodla kullanılabilir. decltype(auto) (C++14), Visual Studio 2015 ve sonraki sürümlerde desteklenir.

Derleyici, parametrenin expression türünü belirlemek için aşağıdaki kuralları kullanır.

expression Parametre bir tanımlayıcı veya sınıf üyesi erişimiyse, decltype(expression) tarafından expressionadlandırılan varlığın türüdür. Böyle bir varlık yoksa veya expression parametre aşırı yüklenmiş işlevler kümesini adlandırıyorsa, derleyici bir hata iletisi verir.
expression Parametresi bir işleve yapılan çağrı veya aşırı yüklenmiş bir işleç işleviyse, decltype(expression) işlevin dönüş türüdür. Aşırı yüklenmiş bir işlecin etrafındaki parantezler yoksayılır.
expression Parametre bir rvalue ise, decltype(expression) türüdürexpression. expression Parametre bir lvalue ise, decltype(expression) türüne yönelik bir lvalue başvurusudurexpression.

Aşağıdaki kod örneği, tür tanımlayıcısının decltype bazı kullanımlarını gösterir. İlk olarak, aşağıdaki deyimleri kodladığınız varsayın.

int var;
const int&& fx();
struct A { double x; };
const A* a = new A();

Ardından, aşağıdaki tabloda yer alan dört decltype deyim tarafından döndürülen türleri inceleyin.

Açıklama	Türü	Notes
`decltype(fx());`	`const int&&`	bir rvalue başvurusu`const int`.
`decltype(var);`	`int`	değişkeninin `var`türü.
`decltype(a->x);`	`double`	Üye erişiminin türü.
`decltype((a->x));`	`const double&`	İç ayraçlar, deyiminin üye erişimi yerine bir ifade olarak değerlendirilmesine neden olur. `a` İşaretçi olarak `const` bildirildiğinden, türü öğesine `const double`bir başvurudur.

`decltype` ve `auto`

C++14'te, dönüş türü şablon bağımsız değişkenlerinin türlerine bağlı olan bir işlev şablonu bildirmek için sonunda dönüş türü olmadan kullanabilirsiniz decltype(auto) .

C++11'de, dönüş türü şablon bağımsız değişkenlerinin türlerine bağlı olan bir işlev şablonunu bildirmek için, son dönüş türünde tür tanımlayıcısını anahtar sözcüğüyle auto birlikte kullanabilirsinizdecltype. Örneğin, işlev şablonunun dönüş türünün şablon bağımsız değişkenlerinin türlerine bağlı olduğu aşağıdaki kod örneğini göz önünde bulundurun. Kod örneğinde yer tutucu, UNKNOWN dönüş türünün belirtilebileceğini gösterir.

template<typename T, typename U>
UNKNOWN func(T&& t, U&& u){ return t + u; }

Tür tanımlayıcısının decltype tanıtılması, bir geliştiricinin işlev şablonunun döndürdüğü ifadenin türünü almasını sağlar. Daha sonra gösterilen alternatif işlev bildirimi söz diziminiauto, anahtar sözcüğünü ve tür tanımlayıcısını decltype kullanarak geç belirtilen dönüş türünü bildirin. Geç belirtilen dönüş türü, kodlandığında değil, bildirim derlendiğinde belirlenir.

Aşağıdaki prototip, alternatif işlev bildiriminin söz dizimini gösterir. const ve volatile niteleyicileri ve throwözel durum belirtimi isteğe bağlıdır. Yer tutucu, function_body işlevin ne yaptığını belirten bileşik bir deyimi temsil eder. En iyi kodlama uygulaması olarak, expression deyimindeki decltype yer tutucu, deyimi tarafından return belirtilen ifadeyle (varsa) içinde function_bodyeşleşmelidir.

auto function_name ( parameters _Tercih)const_Tercihvolatile_Tercih->decltype(expression)noexcept_Tercih{function_body};

Aşağıdaki kod örneğinde, işlev şablonunun geç belirtilen dönüş türü myFunc ve u şablon bağımsız değişkenlerinin t türlerine göre belirlenir. En iyi kodlama uygulaması olarak, kod örneği ayrıca rvalue başvurularını ve mükemmel iletmeyiforward destekleyen işlev şablonunu kullanır. Daha fazla bilgi için bkz . Rvalue başvuru bildirimcisi: &.

//C++11
template<typename T, typename U>
auto myFunc(T&& t, U&& u) -> decltype (forward<T>(t) + forward<U>(u))
        { return forward<T>(t) + forward<U>(u); }

//C++14
template<typename T, typename U>
decltype(auto) myFunc(T&& t, U&& u)
        { return forward<T>(t) + forward<U>(u); }

`decltype` ve iletme işlevleri (C++11)

İletme işlevleri çağrıları diğer işlevlere sarmalar. Bağımsız değişkenlerini veya bu bağımsız değişkenleri içeren bir ifadenin sonuçlarını başka bir işleve ileden bir işlev şablonu düşünün. Ayrıca, iletme işlevi diğer işlevi çağırmanın sonucunu döndürür. Bu senaryoda, iletme işlevinin dönüş türü sarmalanan işlevin dönüş türüyle aynı olmalıdır.

Bu senaryoda, tür tanımlayıcısı olmadan decltype uygun bir tür ifadesi yazamazsınız. Tür tanımlayıcısı decltype , bir işlevin başvuru türü döndürdüğüyle ilgili gerekli bilgileri kaybetmediğinden genel iletme işlevlerini etkinleştirir. İletme işlevinin kod örneği için önceki myFunc işlev şablonu örneğine bakın.

Örnekler

Aşağıdaki kod örneği, işlev şablonunun Plus()geç belirtilen dönüş türünü bildirir. işlevi, Plus iki işlenenini aşırı yüklemeyle operator+ işler. Bu nedenle, artı işlecinin (+) yorumlanması ve işlevin Plus dönüş türü, işlev bağımsız değişkenlerinin türlerine bağlıdır.

// decltype_1.cpp
// compile with: cl /EHsc decltype_1.cpp

#include <iostream>
#include <string>
#include <utility>
#include <iomanip>

using namespace std;

template<typename T1, typename T2>
auto Plus(T1&& t1, T2&& t2) ->
   decltype(forward<T1>(t1) + forward<T2>(t2))
{
   return forward<T1>(t1) + forward<T2>(t2);
}

class X
{
   friend X operator+(const X& x1, const X& x2)
   {
      return X(x1.m_data + x2.m_data);
   }

public:
   X(int data) : m_data(data) {}
   int Dump() const { return m_data;}
private:
   int m_data;
};

int main()
{
   // Integer
   int i = 4;
   cout <<
      "Plus(i, 9) = " <<
      Plus(i, 9) << endl;

   // Floating point
   float dx = 4.0;
   float dy = 9.5;
   cout <<
      setprecision(3) <<
      "Plus(dx, dy) = " <<
      Plus(dx, dy) << endl;

   // String
   string hello = "Hello, ";
   string world = "world!";
   cout << Plus(hello, world) << endl;

   // Custom type
   X x1(20);
   X x2(22);
   X x3 = Plus(x1, x2);
   cout <<
      "x3.Dump() = " <<
      x3.Dump() << endl;
}

Plus(i, 9) = 13
Plus(dx, dy) = 13.5
Hello, world!
x3.Dump() = 42

Visual Studio 2017 ve üzeri: Derleyici, şablonlar örneği değil bildirildiğinde bağımsız değişkenleri ayrıştırıyor decltype . Bu nedenle bağımsız değişkende decltype bağımlı olmayan bir uzmanlık bulunursa, örnekleme süresine ertelenmeyecektir; hemen işlenir ve sonuçta ortaya çıkan hatalar o anda tanılanır.

Aşağıdaki örnekte, bildirim noktasında oluşturulan böyle bir derleyici hatası gösterilmektedir:

#include <utility>
template <class T, class ReturnT, class... ArgsT> class IsCallable
{
public:
   struct BadType {};
   template <class U>
   static decltype(std::declval<T>()(std::declval<ArgsT>()...)) Test(int); //C2064. Should be declval<U>
   template <class U>
   static BadType Test(...);
   static constexpr bool value = std::is_convertible<decltype(Test<T>(0)), ReturnT>::value;
};

constexpr bool test1 = IsCallable<int(), int>::value;
static_assert(test1, "PASS1");
constexpr bool test2 = !IsCallable<int*, int>::value;
static_assert(test2, "PASS2");

Gereksinimler

Visual Studio 2010 veya sonraki sürümleri.

decltype(auto) Visual Studio 2015 veya üzerini gerektirir.

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?

Last updated on 2025-11-07