Java是2+；比C快几倍（作为C+；+；）的子集）

下面的代码是一个非常低效的乘法算法。它是为了测试而写的。我相信我用不同的语言编写了相同的代码

下面是运行代码的结果

OS: Windows 7
language: C (as a subset of C++)

compiler: Visual C++
optimization option: /Ox /Oi /Ot /Oy /GL
running time (seconds): 40 +/- 1

compiler: MinGW/gcc
optimization option: -O3 march=native
running time (seconds): 81 +/- 1

compiler: MinGW/g++
optimization option: -O3 march=native
running time (seconds): 82 +/- 1

language: Java

compiler: Oracle JDK
VM: Oracle JVM
running time (seconds): 18 +/- 1

我相信我在我的C代码中做了一些可怕的事情，完全优化的编译器无法以任何方式进行优化。如果有什么大问题，请告诉我。我正在计划一个项目，其中有一部分涉及大量的计算。我决定用C语言编写这个核心计算部分，但有了这样的结果，我宁愿用Java编写所有的东西；它更容易，甚至更快？我仍然相信C，所以如果我的代码中有任何问题，请告诉我。我所期望的是Java版本应该慢1.5倍或更慢，但不知何故它比C

测试c

#包括
#包括
#包括
#包括
typedef有符号字符字节；
typedef结构数组
{
字节*数据；
内伦；
}
阵列；
无效新数组（数组*a，整数len）
{
a->data=（字节*）malloc（len*sizeof（字节））；
a->len=len；
}
void del_数组（数组*a）
{
免费（a->数据）；
}
类型定义结构
{
数组数；
内伦；
}
BUI[1]；
作废新建筑（建筑b、常量字符*s）
{
int len=strlen（s）；
b->len=len；
新的数组（&b->num，len）；
对于（int i=0；inum.data[i]=s[len-i-1]-'0'；
}
}
德鲁街无效（b街）
{
del_数组（&b->num）；
}
内部建筑cmp（建筑a、建筑b）
{
如果（a->len>b->len）
{
返回1；
}
如果（a->lenlen）
{
返回-1；
}
对于（int i=a->len-1；i>=0；--i）
{
如果（a->num.data[i]>b->num.data[i]）
{
返回1；
}
如果（a->num.data[i]num.data[i]）
{
返回-1；
}
}
返回0；
}
#定义最大值（A，B）（A>B？A:B）
无效建筑添加（建筑、建筑a、建筑b）
{
数组c；
新的_数组（&c，MAX（a->len，b->len）+1）；
memset（c.data，0，c.len）；
memcpy（c.data，a->num.data，a->len）；
对于（int i=0；ilen；++i）
{
c、 数据[i]+=b->num.data[i]；
}
对于（int i=0；i=10）
{
c、 数据[i+1]+=c.data[i]/10；
c、 数据[i]=10；
}
}
del_数组（&r->num）；
r->num=c；
r->len=c.len；
对于（int i=r->num.len-1；r->num.data[i--]==0；--r->len）；
}
无效建筑（建筑、建筑a、建筑b）
{
别克；
新_BUI（c，“0”）；
{
别克一号；
新(一,一);；
别伊；
新_BUI（i，“0”）；
对于（；BUI_cmp（i，a）<0；BUI_add（i，i，1））
{
添加（c、c、b）；
}
德鲁比（一）；
德鲁比（一）；
}
del_数组（&r->num）；
r->num=c->num；
r->len=c->len；
}
无效的BUI_打印（BUI b）
{
对于（inti=b->len-1；i>=0；--i）
{
putchar（b->num.data[i]+'0'）；
}
}
内部主（空）
{
布伊阿；
新(a,123456789);；
b区；
新(b,987654321);；
BUI_print（a）；
FPUT（“x”，标准件）；
布尤印刷（b）；
FPUT（“=”，标准输出）；
开始时间=时钟（）；
布伊穆尔（a、a、b）；
时间=时钟（）；
BUI_print（a）；
德鲁比（a）；
德鲁比（b）；
printf（“\n延迟时间：%.3f\n”，（双精度）（结束时间-开始时间）/每秒时钟数）；
printf（“%d%d\n”，a->num.len，a->len）；
返回0；
}

