几种常见语言的基本语法对比：数字处理

c++: 在不涉及到内存管理下，总体感觉很爽，又因为是unix自带编译器。非常爽。唯一一点就是枚举类型中的枚举值是好像是全局变量名。搞得枚举值命名很长。 语法基本没有太多停顿 ，这个例子中所涉及的语法部分和c#,java 很像。

它的模板确实非常爽。爽到没朋友。

c++就是这样一种语言，用其他语言会觉得，xx真弱，还是c++牛。等你用c++开发。就会说：我去。这是个毛啊。任何语言都比你方便。

#include <iostream>
using namespace std;
enum enum_op
{
    enum_op_add,
    enum_op_minus,
    enum_op_time,
    enum_op_divide
};


int NumberCaculate(int a,int b,enum_op op)
{
    int ret=0;
    switch (op)
    {
        case enum_op_add:
        {
            ret=a+b;
            break;
        }
        case enum_op_minus:
        {
            ret=a-b;
            break;
        }
        case enum_op_time:
        {
            ret=a*b;
            break;
        }
        case enum_op_divide:
        {
            ret=a/b;
        }

    }
    return ret;
}

template<typename T>
T NumberCaculateFull(T a,T b,enum_op op)
{
    T ret=0;
    switch (op)
    {
        case enum_op_add:
        {
            ret=a+b;
            break;
        }
        case enum_op_minus:
        {
            ret=a-b;
            break;
        }
        case enum_op_time:
        {
            ret=a*b;
            break;
        }
        case enum_op_divide:
        {
            ret=a/b;
        }

    }
    return ret;
}


int main()
{
    cout<<"hello,world"<<endl;
    cout<<NumberCaculate(1,3,enum_op_minus)<<endl;
    cout<<NumberCaculateFull<float>(1.2,3.3,enum_op_time)<<endl;
}

object-c:因为有xcode这个地球第二的编辑器（vs第一），所以写代码还是很爽。 和c++不同的是  对于 枚举中 参数的定义  enum enum_op op， 重要的是不完全支持泛型 。这个就差距了。

//
//  main.m
//  HIWorld
//
//  Created by linson on 2018/8/19.
//  Copyright © 2018年 linson. All rights reserved.
//

#import <Foundation/Foundation.h>

enum enum_op
{
    enum_op_add,
    enum_op_minus,
    enum_op_time,
    enum_op_divide
};

int NumberCaculate(int a,int b,enum enum_op op);


int main(int argc, const char * argv[])
{
    @autoreleasepool
    {
        NSLog(@"Hello, World!");
        
        int a=2;
        int b=4;
        NSLog(@"%i", NumberCaculate(a, b, enum_op_add));
        NSLog(@"%i", NumberCaculate(a, b, enum_op_minus));
    }
    return 0;
}


int NumberCaculate(int a,int b,enum enum_op op)
{
    int ret=0;
    switch (op)
    {
        case enum_op_add:
        {
            ret=a+b;
            break;
        }
        case enum_op_minus:
        {
            ret=a-b;
            break;
        }
        case enum_op_time:
        {
            ret=a*b;
            break;
        }
        case enum_op_divide:
        {
            ret=a/b;
        }
            
    }
    return ret;
}

 、

c#:语言和ide。都是一流的手感和观感。枚举值是用枚举变量加 .号访问，非常舒服，毕竟是有虚拟机的语言。就是高级。

但是做完这个例子，才发现 为什么c++的模板是预编译阶段执行的。更方便使用，直接让模板变成一个代码生成器。  让编译器去检查错误。而不是像c# 是运行期 的。需要自己写很多异常处理。

写c++的时间比较短。大概1年多点。现在根本不想用它。确实非常难用。但是发现很多设计，确实是厉害。  就是因为太厉害。必须要规范，圈养，阉割，才能使用。  所以无法快速开发。

