## C++ function templates: Limitations Instantiation and Reification

- An American company made 0.7nm chips: EUV lithography machines can’t do it
- CVE-2007-4559 Python vulnerability ignored for 15 years puts 350,000 projects at risk of code execution
- RISC-V only takes 12 years to achieve the milestone of 10 billion cores
- 14000 cores + 450W: RTX 4080 graphics card perfectly replaces the RTX 3080
- Big upgrade: The difference between Bluetooth 5.0 and 5.2
- Geeks Disappointed that RTX 4080/4090 doesn’t come with PCIe 5.0
- What are advantages and disadvantages of different load balancing?

C++ function templates: Limitations Instantiation and Reification.

```
template<typename T>
void Swap(T &a ,T &b){
T temp;
temp = a;
a = b;
b = temp;
}
```

When using a template function, the compiler generates the corresponding function definition based on the actual type.

## overloaded template

Not all types use the same algorithm, and template function definitions can be overloaded like regular functions.

```
template<typename T>
void Swap(T &a ,T &b); //#1
template<typename T>
void Swap(T *a ,T *b,int n);//#2 the last parameter is a specific type
int main(){
int i =10,j=20;
Swap(i,j);//use #1
const int Lim = 8;
int d1[Lim]={0,1,2,3,4,5,6,7};
int d2[Lim]={7,6,5,4,3,2,1,0};
Swap(d1,d2,Lim);//use #2
}
template<typename T>
void Swap(T &a ,T &b){
T temp;
temp = a;
a = b;
b = temp;
}
template<typename T>
void Swap(T *a ,T *b,int n){
T temp;
for(int i=0;i<n;i++)
{
temp =a[i];
a[i]=b[i];
b[i]=temp;
}
}
```

## Template limitations

In some cases, the corresponding operation of type T is only applicable to arrays. If T is a structure, the template function does not hold.

Likewise, `if(a>b)`

if T is a structure, > does not hold

solution:

- overloaded operator symbols
- Provides a reified template definition for a specific type

## Show incarnation

When the compiler finds a reified definition that matches a function call, it will use that definition and no longer look for templates.

- For a given function name, there can be non-template functions, template functions, and explicit reified template functions and their overloaded versions.
- Shows that reified prototypes and definitions
`template<>`

begin with and indicate the type by name - The calling order is: non-template function > reified template function > template function

```
void Swap(job& ,job&);
template <typename T>
void Swap(T&,T&);
template<> void Swap<job>(job& ,job&);//show incarnation
//<job> in Swap<job> is optional, because the parameter type of the function indicates that this is a reification of job, so it can also be written like this: template<> void Swap(job& ,job&);
```

## Instantiation and reification

*Note: A* function template does not generate a function definition, it just generates a scheme for generating a function definition. When the compiler uses a template to generate a function definition for a specific type, it gets a template instance.

```
template<typename T>
void Swap(T &a ,T &b);
int a =10,b=20;
Swap(a,b);//Because a parameter of type int is provided, a template instance of type int is automatically generated. This is == implicit instantiation ==
```

//You can also directly instruct the compiler to create a specific instance//Display instantiation template void Swap<int>(int &,int &);

//Use Swap() template to generate int function definition of type
//show incarnation
template<> void Swap<int>(int& ,int&);
template<> void Swap(int& ,int&);
//The difference is: Concretization does not use the Swap() template function to generate a function definition, but uses a function definition specifically defined for the int type.

//Simple understanding, concretization is a declaration of a function, and instantiation is a Use of template functions

```
template<typename T>
T Add(T a,T b){
return a+b;
}
int m=6;
double x=10.5;
Add<double>(x,m); //Does not match with Add(x,m), because one is int and the other is double
```

//Instantiation by Add<double>, m can be forced to be converted to double

//But the same can not be successful for Swap, because Swap uses is a reference type Swap<double>(m,x);//double& cannot point to int

```
//Example case
template <typename T>
void Swap(T &,T &);
template<> void Swap<job>(job&,job&);//具体化
int mian(){
template void Swap<char>(char& ,char&);
short a,b;
Swap(a,b);//Implicit instantiation
job n,m;
Swap(n,m);//show incarnation
char g,h;
Swap(g,h);//show instantiation
}
```

## Determination of template function type

```
template<class T1,class T2>
void fun(T1 x,T2 y){
?type? s=x+y; //Because it is a template function, the type of ?type? is uncertain at this time
}
```

C++11 adds `decltype`

keywords

```
template<class T1,class T2>
void fun(T1 x,T2 y){
decltype(x+y) s=x+y; //The type of s is the same as the type of x+y
}
```

Steps to use `decltype(expression) var`

:

- If expression is not enclosed in parentheses, then var has the same type as expression, including qualifiers such as const

```
double x =5.5;
double& z =x;
const double* pd;
decltype(x) w; //w is double type
decltype(z) u; //u is double& type
decltype(pd) v; //v is const double* type
```

- If expression is a function call, then var has the same type as the return value.
*does not actually call the function, the compiler determines the return type by looking at the prototype* - If expression is an lvalue, then var is a reference to its type. Common situations are as follows:

```
double x = 4.5;
decltype((x)) r = x;//r is double& type
decltype(x) r = x;//r is double type
// Parentheses do not change the value and lvalue of expression
```

//It can be understood that adding parentheses is only a way of decltype statement reference

- If none of the first 3 are satisfied, then var has the same type as expression

```
int j=3;
int &k=j;
int &n=j;
decltype(j+6) x; //x is int
decltype(k+n) y;//y is an int, although k and n are references, but k+n is not a reference is the sum of 2 ints
```

If declared multiple times, it is possible to combine `typedef`

and`decltype`

```
typedef decltype(x+y) xytype;
xytype z = x+y;
xytype arr[10];
```

However, some function templates that need to define the return value type still cannot be solved, such as:

```
template<class T1,class T2>
?type? fun(T1 x,T2 y) //The type cannot be determined at this time
{
return x+y;
}
```

C++ adds a new syntax `auto h(int x,float y) -> double`

, which is called a post-return type, and auto is a placeholder

```
template<class T1,class T2>
auto fun(T1 x,T2 y)->decltype(x+y) //The post type uses decltype{
return x+y;
}
```

- DIY a PBX (Phone System) on Raspberry Pi
- How to host multiple websites on Raspberry Pi 3/4?
- A Free Intercom/Paging system with Raspberry pi and old Android phones
- DIY project: How to use Raspberry Pi to build DNS server?
- Raspberry Pi project : How to use Raspberry Pi to build git server?