Test.java

import java.util.*；
BUI级
{
字节[]num；
内伦；
BUI（字符串s）
{
len=s.长度（）；
num=新字节[len]；
对于（int i=0；ib.len）
{
返回1；
}
if（len=0；--i）
{
if（num[i]>b.num[i]）
{
返回1；
}
if（num[i]=10）
{
c[i+1]+=c[i]/10；
c[i]=10；
}
}
num=c；
len=c.长度；
for（int i=num.length-1；num[i-->==0；--len）；
}
无效mul（建筑a、建筑b）
{
BUI c=新的BUI（“0”）；
{
BUI one=新的BUI（“1”）；
BUI i=新的BUI（“0”）；
对于（；i.cmp（a）<0；i.add（i，1））
{
c、 添加（c，b）；
}
}
num=c.num；
len=c.len；
}
作废打印（）
{
对于（int i=len-1；i>=0；--i）
{
系统输出打印（num[i]）；
}
}
}
公开课考试
{
公共静态void main（字符串[]args）
{
BUI a=新的BUI（“123456789”）；
BUI b=新的BUI（“987654321”）；
a、 打印（）；
系统输出打印（“x”）；
b、 打印（）；
系统输出打印（“=”）；
长启动时间=System.currentTimeMillis（）；
a、 mul（a，b）；
long end_time=System.currentTimeMillis（）；
a、 打印（）；
System.out.printf（“\n失效时间：%.3f\n”，（结束时间-开始时间）/1000.0）；
}
}

“语言：C（作为C++的子集）”

只是没有

C不是C++的子集。它们有共同的语法（大多数是C），但大多数运行时检查是不同的（取决于编译器），解释代码的方式是不同的（在少数情况下）和大多数代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

typedef signed char byte;

typedef struct _Array
{
    byte *data;
    int len;
}
Array;

void new_Array(Array *a, int len)
{
    a->data = (byte *)malloc(len * sizeof(byte));
    a->len = len;
}

void del_Array(Array *a)
{
    free(a->data);
}

typedef struct _BUI
{
    Array num;
    int len;
}
BUI[1];

void new_BUI(BUI b, const char *s)
{
    int len = strlen(s);
    b->len = len;
    new_Array(&b->num, len);
    for (int i = 0; i < len; ++i)
    {
        b->num.data[i] = s[len - i - 1] - '0';
    }
}

void del_BUI(BUI b)
{
    del_Array(&b->num);
}

int BUI_cmp(const BUI a, const BUI b)
{
    if (a->len > b->len)
    {
        return 1;
    }
    if (a->len < b->len)
    {
        return -1;
    }
    for (int i = a->len - 1; i >= 0; --i)
    {
        if (a->num.data[i] > b->num.data[i])
        {
            return 1;
        }
        if (a->num.data[i] < b->num.data[i])
        {
            return -1;
        }
    }
    return 0;
}

#define MAX(A, B) (A > B ? A : B)

void BUI_add(BUI r, const BUI a, const BUI b)
{
    Array c;
    new_Array(&c, MAX(a->len, b->len) + 1);
    memset(c.data, 0, c.len);
    memcpy(c.data, a->num.data, a->len);
    for (int i = 0; i < b->len; ++i)
    {
        c.data[i] += b->num.data[i];
    }
    for (int i = 0; i < c.len - 1; ++i)
    {
        if (c.data[i] >= 10)
        {
            c.data[i + 1] += c.data[i] / 10;
            c.data[i] %= 10;
        }
    }
    del_Array(&r->num);
    r->num = c;
    r->len = c.len;
    for (int i = r->num.len - 1; r->num.data[i--] == 0; --r->len);
}

void BUI_mul(BUI r, const BUI a, const BUI b)
{
    BUI c;
    new_BUI(c, "0");
    {
        BUI one;
        new_BUI(one, "1");
        BUI i;
        new_BUI(i, "0");
        for (; BUI_cmp(i, a) < 0; BUI_add(i, i, one))
        {
            BUI_add(c, c, b);
        }
        del_BUI(one);
        del_BUI(i);
    }
    del_Array(&r->num);
    r->num = c->num;
    r->len = c->len;
}

void BUI_print(BUI b)
{
    for (int i = b->len - 1; i >= 0; --i)
    {
        putchar(b->num.data[i] + '0');
    }
}

int main(void)
{
    BUI a;
    new_BUI(a, "123456789");
    BUI b;
    new_BUI(b, "987654321");
    BUI_print(a);
    fputs(" x ", stdout);
    BUI_print(b);
    fputs(" = ", stdout);
    time_t start_time = clock();
    BUI_mul(a, a, b);
    time_t end_time = clock();
    BUI_print(a);
    del_BUI(a);
    del_BUI(b);
    printf("\nelapsed time: %.3f\n", (double)(end_time - start_time) / CLOCKS_PER_SEC);
    printf("%d %d\n", a->num.len, a->len);
    return 0;
}

import java.util.*;

class BUI
{
    byte[] num;
    int len;

    BUI(String s)
    {
        len = s.length();
        num = new byte[len];
        for (int i = 0; i < len; ++i)
        {
            num[i] = (byte)Character.getNumericValue(s.charAt(len - i - 1));
        }
    }

    int cmp(BUI b)
    {
        if (len > b.len)
        {
            return 1;
        }
        if (len < b.len)
        {
            return -1;
        }
        for (int i = len - 1; i >= 0; --i)
        {
            if (num[i] > b.num[i])
            {
                return 1;
            }
            if (num[i] < b.num[i])
            {
                return -1;
            }
        }
        return 0;
    }

    void add(BUI a, BUI b)
    {
        byte[] c = new byte[Math.max(a.len, b.len) + 1];
        Arrays.fill(c, (byte)0);
        System.arraycopy(a.num, 0, c, 0, a.num.length);
        for (int i = 0; i < b.len; ++i)
        {
            c[i] += b.num[i];
        }
        for (int i = 0; i < c.length - 1; ++i)
        {
            if (c[i] >= 10)
            {
                c[i + 1] += c[i] / 10;
                c[i] %= 10;
            }
        }
        num = c;
        len = c.length;
        for (int i = num.length - 1; num[i--] == 0; --len);
    }

    void mul(BUI a, BUI b)
    {
        BUI c = new BUI("0");
        {
            BUI one = new BUI("1");
            BUI i = new BUI("0");
            for (; i.cmp(a) < 0; i.add(i, one))
            {
                c.add(c, b);
            }
        }
        num = c.num;
        len = c.len;
    }

    void print()
    {
        for (int i = len - 1; i >= 0; --i)
        {
            System.out.print(num[i]);
        }
    }
}


public class Test
{
    public static void main(String[] args)
    {
        BUI a = new BUI("123456789");
        BUI b = new BUI("987654321");
        a.print();
        System.out.print(" x ");
        b.print();
        System.out.print(" = ");
        long start_time = System.currentTimeMillis();
        a.mul(a, b);
        long end_time = System.currentTimeMillis();
        a.print();
        System.out.printf("\nelapsed time: %.3f\n", (end_time - start_time) / 1000.0);
    }
}

    for (; BUI_cmp(i, a) < 0; BUI_inc(i))
    {
        BUI_addinplace(c, b);
    }

void BUI_addinplace(BUI a, const BUI b) //a += b
{
    int maxSize = MAX(a->len, b->len) + 1;

    if (a->num.len < maxSize)
    {
        Array tmp;
        new_Array(&tmp, maxSize);

        memset(tmp.data, 0, tmp.len);
        memcpy(tmp.data, a->num.data, a->len);

        del_Array(&a->num);
        a->num = tmp;
    }

    for (int i = 0; i < b->len; ++i)
    {
        a->num.data[i] += b->num.data[i];
    }

    int maxLen = a->len;

    for (int i = 0; i < a->len; ++i)
    {
        if (a->num.data[i] >= 10)
        {
            a->num.data[i + 1] += a->num.data[i] / 10;
            a->num.data[i] %= 10;
            maxLen = i + 2;
        }
    }

    if (maxLen > a->len) a->len = maxLen;
}


void BUI_inc(BUI a) //a += 1
{
    int maxSize = a->len + 1;

    if (a->num.len < maxSize)
    {
        ++numAllocations;
        Array tmp;
        new_Array(&tmp, maxSize);

        memset(tmp.data, 0, tmp.len);
        memcpy(tmp.data, a->num.data, a->len);

        del_Array(&a->num);
        a->num = tmp;
    }

    ++a->num.data[0];
    if (a->num.data[0] < 10) return;

    int maxLen = a->len;

    for (int i = 0; i < a->len; ++i)
    {
        if (a->num.data[i] >= 10)
        {
            a->num.data[i + 1] += a->num.data[i] / 10;
            a->num.data[i] %= 10;
            maxLen = i + 2;
        }
        else {
            break;
        }
    }

    if (maxLen > a->len) a->len = maxLen;
}

#define BUFFER_SIZE 1048576 //reserve 1MB, although we only use 417bytes

typedef struct mem_block_hdr
{
    unsigned short size; //size of the memory block, excluding header
    char free;           //is this block free
    char cont;           //not used
}mem_block_hdr_t;

struct _myallocdata
{
    char mem[BUFFER_SIZE];
    unsigned int highest_header_pos;
} my_alloc_data;

void init_block_hdr(void *mem)
{
    mem_block_hdr_t *head = (mem_block_hdr_t*) mem;
    head->size = USHRT_MAX;
    head->free = 1;
    head->cont = 0;
}
void init_my_alloc()
{
    init_block_hdr(my_alloc_data.mem);
    my_alloc_data.highest_header_pos = 0;
}

mem_block_hdr_t *next_header(mem_block_hdr_t *curr)
{
    return (mem_block_hdr_t*) ((char*) curr + sizeof(mem_block_hdr_t) + curr->size);
}

mem_block_hdr_t *find_next_free(unsigned int size)
{
    void * ret;
    char end_reached = 0;
    mem_block_hdr_t *head = (mem_block_hdr_t*) my_alloc_data.mem;

    while(
        (!head->free || head->size < size) &&
        ((char*) head - my_alloc_data.mem ) < my_alloc_data.highest_header_pos
        )
    {
        head = next_header(head);
    }
    return head;
}

void *my_alloc(unsigned int size)
{
    mem_block_hdr_t *header = find_next_free(size);
    unsigned int diff = (char*) header - my_alloc_data.mem ;

    if (header->size == USHRT_MAX)
    {
        header->size = size;
    }
    header->free = 0;

    if (diff >= my_alloc_data.highest_header_pos)
    {
        mem_block_hdr_t *new_high = next_header(header);
        init_block_hdr(new_high);
        my_alloc_data.highest_header_pos = ((char*) new_high) - my_alloc_data.mem;
    }
    return (void *)++header;
}

void my_free(void *mem)
{
    mem_block_hdr_t *hdr =(mem_block_hdr_t *) ((char *)mem - sizeof(mem_block_hdr_t));
    hdr->free = 1;
}

void new_Array(Array *a, int len)
{
    //a->data = (byte *) malloc(len * sizeof(byte));
    a->data = (byte *) my_alloc(len * sizeof(byte));
    a->len = len;
}

void del_Array(Array *a)
{
    //free(a->data);
    my_free(a->data);
}

//calling init_my_alloc() in main before using it

123456789 x 987654321 = 121932631112635269
elapsed time (custom alloc): 25.546
19 18
123456789 x 987654321 = 121932631112635269
elapsed time (malloc): 290.118
19 18

123456789 x 987654321 = 121932631112635269
elapsed time (custom alloc): 30.703
19 18
123456789 x 987654321 = 121932631112635269
elapsed time (malloc): 46.406
19 18