C/C++区块链实现代码优化

C/C++区块链实现代码优化

源地址为：https://blog.csdn.net/qq_27180763/article/details/82588305

你有多少电力，算完这道哈希，

比特币的共识太给力，随处可藏，无问东西。

因你的梦太美，我已不想再退，

算法来的信任太纯粹，好想带你全世界都走一回

分布式的记帐，多简单多抽象，

可中本聪他呀，却是下落不详。

谁接青黄，少年郎，造以太坊。

ICO太疯狂，乱相惹怒央行，

那庄家太嚣张，这韭菜在摇晃，

先熄灭妄想，才能成长。

几千几万通证，几言几语新政，

谁在走进 悬崖边的乱阵，

一步迈错 你交出了谁的灵魂。

多明显的泡沫，明显得好寂寞，

抽象掩盖欲望，却又欲盖弥彰，

谁在嚣张，嚣张到失去形状。

监管一记耳光，逼谁露出真相，

这梦想太张扬，这现实太慌张，

先落地生长，才好推广。

既然已在路上，慢一点又何妨，

就像硅谷那样，代码多写几行，

这征途太远，要勇敢且倔强。

#include <iostream>
#include <stdio.h>
#include <windows.h>
#include <string>
#include <cmath>
#include <climits>
#include <list>
#include <time.h>
using namespace std;

struct Moving_Point {
     long x;
     long y;
};

int circle = 1;

class Martix {
public:
    int circle_s;                                       //假定向量环路为1;
    int KEY;
    long _publickey;
private:
    long **martix_4_2 = new long*[KEY / 2];     //存储向量矩阵
    long **martix_8_8 = new long*[KEY];         //存储由向量矩阵得到的转置矩阵
    long *martix_complete = new long[KEY * 2];  //存储操作完成后的矩阵（一维）

public:
    Martix(string a) {};
    Martix(int a, int b, int circle):KEY(circle*8),circle_s(circle)
    {
        int key = 8;
        int cir = circle_s;

        for (int i = 0; i < KEY; i++) {
            martix_8_8[i] = new long[KEY];
        }
        while (cir--)
        {
            martix_4_2[key / 2 - 4] = new long[2];
            martix_4_2[key / 2 - 4][0] = (-1)*b;    martix_4_2[key / 2 - 4][1] = (-1)*a;
            martix_4_2[key / 2 - 3] = new long[2];
            martix_4_2[key / 2 - 3][0] = b;         martix_4_2[key / 2 - 3][1] = (-1)*a;
            martix_4_2[key / 2 - 2] = new long[2];
            martix_4_2[key / 2 - 2][0] = b;         martix_4_2[key / 2 - 2][1] = a;
            martix_4_2[key / 2 - 1] = new long[2];
            martix_4_2[key / 2 - 1][0] = (-1)*b;    martix_4_2[key / 2 - 1][1] = a;
            key += 8;
        }
        Change_New_Martix();
        Save_Martix();
        _publickey = GetPublicKey();
    }

    void Change_New_Martix() {
        for (int i = 0; i < 2; i++)
        {
            for (int j = 0; j < 2; j++)
            {
                martix_8_8[i][j] = 0;
            }
        }

        for (int j = 2; j < KEY / 2 + 2; j++) {
            martix_8_8[0][j] = martix_4_2[j - 2][0] * (-1);
            martix_8_8[1][j] = martix_4_2[j - 2][1] * (-1);
        }

        for (int i = 2; i < KEY / 2 + 2; i++) {
            martix_8_8[i][0] = martix_4_2[i - 2][0] * (-1);
            martix_8_8[i][1] = martix_4_2[i - 2][1] * (-1);
        }

        for (int i = 2; i < KEY / 2 + 2; i++)
        {
            for (int j = 2; j < KEY / 2 + 2; j++)
            {
                martix_8_8[i][j] = 0;
            }
        }
        for (int i = 0; i < KEY / 2; i++) {
            delete[] martix_4_2[i];
        }
        delete []martix_4_2;
    }

public:
    void Save_Martix()
    {
        int key = 0;
        for (int i = 0; i < KEY / 2 + 2; i++)
        {
            for (int j = 0; j < KEY / 2 + 2; j++)
            {
                if (martix_8_8[i][j] != 0)
                {
                    martix_complete[key++] = martix_8_8[i][j];
                }
            }
        }
        for (int i = 0; i < KEY; i++) {
            delete[] martix_8_8[i];
        }
        delete[]martix_8_8;
    }