类型判断关键字.  c# :is  .java: instanceof  .细微处.java 更好.   is 含义太广,是什么鬼.  instanceof .直译中心思想.简洁.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace helloworld
{
    class Program
    {
        static void Main(string[] args)
        {
            System.Console.WriteLine("helloworld");

            int a=2;
            int b=4;

            foreach(enum_op myop in Enum.GetValues(typeof(enum_op)))
            {
                System.Console.WriteLine("ret:" + NumberCaculate(a, b, myop));
            }

            foreach (enum_op myop in Enum.GetValues(typeof(enum_op)))
            {
                System.Console.WriteLine("ret:" + NumberCaculateFull<decimal>(2, 3, myop));
            }

            System.Console.Read();
        }


        enum enum_op
        {
            add,
            minus,
            time,
            divide
        };


        static T NumberCaculateFull<T>(T a,T b,enum_op op)
        {
            if (a is int)
            {

                int ret = 0;
                int inta = Convert.ToInt32(a);
                int intb = Convert.ToInt32(b);

                switch (op)
                {
                    case enum_op.add:
                        {
                            ret = inta + intb;
                            break;
                        }
                    case enum_op.minus:
                        {
                            ret = inta - intb;
                            break;
                        }
                    case enum_op.time:
                        {
                            ret = inta * intb;
                            break;
                        }
                    case enum_op.divide:
                        {
                            ret = inta / intb;
                            break;
                        }

                }
                return (T)Convert.ChangeType(ret, typeof(T));
            }
            else if(a is decimal)
            {
                decimal ret = 0;
                decimal inta = Convert.ToDecimal(a);
                decimal intb = Convert.ToDecimal(b);

                switch (op)
                {
                    case enum_op.add:
                        {
                            ret = inta + intb;
                            break;
                        }
                    case enum_op.minus:
                        {
                            ret = inta - intb;
                            break;
                        }
                    case enum_op.time:
                        {
                            ret = inta * intb;
                            break;
                        }
                    case enum_op.divide:
                        {
                            ret = inta / intb;
                            break;
                        }

                }
                return (T)Convert.ChangeType(ret, typeof(T));
            }
            else
            {
                return (T)Convert.ChangeType("0", typeof(T));
            }
        }

        static int NumberCaculate(int a, int b, enum_op op)
        {
            int ret = 0;
            switch (op)
            {
                case enum_op.add:
                    {
                        ret = a + b;
                        break;
                    }
                case enum_op.minus:
                    {
                        ret = a - b;
                        break;
                    }
                case enum_op.time:
                    {
                        ret = a * b;
                        break;
                    }
                case enum_op.divide:
                    {
                        ret = a / b;
                        break;
                    }
            }
            return ret;
        }
    }
}

java ,基本和 c# 一样. 枚举用.号访问. enum 结束符号 加不加;都可以编译   范型是运行时范型.

但是 .static 居然还要加public. 都静态了,还需要特定指名public ,特别!  default 是不能外部访问的.这个只能是.摸头杀.

而且范型方法比c#多提供一个 可选的 基类的选择选项.  好像作用不大.如果需要提供基类.我直接用 多态了.还需要范型作什么.范型的目的,就是处理 基类不是一类的东西.

总体来说, 比c#,少了一个更好的ide.  对vjava还不熟悉.  总体很好,有些 强硬的思想,反而使编程规范化.而  c#走的太灵活了.

ide真的很重要. 说语言才是根本的.ide不重要的. 都是在用比较好的工具了, 没有差到哪里去.     去写写c++.不同平台,不同工具,  界面框架也不统一.各种纠结. 郁闷.

package com.Tea;


public class HelloWorld
{
    enum enum_op
    {
        add,
        minus,
        time,
        divide
    };
    
    public static void main(String[] args)
    {
        System.out.println("hello,world.");
        enum_op[] allOps=enum_op.values();
        
        int a=2,b=3;
        for(int i=0;i<allOps.length;i++)
        {
            System.out.println(NumberCaculate(a, b, allOps[i]));
        }
        
        Integer c=3;
        Integer d=4;
        
        Number retInteger=NumberCaculateFull(c, d, enum_op.add);
        System.out.println(retInteger);
    }
    
    
     static <T extends Number> Number NumberCaculateFull(T a, T b,enum_op op) 
     {
         if(a instanceof  Integer)
         {
             return (Number)1;
         }
         else if(a instanceof Float)
         {
             return (Number)2;
         }
         else 
         {
             return (Number)4;
         }
    }
    
    
    static int NumberCaculate(int a, int b, enum_op op)
        {
            int ret = 0;
            switch (op)
            {
                case add:
                    {
                        ret = a + b;
                        break;
                    }
                case minus:
                    {
                        ret = a - b;
                        break;
                    }
                case time:
                    {
                        ret = a * b;
                        break;
                    }
                case divide:
                    {
                        ret = a / b;
                        break;
                    }
            }
            return ret;
        }
    
}

脚本 语言 lua

脚本 语言 只 了解 js和 lua。lua非常简洁 ，无任何官方扩展api。只有自带的简单语法和解释器。

因为是脚本语言 。所以 执行顺序 是 从上往下解释执行的。没有编译工具去整体编译为机器指令。

解释器 的话。感觉所以脚本语言很灵活，会有一些小惊喜。 可变参数列表。 .. 来代替+ .

 非常简洁 ，配合c,c++  完成一些方法还是非常好的。

print("hi,i am lua")

function addnumber2(...)--可变参数
    local allnumber={...}
    local ret=0
    for i=1,#(allnumber) do
        ret=ret+allnumber[i]
    end
    return ret;
end

function addnumber(a,b)
    local ret=0
    
    return a+b;
end

print(addnumber2(1,2,3,4,5,6,7))
print("2+4=" .. addnumber(2,4))