Перегрузка функции по типу возврата?

На таком языке, как бы вы разрешили следующее:

f(g(x))

если у f были перегрузки void f(int) и void f(string), а у g были перегрузки int g(int) и string g(int)? Вам понадобится какой-нибудь устранитель неоднозначности.

Я думаю, что в ситуациях, когда вам это может понадобиться, лучше выбрать новое имя для функции.

Чтобы украсть специфичный для C++ ответ на другой очень похожий вопрос (обман?):

Типы возвращаемых функций не участвуют в разрешении перегрузки просто потому, что Страуструп (я предполагаю, что с вводом от других архитекторов C++) хотел, чтобы разрешение перегрузки было «контекстно-независимым». См. Раздел 7.4.1 - «Перегрузка и возвращаемый тип» в «Языке программирования C++, третье издание».

The reason is to keep resolution for an individual operator or function call context-independent.

Они хотели, чтобы это основывалось только на том, как была вызвана перегрузка, а не на том, как был использован результат (если он вообще использовался). Действительно, многие функции вызываются без использования результата, иначе результат будет использоваться как часть более крупного выражения. Один фактор, который, я уверен, вступил в игру, когда они решили, что это было то, что если бы тип возвращаемого значения был частью разрешения, было бы много вызовов перегруженных функций, которые нужно было бы разрешить с помощью сложных правил или чтобы компилятор бросил ошибка в том, что звонок был неоднозначным.

И, черт его знает, разрешение перегрузки C++ достаточно сложно в существующем виде ...

Если функции были перегружены возвращаемым типом, и у вас были эти две перегрузки

int func();
string func();

компилятор не может определить, какую из этих двух функций вызывать, увидев такой вызов

void main() 
{
    func();
}

По этой причине разработчики языка часто запрещают перегрузку возвращаемого значения.

Однако некоторые языки (например, MSIL) делать допускают перегрузку по типу возвращаемого значения. Конечно, они тоже сталкиваются с вышеуказанной трудностью, но у них есть обходные пути, для которых вам придется обращаться к их документации.

Большинство статических языков теперь также поддерживают дженерики, которые решат вашу проблему. Как указывалось ранее, без различия параметров невозможно узнать, какой из них вызывать. Так что, если вы хотите сделать это, просто используйте дженерики и закончите.

В haskell это возможно, даже если у него нет перегрузки функций. Haskell использует классы типов. В программе вы могли видеть:

class Example a where
    example :: Integer -> a

instance Example Integer where  -- example is now implemented for Integer
    example :: Integer -> Integer
    example i = i * 10

Сама по себе перегрузка функций не так популярна. В основном языки, которые я видел с ним, - это C++, возможно, java и / или C#. Во всех динамических языках это сокращение для:

define example:i
  ↑i type route:
    Integer = [↑i & 0xff]
    String = [↑i upper]


def example(i):
    if isinstance(i, int):
        return i & 0xff
    elif isinstance(i, str):
        return i.upper()

Поэтому особого смысла в этом нет. Большинство людей не интересуются, может ли язык помочь вам отбросить одну строчку в зависимости от того, где вы его используете.

Сопоставление с образцом в чем-то похоже на перегрузку функций, и я думаю, иногда работает аналогично. Однако это нечасто, потому что это полезно только для нескольких программ и сложно реализовать на большинстве языков.

Вы видите, что существует бесконечно много других более простых в реализации функций, которые можно реализовать на языке, в том числе:

• Динамический набор текста
• Внутренняя поддержка списков, словарей и строк Юникода
• Оптимизация (JIT, определение типа, компиляция)
• Интегрированные инструменты развертывания
• Поддержка библиотеки
• Поддержка сообщества и места сбора
• Богатые стандартные библиотеки
• Хороший синтаксис
• Читать цикл печати eval
• Поддержка рефлексивного программирования

Хорошие ответы! В частности, ответ А.Рекса очень подробен и поучителен. Как он указывает, C++ делает учитывает пользовательские операторы преобразования типов при компиляции lhs = func();(где func на самом деле имя структуры). Мой обходной путь немного другой - не лучше, просто другой (хотя он основан на той же базовой идее).

Тогда как мне нужно было написать в розыске ...

template <typename T> inline T func() { abort(); return T(); }

template <> inline int func()
{ <<special code for int>> }

template <> inline double func()
{ <<special code for double>> }

.. etc, then ..

int x = func(); // ambiguous!
int x = func<int>(); // *also* ambiguous!?  you're just being difficult, g++!

В итоге я получил решение, в котором используется параметризованная структура (с T = типом возврата):

template <typename T>
struct func
{
    operator T()
    { abort(); return T(); } 
};

// explicit specializations for supported types
// (any code that includes this header can add more!)

template <> inline
func<int>::operator int()
{ <<special code for int>> }

template <> inline
func<double>::operator double()
{ <<special code for double>> }

.. etc, then ..

