タイトルの通りです。

```

    public float speed = 1.0f;
    
```

で、`void update`に

```

    transform.position += transform.forward * speed;
    
```

と書くと常に前進します、それで例えば

```

       if (Input.GetKey(KeyCode.UpArrow))
        {
            speed++;
        }
    
```

みたいに書くとキーを押すたびにspeedが1増えますが、もっと増える数を小さくしたいです。  
0.1増えるようにすることはできますか？
CC BY-SA 3.0
2017-10-18T04:21:47.950
38821
2017-10-20T02:11:38.473
2017-10-18T04:25:34.703
754
25810
question
c#
演算子++を使うと１増えますが、0.1増えるようにすることはできますか？
```

    speed += 0.1f;
    
```

と記述すれば増える値は任意に指定できます。期待される増分はプログラムごとにバラバラですから`++`演算子に複数の意味を持たせるのは混乱の元であり、明示的に記述すべきです。

* * *

suzukisさんがオーバーロード可能とコメントされていますし、shimiteiさんが回答を挙げておられますが、この目的でのオーバーロードの使用はあまりお勧めしません。それは数値型定義するには多数のメンバーを用意する必要があるためです。pgrhoさんがいくつかメンバーを挙げられていますが、それ以外にも四則演算や比較演算なども不足しているため、数値として使用するにはかなり窮屈なはずです。

参考までに書いてみましたが、これで全てなのかの自信もありません。`++`演算子ひとつのためにこれほどまでの型を用意するぐらいであれば、先述の通り`speed
+= 0.1f`をお勧めします。  
（なお、`float`から`Speed`への暗黙の型変換を用意しているのであれば、`Speed`同士の二項演算子だけでもいいかなと思い`Speed ・
float`及び`float ・ Speed`の演算子は省略しました。）

```

    struct Speed : IEquatable<Speed>, IEquatable<float>, IComparable, IComparable<Speed>, IComparable<float>, IFormattable, IConvertible {
        public float Value { get; set; }
    
        public Speed(float data) => Value = data;
        public static implicit operator Speed(float f) => new Speed(f);
        public static implicit operator float(Speed f) => f.Value;
    
        public static Speed operator +(Speed s) => s;
        public static Speed operator -(Speed s) => -s.Value;
        public static Speed operator ++(Speed s) => s + 0.1f;
        public static Speed operator --(Speed s) => s - 0.1f;
    
        public static Speed operator +(Speed s1, Speed s2) => s1.Value + s2.Value;
        public static Speed operator -(Speed s1, Speed s2) => s1.Value - s2.Value;
        public static Speed operator *(Speed s1, Speed s2) => s1.Value * s2.Value;
        public static Speed operator /(Speed s1, Speed s2) => s1.Value / s2.Value;
        public static Speed operator %(Speed s1, Speed s2) => s1.Value % s2.Value;
    
        public static bool operator ==(Speed s1, Speed s2) => s1.Value == s2.Value;
        public static bool operator !=(Speed s1, Speed s2) => s1.Value != s2.Value;
        public static bool operator <(Speed s1, Speed s2) => s1.Value < s2.Value;
        public static bool operator >(Speed s1, Speed s2) => s1.Value > s2.Value;
        public static bool operator <=(Speed s1, Speed s2) => s1.Value <= s2.Value;
        public static bool operator >=(Speed s1, Speed s2) => s1.Value >= s2.Value;
    
        public override int GetHashCode() => Value.GetHashCode();
    
        public override bool Equals(object obj) => obj is Speed s ? Equals(s) : obj is float f ? Equals(f) : false;
        public bool Equals(Speed other) => Equals(other.Value);
        public bool Equals(float other) => Value.Equals(other);
    
        public int CompareTo(object obj) => obj is Speed s ? CompareTo(s) : obj is float f ? CompareTo(f) : throw new ArgumentException();
        public int CompareTo(Speed other) => CompareTo(other.Value);
        public int CompareTo(float other) => Value.CompareTo(other);
    
        public override string ToString() => Value.ToString();
        public string ToString(string format) => Value.ToString(format);
        public string ToString(IFormatProvider formatProvider) => Value.ToString(formatProvider);
        public string ToString(string format, IFormatProvider formatProvider) => Value.ToString(format, formatProvider);
    
        public TypeCode GetTypeCode() => Value.GetTypeCode();
        bool IConvertible.ToBoolean(IFormatProvider provider) => ((IConvertible)Value).ToBoolean(provider);
        char IConvertible.ToChar(IFormatProvider provider) => ((IConvertible)Value).ToChar(provider);
        sbyte IConvertible.ToSByte(IFormatProvider provider) => ((IConvertible)Value).ToSByte(provider);
        byte IConvertible.ToByte(IFormatProvider provider) => ((IConvertible)Value).ToByte(provider);
        short IConvertible.ToInt16(IFormatProvider provider) => ((IConvertible)Value).ToInt16(provider);
        ushort IConvertible.ToUInt16(IFormatProvider provider) => ((IConvertible)Value).ToUInt16(provider);
        int IConvertible.ToInt32(IFormatProvider provider) => ((IConvertible)Value).ToInt32(provider);
        uint IConvertible.ToUInt32(IFormatProvider provider) => ((IConvertible)Value).ToUInt32(provider);
        long IConvertible.ToInt64(IFormatProvider provider) => ((IConvertible)Value).ToInt64(provider);
        ulong IConvertible.ToUInt64(IFormatProvider provider) => ((IConvertible)Value).ToUInt64(provider);
        float IConvertible.ToSingle(IFormatProvider provider) => ((IConvertible)Value).ToSingle(provider);
        double IConvertible.ToDouble(IFormatProvider provider) => ((IConvertible)Value).ToDouble(provider);
        decimal IConvertible.ToDecimal(IFormatProvider provider) => ((IConvertible)Value).ToDecimal(provider);
        DateTime IConvertible.ToDateTime(IFormatProvider provider) => ((IConvertible)Value).ToDateTime(provider);
        object IConvertible.ToType(Type conversionType, IFormatProvider provider) => ((IConvertible)Value).ToType(conversionType, provider);
    }
    
```
CC BY-SA 3.0
2017-10-18T04:25:49.013
38822
2017-10-20T02:11:38.473
2017-10-20T02:11:38.473
4236
4236
38821
answer
演算子 ++ は、「整数変数の値を１増やす演算子」とプログラミング言語C#で定義されていますから、それ以外の機能にすることはできません。