     long GetPublicKey()
    {
         long public_key = martix_complete[0];
        for (int i = 1; i < KEY * 2; i++)
        {
            if (i % 2 == 0)
            {
                public_key = public_key + martix_complete[i];
            }
            else {
                public_key = public_key * martix_complete[i];
            }
        }
        delete []martix_complete;
        return public_key;
    }
};

class Cryptography :public Martix
{
public:
    /*作为私钥，发送方保存内容*/
     long a;                    //椭圆长轴的半轴长度
     long b;                    //椭圆短轴的半轴长度

                                    /*作为公钥，接收方接受公钥*/
     long public_Key;           //通过椭圆矩阵算法得到的公钥G
     Moving_Point p;                    //随机选定的在椭圆上的点

public:
    Cryptography(string a) :Martix("OK") {};
    Cryptography( long in_a,  long in_b, int diffcult) :Martix(in_a, in_b, diffcult)
    {
        this->a = in_a;
        this->b = in_b;
        p.x = 0;
        p.y = 0;
        public_Key = _publickey;
    }
};

struct block {
    long this_hash;
    long pre_hash;
    long data;
};

block blo;
block pre_blo = { 0,0,0 };

class Create_Block :public Cryptography {
public:
    list<block> Block;
    long public_key_key;
    int numerous = 1;
public:
    Create_Block(string a) :Cryptography("OK") {};
    Create_Block(int x = rand()%2048, int y = rand()%1024, int diffcult = rand()%1024):Cryptography(rand()%2048,rand()%1024,rand()%1024) {
        public_key_key = public_Key;
    }
    void Make_First_Block()
    {
        //Cryptography one(2,1,1);
        Cryptography one(rand() % 2048, rand() % 1024, rand() % 1024);
        public_key_key = one.public_Key;
        blo.data = numerous;
        blo.pre_hash = 0;
        blo.this_hash = (blo.pre_hash + public_key_key) * (a + b);
        Block.push_back(blo);
    }
    void Append_Block()
    {
        numerous++;
        pre_blo = blo;
        bool flag = true;
        auto temp = public_Key;
        //int cir = circle_s + 1;
        int a = rand() % 2048;
        int b = rand() % 1024;
        int c = rand() % 1024;
        Cryptography one(a,b,c);
        public_key_key = one.public_Key;
        blo.data = numerous;
        blo.pre_hash = blo.this_hash;
        blo.this_hash = (blo.pre_hash + public_key_key) * (a + b);
        Block.push_back(blo);
    }
};

class Get_Block :Create_Block{
public:
    int number = 1;
    long __public_key;
    Get_Block(int num=1):Create_Block("null") {
        number = num;
    }
    void  calc()
    {
        double start = clock();
        while (true) {
            for (long long z = 1; z < 1024; z++) {
                for (long long j = 1; j < 1024; j = j + 1) {
                    for (long long i = 1; i < 2048; i = i + 1) {
                        Cryptography* person = new Cryptography(i, j, z);
                        __public_key = person->public_Key;
                        block bloc;
                        bloc.data = number;
                        bloc.pre_hash = pre_blo.this_hash;
                        bloc.this_hash = (blo.pre_hash + __public_key) * (i + j);
                        if (blo.data == bloc.data &&blo.pre_hash == bloc.pre_hash && blo.this_hash == bloc.this_hash)
                        {
                            double end = clock();
                            cout << "历时" << end - start << "毫秒获得的第" << number++ << "个区块信息为：" << endl;
                            cout << "data:" << bloc.data << endl;
                            cout << "this_hash:" << bloc.this_hash << endl;
                            cout << "pre_hash:" << bloc.pre_hash << endl << "============================" << endl << endl;
                            this->Append_Block();
                            start = clock();
                        }
                        delete []person;
                    }
                }
            }
        }
    }
};
int main()
{
    Create_Block one;
    one.Make_First_Block();
    int flag = 10;
    Get_Block two(1);
    two.calc();

    system("pause");
    return 0;
}