The .appxupload contains the MSIL binaries as well as an explicit reference to the version of the .NET Native toolchain your app consumes (referenced in the AppxManifest.xml).

#include <vector>

int main()
{
    std::vector<int> ints;
    std::vector<float> floats;

    ints.push_back(1);
    floats.push_back(1);

    return 0;
}

    ints.push_back(1);
0014104D  lea         ecx,[ints]  
00141050  mov         byte ptr [ebp-4],1  
00141054  call        std::vector<float,std::allocator<float> >::_Reserve (0141140h)  
...

    floats.push_back(1);
014106A  lea         ecx,[floats]  
0014106D  mov         dword ptr [ebp-20h],eax  
00141070  call        std::vector<float,std::allocator<float> >::_Reserve (0141140h)

    return 0;
00141083  lea         ecx,[floats]  
00141089  call        std::vector<int,std::allocator<int> >::_Tidy (01410C0h)  
0014108E  lea         ecx,[ints]  
00141091  call        std::vector<int,std::allocator<int> >::_Tidy (01410C0h)

Ad-hoc polymorphism, by contrast, allows a polymorphic value to exhibit different behaviors when “viewed” at different types. The most common example of ad-hoc polymorphism is overloading, which associates a single function symbol with many implementations; the compiler (or the runtime system, depending on whether overloading resolution is static or dynamic) chooses an appropriate implementation for each application of the function, based on the types of the arguments.

TAPL

Several varieties of polymorphism can be found in modern languages (this classification comes from Strachey, 1967, and Cardelli and Wegner, 1985).

Там же

_>bool operator()(const T &lhs, const T &rhs) const
_>{
_>    return lhs.compare(rhs)==0;
_>}
_>

_>

class Base {
  typedef SomeType value_type;
  value_type value_;

  virtual void update(value_type newValue) {
    if(value_ != newValue) {
      value_ = newValue;
      onValueChanged();
    }
  }

  virtual void onValueChanged(SomeType newValue) {}
};

template<typename T>
class SomeAspect : public T
{
  typedef T base;
  typedef typename T::value_type value_type;

  virtual void onValueChanged(value_type newValue) {
    someLog(newValue);
    base::onValueChanged(newValue);
  }
};

Parametric polymorphism, the topic of this chapter, allows a single piece of code to be typed “generically,” using variables in place of actual types, and then instantiated with particular types as needed. Parametric definitions are uniform: all of their instances behave the same.

TAPL

#include <vector>

int main()
{
    std::vector<char> chars;
    std::vector<double> doubles;

    chars.push_back(1);
    doubles.push_back(1);

    return 0;
}

    chars.push_back(1);
00CE107B  push        eax  
00CE107C  lea         ecx,[chars]  
00CE107F  mov         byte ptr [ebp-29h],1  
00CE1083  call        std::vector<char,std::allocator<char> >::emplace_back<char> (0CE12F0h)  
    doubles.push_back(1);
00CE1088  movsd       xmm0,mmword ptr [__real@3ff0000000000000 (0CE31A8h)]  
00CE1090  lea         eax,[ebp-34h]  
00CE1093  push        eax  
00CE1094  lea         ecx,[doubles]  
00CE1097  movsd       mmword ptr [ebp-34h],xmm0  
00CE109C  call        std::vector<double,std::allocator<double> >::emplace_back<double> (0CE1220h)