演算子 += を使い、増分を１より少ない値にすれば、実現可能です。

例えば、

```

    public float speed = 1.0f;
    
    void changeSpeed(changeValue) {
       speed += changeValue;
    }
    
```

というようにクラスRobotを定義しておけば

```

    Robot r=new Robot();
    
    r.change(0.1); // ロボットの速度を0.1上げる(加速)
    r.change(-0.05); // ロボットの速度を0.05下げる(減速)
    
```

というような感じで、引数の値によって加速や減速が出来ます。
CC BY-SA 3.0
2017-10-18T04:37:38.263
38823
2017-10-18T04:37:38.263
217
38821
answer
新しくクラスを作成して、++演算子をオーバーロードすると0.1増えるようにもできます。

```

    class Program
    {
        static void Main(string[] args)
        {
            Speed speed = 1.0f;
            Console.WriteLine(speed); // 1
            speed++;
            Console.WriteLine(speed); // 1.1
            float forward = 30.0f;
            Console.WriteLine(forward * speed); // 33
            float position = 100.0f;
            position += forward * speed;
            Console.WriteLine(position); // 133
        }
    }
    
    class Speed
    {
        public float Value { get; set; }
        public Speed(float data) { this.Value = data; }
        // floatから暗黙的に変換可能に。Speed speed = 1.0f;
        public static implicit operator Speed(float f)
        {
            return new Speed(f);
        }
        // floatへ暗黙的に変換可能に。float pos = new Speed(1.0f);
        public static implicit operator float(Speed f)
        {
            return f.Value;
        }
        // ++演算子のオーバーロード。0.1増やす。
        public static Speed operator ++(Speed f)
        {
            Speed tmp = new Speed(f.Value + 0.1f);
            return tmp;
        }
        // *演算子のオーバーロード
        public static Speed operator* (Speed s, float f)
        {
            return new Speed(s.Value * f);
        }
        public static Speed operator *(float f, Speed s)
        {
            return new Speed(s.Value * f);
        }
        // +演算子のオーバーロード
        public static Speed operator +(Speed s, float f)
        {
            return new Speed(s.Value + f);
        }
        public static Speed operator +(float f, Speed s)
        {
            return new Speed(s.Value + f);
        }
        public override string ToString() { return this.Value.ToString(); }
    }
    
```
CC BY-SA 3.0
2017-10-19T07:27:28.230
38860
2017-10-19T07:27:28.230
3655
38821
answer