int x = func<int>(); // this is OK!
double d = func<double>(); // also OK :)

Преимущество этого решения заключается в том, что любой код, включающий эти определения шаблонов, может добавлять дополнительные специализации для большего количества типов. Также вы можете выполнить частичную специализацию структуры по мере необходимости. Например, если вам нужна особая обработка типов указателей:

template <typename T>
struct func<T*>
{
    operator T*()
    { <<special handling for T*>> } 
};

Как минус, вы не можете записать int x = func(); с моим решением. Вы должны написать int x = func<int>();. Вы должны явно указать тип возвращаемого значения, а не просить компилятор разобраться в этом, глядя на операторы преобразования типов. Я бы сказал, что "мое" решение и оба А.Рекса входят в Парето-оптимальный фронт способов решения этой дилеммы C++ :)

Как уже было показано, неоднозначные вызовы функции, которая отличается только типом возвращаемого значения, вносит неоднозначность. Двусмысленность порождает дефектный код. Следует избегать дефектного кода.

Сложность, вызванная попыткой двусмысленности, показывает, что это не лучший способ взлома. Помимо интеллектуального упражнения - почему бы не использовать процедуры с эталонными параметрами.

procedure(reference string){};
procedure(reference int){};
string blah;
procedure(blah)

с этой функцией перегрузки нетрудно справиться, если посмотреть на нее немного по-другому. рассмотрим следующее,

public Integer | String f(int choice){
if (choice==1){
return new string();
}else{
return new Integer();
}}

если язык действительно вернул перегрузку, это допустило бы перегрузку параметров, но не дублирование. это решило бы проблему:

main (){
f(x)
}

потому что есть только один f (int choice) на выбор.

В .NET иногда мы используем один параметр, чтобы указать желаемый результат общего результата, а затем выполняем преобразование, чтобы получить то, что мы ожидаем.

C#

public enum FooReturnType{
        IntType,
        StringType,
        WeaType
    }

    class Wea { 
        public override string ToString()
        {
            return "Wea class";
        }
    }

    public static object Foo(FooReturnType type){
        object result = null;
        if (type == FooReturnType.IntType) 
        {
            /*Int related actions*/
            result = 1;
        }
        else if (type == FooReturnType.StringType)
        {
            /*String related actions*/
            result = "Some important text";
        }
        else if (type == FooReturnType.WeaType)
        {
            /*Wea related actions*/
            result = new Wea();
        }
        return result;
    }

    static void Main(string[] args)
    {
        Console.WriteLine("Expecting Int from Foo: " + Foo(FooReturnType.IntType));
        Console.WriteLine("Expecting String from Foo: " + Foo(FooReturnType.StringType));
        Console.WriteLine("Expecting Wea from Foo: " + Foo(FooReturnType.WeaType));
        Console.Read();
    }

Возможно, этот пример тоже может помочь:

C++

    #include <iostream>

enum class FooReturnType{ //Only C++11
    IntType,
    StringType,
    WeaType
}_FooReturnType;

class Wea{
public:
    const char* ToString(){
        return "Wea class";
    }
};

void* Foo(FooReturnType type){
    void* result = 0;
    if (type == FooReturnType::IntType) //Only C++11
    {
        /*Int related actions*/
        result = (void*)1;
    }
    else if (type == FooReturnType::StringType) //Only C++11
    {
        /*String related actions*/
        result = (void*)"Some important text";
    }
    else if (type == FooReturnType::WeaType) //Only C++11
    {
        /*Wea related actions*/
        result = (void*)new Wea();
    }
    return result;
}

int main(int argc, char* argv[])
{
    int intReturn = (int)Foo(FooReturnType::IntType);
    const char* stringReturn = (const char*)Foo(FooReturnType::StringType);
    Wea *someWea = static_cast<Wea*>(Foo(FooReturnType::WeaType));
    std::cout << "Expecting Int from Foo: " << intReturn << std::endl;
    std::cout << "Expecting String from Foo: " << stringReturn << std::endl;
    std::cout << "Expecting Wea from Foo: " << someWea->ToString() << std::endl;
    delete someWea; // Don't leak oil!
    return 0;
}

Для записи Октава допускает различный результат в зависимости от того, является ли возвращаемый элемент скалярным по сравнению с массивом.

x = min ([1, 3, 0, 2, 0])
   ⇒  x = 0

[x, ix] = min ([1, 3, 0, 2, 0])
   ⇒  x = 0
      ix = 3 (item index)

См. Также Разложение по сингулярным значениям.

Это немного отличается от C++; Я не знаю, будет ли это считаться перегрузкой напрямую по возвращаемому типу. Это скорее специализация шаблонов, которая действует как.

util.h

#ifndef UTIL_H
#define UTIL_H

#include <string>
#include <sstream>
#include <algorithm>

