Quá tải theo loại trả lại

Tôi đọc được một số câu hỏi ở đây trên SO về chủ đề này mà dường như vẫn còn khó hiểu đối với tôi. Tôi mới bắt đầu học C ++ và tôi chưa nghiên cứu các khuôn mẫu hoặc nạp chồng toán tử và những thứ tương tự.

Bây giờ có một cách đơn giản để quá tải

class My {
public:
    int get(int);
    char get(int);
}

không có khuôn mẫu hoặc hành vi lạ? hay tôi chỉ nên

class My {
public:
    int get_int(int);
    char get_char(int);
}

?

Không, không có. Bạn không thể nạp chồng các phương thức dựa trên kiểu trả về.

Giải quyết quá tải có tính đến chữ ký chức năng . Chữ ký hàm được tạo thành từ:

• Tên chức năng
• vòng loại cv
• các loại tham số

Và đây là câu trích dẫn:

1.3.11 chữ ký

thông tin về một hàm tham gia phân giải quá tải (13.3): tham số-kiểu-danh sách (8.3.5) của nó và, nếu hàm là một thành viên lớp, thì các vòng loại cv (nếu có) trên chính hàm và lớp trong đó hàm thành viên được khai báo. [...]

Các tùy chọn:

1) thay đổi tên phương thức:

class My {
public:
    int getInt(int);
    char getChar(int);
};

2) tham số ra:

class My {
public:
    void get(int, int&);
    void get(int, char&);
}

3) mẫu ... quá mức cần thiết trong trường hợp này.

Nó có thể, nhưng tôi không chắc rằng đó là một kỹ thuật tôi muốn giới thiệu cho người mới bắt đầu. Như trong các trường hợp khác, khi bạn muốn lựa chọn các hàm phụ thuộc vào cách sử dụng giá trị trả về, bạn sử dụng proxy; đầu tiên xác định các hàm như getCharvà getInt, sau đó là một hàm chung get()trả về một Proxy như sau:

class Proxy
{
    My const* myOwner;
public:
    Proxy( My const* owner ) : myOwner( owner ) {}
    operator int() const
    {
        return myOwner->getInt();
    }
    operator char() const
    {
        return myOwner->getChar();
    }
};

Mở rộng nó thành nhiều loại nếu bạn cần.

Không, bạn không thể nạp chồng theo kiểu trả về; chỉ bởi các loại tham số và định tính const / biến động.

Một thay thế sẽ là "return" bằng cách sử dụng đối số tham chiếu:

void get(int, int&);
void get(int, char&);

mặc dù tôi có thể sẽ sử dụng một mẫu hoặc các hàm được đặt tên khác như ví dụ thứ hai của bạn.

Bạn có thể nghĩ theo cách này:

Bạn có:

  int get(int);
  char get(int);

Và, không bắt buộc phải thu thập giá trị trả về của hàm khi đang gọi.

Bây giờ, bạn gọi

  get(10);  -> there is an ambiguity here which function to invoke. 

Vì vậy, Không có ý nghĩa nếu cho phép quá tải dựa trên kiểu trả về.

Đang phục hồi một chuỗi cũ, nhưng tôi có thể thấy rằng không ai đề cập đến việc quá tải bởi các bộ định lượng ref. Vòng loại tham chiếu là một tính năng ngôn ngữ được thêm vào trong C ++ 11 và tôi chỉ mới tình cờ thấy nó gần đây - nó không phổ biến như vòng loại cv. Ý tưởng chính là để phân biệt giữa hai trường hợp: khi hàm thành viên được gọi trên một đối tượng rvalue và khi nào được gọi trên một đối tượng lvalue. Về cơ bản bạn có thể viết một cái gì đó như thế này (tôi đang sửa đổi một chút mã của OP):

#include <stdio.h>

class My {
public:
    int get(int) & { // notice &
        printf("returning int..\n");
        return 42;
    }
    char get(int) && { // notice &&
        printf("returning char..\n");
        return 'x';
    };
};

int main() {
    My oh_my;
    oh_my.get(13); // 'oh_my' is an lvalue
    My().get(13); // 'My()' is a temporary, i.e. an rvalue
}

Mã này sẽ tạo ra kết quả sau:

returning int..
returning char..

Tất nhiên, như trường hợp của các định nghĩa cv, cả hai hàm có thể trả về cùng một kiểu và việc nạp chồng vẫn sẽ thành công.

Như đã nêu trước đây, các mẫu là quá mức cần thiết trong trường hợp này, nhưng nó vẫn là một lựa chọn đáng được đề cập.

class My {
public:
    template<typename T> T get(int);
};

template<> int My::get<int>(int);
template<> char My::get<char>(int);

Trong khi hầu hết các nhận xét khác về vấn đề này là đúng về mặt kỹ thuật, bạn có thể quá tải giá trị trả về một cách hiệu quả nếu bạn kết hợp nó với quá tải tham số đầu vào. Ví dụ:

class My {
public:
    int  get(int);
    char get(unsigned int);
};

BẢN GIỚI THIỆU:

#include <stdio.h>

class My {
public:
    int  get(         int x) { return 'I';  };
    char get(unsinged int x) { return 'C';  };
};

int main() {

    int i;
    My test;

    printf( "%c\n", test.get(               i) );
    printf( "%c\n", test.get((unsigned int) i) );
}

Kết quả của việc này là:

I 
C

Không có cách nào để nạp chồng bằng kiểu trả về trong C ++. Nếu không sử dụng các mẫu, sử dụng get_intvà get_charsẽ là điều tốt nhất bạn có thể làm.

Bạn không thể nạp chồng các phương thức dựa trên kiểu trả về. Đặt cược tốt nhất của bạn là tạo hai hàm với cú pháp hơi khác nhau, chẳng hạn như trong đoạn mã thứ hai của bạn.

bạn không thể quá tải một hàm dựa trên kiểu trả về của hàm. bạn có thể bổ sung thừa dựa trên kiểu và số lượng đối số mà hàm này sử dụng.

Tôi đã sử dụng câu trả lời của James Kanze bằng proxy:

https://stackoverflow.com/a/9569120/262458

Tôi muốn tránh sử dụng nhiều static_cast xấu xí trên một khoảng trống *, vì vậy tôi đã làm điều này:

#include <SDL_joystick.h>
#include <SDL_gamecontroller.h>

struct JoyDev {
    private:
        union {
            SDL_GameController* dev_gc = nullptr;
            SDL_Joystick*       dev_js;
        };
    public:
        operator SDL_GameController*&() { return dev_gc; }
        operator SDL_Joystick*&()       { return dev_js; }

        SDL_GameController*& operator=(SDL_GameController* p) { dev_gc = p; return dev_gc; }
        SDL_Joystick*&       operator=(SDL_Joystick* p)       { dev_js = p; return dev_js; }
};

struct JoyState {
    public:
        JoyDev dev;
};

int main(int argc, char** argv)
{
    JoyState js;

    js.dev = SDL_JoystickOpen(0);

    js.dev = SDL_GameControllerOpen(0);

    SDL_GameControllerRumble(js.dev, 0xFFFF, 0xFFFF, 300);

    return 0;
}

Hoạt động hoàn hảo!