quá tải dễ bay hơi?

Question

Tôi nghe nói rằng dễ bay hơi là yếu tố quá tải như const.

Nếu chức năng bị quá tải bởi thông số dễ bay hơi, khi nào là phiên bản dễ bay hơi được gọi?

Tôi không thể tưởng tượng được tình huống khi phiên bản biến động được gọi.  

Answer 1

Biến động có thể được áp dụng cho các tham số, nhưng nó không phải là một yếu tố quá tải khi áp dụng trực tiếp cho tham số. Tuy nhiên, nó có thể sử dụng nó để phân biệt các loại tham số. Ví dụ, đây là quy phạm pháp luật:

void f(int &p) {}; //reference to int 
void f(volatile int &p) {}; //reference to volatile int 

Đây không phải là:

void f(int p) {}; 
void f(volatile int p) {}; 

Lý do là trong ví dụ đầu tiên tham chiếu là không gì là không ổn định, nhưng các số nguyên. Trong ví dụ thứ hai, cả hai loại là số nguyên và do đó cùng loại.

Ngoài ra còn có các phương pháp dễ bay hơi. Chúng tương tự như tuyên bố this để dễ bay hơi. Bởi vì this là một con trỏ và không phải là loại có chứa chính nó, sau cũng là hợp pháp:

void c::f(int p) {}; 
void c::f(int p) volatile {}; 

Đó là tất cả giống như cho quá tải bởi const.

Phần liên quan này của tiêu chuẩn C++ là §13.1 Tuyên bố quá tải. Từ bản thảo C++ 11 n3290:

Khai báo tham số khác với sự hiện diện hoặc vắng mặt của const và/hoặc bay hơi là tương đương. Nghĩa là, các kiểu biến dạng const và biến động cho mỗi kiểu tham số được bỏ qua khi xác định hàm nào đang được khai báo, định nghĩa hoặc được gọi. [Ví dụ:

typedef const int cInt; 
int f(int); 
int f(const int);   // redeclaration of f(int) 
int f(int) { /* ... */ } // definition of f(int) 
int f(cInt) { /* ... */ } // error: redefinition of f(int) 

- end dụ]

Chỉ const và dễ bay hơi kiểu specifiers ở cấp ngoài cùng của đặc tả kiểu tham số được bỏ qua trong thời trang này; const và các kiểu biến dạng dễ bay hơi được chôn trong một đặc tả kiểu tham số là quan trọng và có thể được sử dụng để phân biệt các khai báo hàm quá tải . Cụ thể, đối với mọi loại T, pointer to T, pointer to const T và pointer to volatile T được coi là các loại thông số riêng biệt, như là reference to T, reference to const T và reference to volatile T.

_{124) Khi một loại tham số bao gồm một loại chức năng, chẳng hạn như trong trường hợp của một loại tham số đó là một con trỏ đến chức năng, các const và dễ bay hơi kiểu specifiers ở cấp ngoài cùng của thông số kỹ thuật loại tham số cho loại hàm bên trong là cũng bị bỏ qua.}

Answer 2

Dưới đây là một ví dụ:

#include <iostream> 

struct A { 
    void foo() { 
     std::cout << "in non-volatile" << std::endl; 
    } 
    void foo() volatile { 
     std::cout << "in volatile" << std::endl; 
    } 
}; 

int main() 
{ 
    A a; 
    a.foo(); 
    volatile A b; 
    b.foo(); 
} 

b.foo() sẽ gọi quá tải volatile. Nếu struct A không có quá tải dễ bay hơi đối với foo, b.foo() sẽ không hợp lệ.

Answer 3

Viết chương trình thử nghiệm để tìm hiểu.

void func(const int& a) 
{ 
    std::cout << "func(const)" << std::endl; 
} 

void func(const volatile int& a) 
{ 
    std::cout << "func(const volatile)" << std::endl; 
} 

int main() 
{ 
    const int a = 0; 
    const volatile int b = 0; 
    func(a); 
    func(b); 
    system("pause"); 
    return 0; 
} 

chí đầu ra:

func(const) 
func(const volatile)