class util {
public: 
    static int      convertToInt( const std::string& str );
    static unsigned convertToUnsigned( const std::string& str );
    static float    convertToFloat( const std::string& str );
    static double   convertToDouble( const std::string& str );

private:
    util();
    util( const util& c );
    util& operator=( const util& c );

    template<typename T>
    static bool stringToValue( const std::string& str, T* pVal, unsigned numValues );

    template<typename T>
    static T getValue( const std::string& str, std::size_t& remainder );
};

#include "util.inl"

#endif UTIL_H

util.inl

template<typename T>
static bool util::stringToValue( const std::string& str, T* pValue, unsigned numValues ) {
    int numCommas = std::count(str.begin(), str.end(), ',');
    if (numCommas != numValues - 1) {
        return false;
    }

    std::size_t remainder;
    pValue[0] = getValue<T>(str, remainder);

    if (numValues == 1) {
        if (str.size() != remainder) {
            return false;
        }
    }
    else {
        std::size_t offset = remainder;
        if (str.at(offset) != ',') {
            return false;
        }

        unsigned lastIdx = numValues - 1;
        for (unsigned u = 1; u < numValues; ++u) {
            pValue[u] = getValue<T>(str.substr(++offset), remainder);
            offset += remainder;
            if ((u < lastIdx && str.at(offset) != ',') ||
                (u == lastIdx && offset != str.size()))
            {
                return false;
            }
        }
    }
    return true;    
}

util.cpp

#include "util.h"

template<>
int util::getValue( const std::string& str, std::size_t& remainder ) {
    return std::stoi( str, &remainder );
} 

template<>
unsigned util::getValue( const std::string& str, std::size_t& remainder ) {
    return std::stoul( str, &remainder );
}

template<>
float util::getValue( const std::string& str, std::size_t& remainder ) {
    return std::stof( str, &remainder );
}     

template<>   
double util::getValue( const std::string& str, std::size_t& remainder ) {
    return std::stod( str, &remainder );
}

int util::convertToInt( const std::string& str ) {
    int i = 0;
    if ( !stringToValue( str, &i, 1 ) ) {
        std::ostringstream strStream;
        strStream << __FUNCTION__ << " Bad conversion of [" << str << "] to int";
        throw strStream.str();
    }
    return i;
}

unsigned util::convertToUnsigned( const std::string& str ) {
    unsigned u = 0;
    if ( !stringToValue( str, &u, 1 ) ) {
        std::ostringstream strStream;
        strStream << __FUNCTION__ << " Bad conversion of [" << str << "] to unsigned";
        throw strStream.str();
    }
    return u;
}     

float util::convertToFloat(const std::string& str) {
    float f = 0;
    if (!stringToValue(str, &f, 1)) {
        std::ostringstream strStream;
        strStream << __FUNCTION__ << " Bad conversion of [" << str << "] to float";
        throw strStream.str();
    }
    return f;
}

double util::convertToDouble(const std::string& str) {
    float d = 0;
    if (!stringToValue(str, &d, 1)) {
        std::ostringstream strStream;
        strStream << __FUNCTION__ << " Bad conversion of [" << str << "] to double";
        throw strStream.str();
    }
    return d;
}

В этом примере не совсем точно используется разрешение перегрузки функции по типу возвращаемого значения, однако этот необъектный класс C++ использует специализацию шаблона для имитации разрешения перегрузки функции по типу возвращаемого значения с помощью частного статического метода.

Каждая из функций convertToType вызывает шаблон функции stringToValue(), и если вы посмотрите на детали реализации или алгоритм этого шаблона функции, он вызывает getValue<T>( param, param ) и возвращает обратно тип T и сохраняет его в T*, который передается в функцию stringToValue(). шаблон как один из его параметров.

Кроме чего-то вроде этого; В C++ на самом деле нет механизма для разрешения перегрузки функций по типу возвращаемого значения. Могут существовать другие конструкции или механизмы, о которых я не знаю, которые могут имитировать разрешение по типу возвращаемого значения.

Я думаю, что это пробел в современном определении C++… почему?

int func();
double func();

// example 1. → defined
int i = func();

// example 2. → defined
double d = func();

// example 3. → NOT defined. error
void main() 
{
    func();
}

Почему компилятор C++ не может выдать ошибку в примере «3» и принять код в примере "1 + 2" ??

если вы хотите перегрузить методы с разными типами возврата, просто добавьте фиктивный параметр со значением по умолчанию, чтобы разрешить выполнение перегрузки, но не забывайте, что тип параметра должен быть другим, поэтому логика перегрузки работает, например, на delphi:

type    
    myclass = class
    public
      function Funct1(dummy: string = EmptyStr): String; overload;
      function Funct1(dummy: Integer = -1): Integer; overload;
    end;

используйте это так

procedure tester;
var yourobject : myclass;
  iValue: integer;
  sValue: string;
begin
  yourobject:= myclass.create;
  iValue:= yourobject.Funct1(); //this will call the func with integer result
  sValue:= yourobject.Funct1(); //this will call the func with string result
end;