Что делает унарное плюс оператор, делают?

EDIT Переписала полностью, потому что я был waaaayyy прочь в моем исходном ответе.

Это должно позволить Вам обрабатывать явное объявление своего типа как положительное значение (я думаю в главным образом нематематических операциях). Кажется, что отрицание было бы более полезным, но я предполагаю, вот пример того, где это могло бы иметь значение:

public struct Acceleration
{
    private readonly decimal rate;
    private readonly Vector vector;

    public Acceleration(decimal rate, Vector vector)
    {
        this.vector = vector;
        this.rate = rate;
    }

    public static Acceleration operator +(Acceleration other)
    {
        if (other.Vector.Z >= 0)
        {
            return other;
        }
        return new Acceleration(other.Rate, new Vector(other.vector.X, other.Vector.Y, -other.vector.Z));
    }

    public static Acceleration operator -(Acceleration other)
    {
        if (other.Vector.Z <= 0)
        {
            return other;
        }
        return new Acceleration(other.Rate, new Vector(other.vector.X, other.Vector.Y, -other.vector.Z));
    }

    public decimal Rate
    {
        get { return rate; }
    }

    public Vector Vector
    {
        get { return vector; }
    }
}

Я предполагаю, что Вы могли использовать его, чтобы всегда сделать число положительным. Просто перегрузите унарное + оператор, чтобы быть брюшным прессом. Едва ли стоящий путания Ваших поддерживающих разработчиков, если Вы действительно просто не хотите запутать свой код. Затем это работало бы приятно.

Я видел, что это раньше для ясности, подчеркивало положительное значение в отличие от отрицательной величины:

shift(+1);
shift(-1);

Но это - довольно слабое использование. Ответ определенно перегружается.

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

• Повышение: оператор new_type + (old_type)
• Преобразование: new_type (old_type)
• Приведение: оператор (new_type) (old_type) )
• Принуждение: оператор new_type = (old_type)

Конечно, это из моей интерпретации заметки в одном из руководств Microsoft (действительно старых) по c / c ++, которые я прочитал около 15 лет назад, поэтому возьми это с зерном соли.

Унарный плюс присутствовал в C, где он абсолютно ничего не делал (во многом как ключевое слово auto ). Чтобы этого не было, Страуструпу пришлось бы ввести безвозмездную несовместимость с C.

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

Так, это ничего не значит. Его можно использовать как декорацию, чтобы сделать вещи более симметричными, например, используя +1,5 в качестве противоположности -1,5. В C ++ он может быть перегружен, но это будет сбивать с толку, если operator + () что-нибудь сделает. Помните стандартное правило: при перегрузке арифметических операторов делайте то же самое, что и int .

Если вы ищете причину, почему это ' s там, найдите что-нибудь о ранней истории C. Я подозреваю, что не было веской причины, так как C не был действительно разработан. Рассмотрим бесполезное ключевое слово auto (предположительно в отличие от static , которое теперь перерабатывается в C ++ 0x), и ключевое слово entry , которое никогда ничего не делало ( и позже опущен в C90). Есть известное электронное письмо, в котором Ритчи или Керниган говорят, что, когда они поняли, что у приоритета оператора возникли проблемы, уже было три установки с тысячами строк кода, которые они не хотели нарушать.

и ключевое слово entry , которое ничего не делало (а позже опущено в C90). Есть известное электронное письмо, в котором Ритчи или Керниган говорят, что, когда они поняли, что у приоритета оператора возникли проблемы, уже было три установки с тысячами строк кода, которые они не хотели нарушать.

и ключевое слово entry , которое ничего не делало (а позже опущено в C90). Есть известное электронное письмо, в котором Ритчи или Керниган говорят, что, когда они поняли, что у приоритета оператора возникли проблемы, уже было три установки с тысячами строк кода, которые они не хотели нарушать.

Не много. Общий аргумент в пользу перегрузки operator + () заключается в том, что для перегрузки operator - () определенно существует реальный мир, и было бы очень странно (или асимметрично), если вы разрешите перегрузку operator - () , но не operator + () .

Я считаю, что сначала прочитал этот аргумент из Stroustrop, но я не у меня есть мои книги, чтобы проверить это. Я могу ошибаться.

просто это раньше убеждало, какие числа положительны

, например;

int a=10;
System.out.println(+x);// prints 10(that means,that number 10 multiply by +1,{10*+1})

//if we use unary minus

int a=10;
System.out.println(-x);//prints -10(that means,that number 10 multiply by +1,{10*-1})