Ubuntu 当我为自己的altcoin尝试make-f makefile.unix时，如何消除错误？

我已经完成了这个视频（）中的所有SEPT，但是当我尝试

make-f makefile.unix

时，我有一长串的错误，但是我找不到修复它们的方法！以下是我所有的错误：

In file included from main.h:8:0,
                 from checkpoints.cpp:10:
bignum.h:51:24: error: invalid use of incomplete type ‘BIGNUM {aka struct bignum_st}’
 class CBigNum : public BIGNUM
                        ^~~~~~
In file included from /usr/include/openssl/bn.h:19:0,
                 from bignum.h:10,
                 from main.h:8,
                 from checkpoints.cpp:10:
/usr/include/openssl/ossl_typ.h:80:16: note: forward declaration of ‘BIGNUM {aka struct bignum_st}’
 typedef struct bignum_st BIGNUM;
                ^~~~~~~~~
In file included from main.h:8:0,
                 from checkpoints.cpp:10:
bignum.h: In constructor ‘CBigNum::CBigNum()’:
bignum.h:56:9: error: ‘BN_init’ was not declared in this scope
         BN_init(this);
         ^~~~~~~
bignum.h:56:9: note: suggested alternative: ‘BN_print’
         BN_init(this);
         ^~~~~~~
         BN_print
bignum.h: In copy constructor ‘CBigNum::CBigNum(const CBigNum&)’:
bignum.h:61:9: error: ‘BN_init’ was not declared in this scope
         BN_init(this);
         ^~~~~~~
bignum.h:61:9: note: suggested alternative: ‘BN_print’
         BN_init(this);
         ^~~~~~~
         BN_print
bignum.h:62:30: error: cannot convert ‘CBigNum*’ to ‘BIGNUM* {aka bignum_st*}’ for argument ‘1’ to ‘BIGNUM* BN_copy(BIGNUM*, const BIGNUM*)’
         if (!BN_copy(this, &b))
                              ^
bignum.h:64:31: error: cannot convert ‘CBigNum*’ to ‘BIGNUM* {aka bignum_st*}’ for argument ‘1’ to ‘void BN_clear_free(BIGNUM*)’
             BN_clear_free(this);
                               ^
bignum.h: In member function ‘CBigNum& CBigNum::operator=(const CBigNum&)’:
bignum.h:71:30: error: cannot convert ‘CBigNum*’ to ‘BIGNUM* {aka bignum_st*}’ for argument ‘1’ to ‘BIGNUM* BN_copy(BIGNUM*, const BIGNUM*)’
         if (!BN_copy(this, &b))
                              ^
bignum.h: In destructor ‘CBigNum::~CBigNum()’:
bignum.h:78:27: error: cannot convert ‘CBigNum*’ to ‘BIGNUM* {aka bignum_st*}’ for argument ‘1’ to ‘void BN_clear_free(BIGNUM*)’
         BN_clear_free(this);
                           ^
bignum.h: In constructor ‘CBigNum::CBigNum(signed char)’:
bignum.h:82:35: error: ‘BN_init’ was not declared in this scope
     CBigNum(signed char n)      { BN_init(this); if (n >= 0) setulong(n); else setint64(n); }
                                   ^~~~~~~
bignum.h:82:35: note: suggested alternative: ‘BN_print’
     CBigNum(signed char n)      { BN_init(this); if (n >= 0) setulong(n); else setint64(n); }
                                   ^~~~~~~
                                   BN_print
bignum.h: In constructor ‘CBigNum::CBigNum(short int)’:
bignum.h:83:35: error: ‘BN_init’ was not declared in this scope
     CBigNum(short n)            { BN_init(this); if (n >= 0) setulong(n); else setint64(n); }
                                   ^~~~~~~
bignum.h:83:35: note: suggested alternative: ‘BN_print’
     CBigNum(short n)            { BN_init(this); if (n >= 0) setulong(n); else setint64(n); }
                                   ^~~~~~~
                                   BN_print
bignum.h: In constructor ‘CBigNum::CBigNum(int)’:
bignum.h:84:35: error: ‘BN_init’ was not declared in this scope
     CBigNum(int n)              { BN_init(this); if (n >= 0) setulong(n); else setint64(n); }
                                   ^~~~~~~
bignum.h:84:35: note: suggested alternative: ‘BN_print’
     CBigNum(int n)              { BN_init(this); if (n >= 0) setulong(n); else setint64(n); }
                                   ^~~~~~~
                                   BN_print
bignum.h: In constructor ‘CBigNum::CBigNum(long int)’:
bignum.h:85:35: error: ‘BN_init’ was not declared in this scope
     CBigNum(long n)             { BN_init(this); if (n >= 0) setulong(n); else setint64(n); }
                                   ^~~~~~~
bignum.h:85:35: note: suggested alternative: ‘BN_print’
     CBigNum(long n)             { BN_init(this); if (n >= 0) setulong(n); else setint64(n); }
                                   ^~~~~~~
                                   BN_print
bignum.h: In constructor ‘CBigNum::CBigNum(int64)’:
bignum.h:86:35: error: ‘BN_init’ was not declared in this scope
     CBigNum(int64 n)            { BN_init(this); setint64(n); }
                                   ^~~~~~~
bignum.h:86:35: note: suggested alternative: ‘BN_print’
     CBigNum(int64 n)            { BN_init(this); setint64(n); }
                                   ^~~~~~~
                                   BN_print
bignum.h: In constructor ‘CBigNum::CBigNum(unsigned char)’:
bignum.h:87:35: error: ‘BN_init’ was not declared in this scope
     CBigNum(unsigned char n)    { BN_init(this); setulong(n); }
                                   ^~~~~~~
bignum.h:87:35: note: suggested alternative: ‘BN_print’
     CBigNum(unsigned char n)    { BN_init(this); setulong(n); }
                                   ^~~~~~~
                                   BN_print
bignum.h: In constructor ‘CBigNum::CBigNum(short unsigned int)’:
bignum.h:88:35: error: ‘BN_init’ was not declared in this scope
     CBigNum(unsigned short n)   { BN_init(this); setulong(n); }
                                   ^~~~~~~
bignum.h:88:35: note: suggested alternative: ‘BN_print’
     CBigNum(unsigned short n)   { BN_init(this); setulong(n); }
                                   ^~~~~~~
                                   BN_print
bignum.h: In constructor ‘CBigNum::CBigNum(unsigned int)’:
bignum.h:89:35: error: ‘BN_init’ was not declared in this scope
     CBigNum(unsigned int n)     { BN_init(this); setulong(n); }
                                   ^~~~~~~
bignum.h:89:35: note: suggested alternative: ‘BN_print’
     CBigNum(unsigned int n)     { BN_init(this); setulong(n); }
                                   ^~~~~~~
                                   BN_print
bignum.h: In constructor ‘CBigNum::CBigNum(long unsigned int)’:
bignum.h:90:35: error: ‘BN_init’ was not declared in this scope
     CBigNum(unsigned long n)    { BN_init(this); setulong(n); }
                                   ^~~~~~~
bignum.h:90:35: note: suggested alternative: ‘BN_print’
     CBigNum(unsigned long n)    { BN_init(this); setulong(n); }
                                   ^~~~~~~
                                   BN_print
bignum.h: In constructor ‘CBigNum::CBigNum(uint64)’:
bignum.h:91:35: error: ‘BN_init’ was not declared in this scope
     CBigNum(uint64 n)           { BN_init(this); setuint64(n); }
                                   ^~~~~~~
bignum.h:91:35: note: suggested alternative: ‘BN_print’
     CBigNum(uint64 n)           { BN_init(this); setuint64(n); }
                                   ^~~~~~~
                                   BN_print
bignum.h: In constructor ‘CBigNum::CBigNum(uint256)’:
bignum.h:92:35: error: ‘BN_init’ was not declared in this scope
     explicit CBigNum(uint256 n) { BN_init(this); setuint256(n); }
                                   ^~~~~~~
bignum.h:92:35: note: suggested alternative: ‘BN_print’
     explicit CBigNum(uint256 n) { BN_init(this); setuint256(n); }
                                   ^~~~~~~
                                   BN_print
bignum.h: In constructor ‘CBigNum::CBigNum(const std::vector<unsigned char>&)’:
bignum.h:96:9: error: ‘BN_init’ was not declared in this scope
         BN_init(this);
         ^~~~~~~
bignum.h:96:9: note: suggested alternative: ‘BN_print’
         BN_init(this);
         ^~~~~~~
         BN_print
bignum.h: In member function ‘void CBigNum::setulong(long unsigned int)’:
bignum.h:102:33: error: cannot convert ‘CBigNum*’ to ‘BIGNUM* {aka bignum_st*}’ for argument ‘1’ to ‘int BN_set_word(BIGNUM*, long unsigned int)’
         if (!BN_set_word(this, n))
                                 ^
bignum.h: In member function ‘long unsigned int CBigNum::getulong() const’:
bignum.h:108:32: error: cannot convert ‘const CBigNum*’ to ‘const BIGNUM* {aka const bignum_st*}’ for argument ‘1’ to ‘long unsigned int BN_get_word(const BIGNUM*)’
         return BN_get_word(this);
                                ^
bignum.h: In member function ‘unsigned int CBigNum::getuint() const’:
bignum.h:113:32: error: cannot convert ‘const CBigNum*’ to ‘const BIGNUM* {aka const bignum_st*}’ for argument ‘1’ to ‘long unsigned int BN_get_word(const BIGNUM*)’
         return BN_get_word(this);
                                ^
bignum.h: In member function ‘int CBigNum::getint() const’:
bignum.h:118:43: error: cannot convert ‘const CBigNum*’ to ‘const BIGNUM* {aka const bignum_st*}’ for argument ‘1’ to ‘long unsigned int BN_get_word(const BIGNUM*)’
         unsigned long n = BN_get_word(this);
                                           ^
bignum.h:119:33: error: cannot convert ‘const CBigNum*’ to ‘const BIGNUM* {aka const bignum_st*}’ for argument ‘1’ to ‘int BN_is_negative(const BIGNUM*)’
         if (!BN_is_negative(this))
                                 ^
In file included from main.h:8:0,
                 from checkpoints.cpp:10:
bignum.h: In member function ‘void CBigNum::setint64(int64)’:
bignum.h:167:37: error: cannot convert ‘CBigNum*’ to ‘BIGNUM* {aka bignum_st*}’ for argument ‘3’ to ‘BIGNUM* BN_mpi2bn(const unsigned char*, int, BIGNUM*)’
         BN_mpi2bn(pch, p - pch, this);
                                     ^
bignum.h: In member function ‘void CBigNum::setuint64(uint64)’:
bignum.h:194:37: error: cannot convert ‘CBigNum*’ to ‘BIGNUM* {aka bignum_st*}’ for argument ‘3’ to ‘BIGNUM* BN_mpi2bn(const unsigned char*, int, BIGNUM*)’
         BN_mpi2bn(pch, p - pch, this);
                                     ^
bignum.h: In member function ‘void CBigNum::setuint256(uint256)’:
bignum.h:222:37: error: cannot convert ‘CBigNum*’ to ‘BIGNUM* {aka bignum_st*}’ for argument ‘3’ to ‘BIGNUM* BN_mpi2bn(const unsigned char*, int, BIGNUM*)’
         BN_mpi2bn(pch, p - pch, this);
                                     ^
bignum.h: In member function ‘uint256 CBigNum::getuint256() const’:
bignum.h:227:50: error: cannot convert ‘const CBigNum*’ to ‘const BIGNUM* {aka const bignum_st*}’ for argument ‘1’ to ‘int BN_bn2mpi(const BIGNUM*, unsigned char*)’
         unsigned int nSize = BN_bn2mpi(this, NULL);
                                                  ^
bignum.h:231:32: error: cannot convert ‘const CBigNum*’ to ‘const BIGNUM* {aka const bignum_st*}’ for argument ‘1’ to ‘int BN_bn2mpi(const BIGNUM*, unsigned char*)’
         BN_bn2mpi(this, &vch[0]);
                                ^
bignum.h: In member function ‘void CBigNum::setvch(const std::vector<unsigned char>&)’:
bignum.h:252:46: error: cannot convert ‘CBigNum*’ to ‘BIGNUM* {aka bignum_st*}’ for argument ‘3’ to ‘BIGNUM* BN_mpi2bn(const unsigned char*, int, BIGNUM*)’
         BN_mpi2bn(&vch2[0], vch2.size(), this);
                                              ^
bignum.h: In member function ‘std::vector<unsigned char> CBigNum::getvch() const’:
bignum.h:257:50: error: cannot convert ‘const CBigNum*’ to ‘const BIGNUM* {aka const bignum_st*}’ for argument ‘1’ to ‘int BN_bn2mpi(const BIGNUM*, unsigned char*)’
         unsigned int nSize = BN_bn2mpi(this, NULL);
                                                  ^
bignum.h:261:32: error: cannot convert ‘const CBigNum*’ to ‘const BIGNUM* {aka const bignum_st*}’ for argument ‘1’ to ‘int BN_bn2mpi(const BIGNUM*, unsigned char*)’
         BN_bn2mpi(this, &vch[0]);
                                ^
bignum.h: In member function ‘CBigNum& CBigNum::SetCompact(unsigned int)’:
bignum.h:297:36: error: cannot convert ‘CBigNum*’ to ‘BIGNUM* {aka bignum_st*}’ for argument ‘1’ to ‘int BN_set_word(BIGNUM*, long unsigned int)’
             BN_set_word(this, nWord);
                                    ^
bignum.h:301:36: error: cannot convert ‘CBigNum*’ to ‘BIGNUM* {aka bignum_st*}’ for argument ‘1’ to ‘int BN_set_word(BIGNUM*, long unsigned int)’
             BN_set_word(this, nWord);
                                    ^
bignum.h:302:46: error: cannot convert ‘CBigNum*’ to ‘BIGNUM* {aka bignum_st*}’ for argument ‘1’ to ‘int BN_lshift(BIGNUM*, const BIGNUM*, int)’
             BN_lshift(this, this, 8*(nSize-3));
                                              ^
bignum.h:304:40: error: cannot convert ‘CBigNum*’ to ‘BIGNUM* {aka bignum_st*}’ for argument ‘1’ to ‘void BN_set_negative(BIGNUM*, int)’
         BN_set_negative(this, fNegative);
                                        ^
In file included from bignum.h:10:0,
                 from main.h:8,
                 from checkpoints.cpp:10:
bignum.h: In member function ‘unsigned int CBigNum::GetCompact() const’:
bignum.h:310:30: error: cannot convert ‘const CBigNum*’ to ‘const BIGNUM* {aka const bignum_st*}’ for argument ‘1’ to ‘int BN_num_bits(const BIGNUM*)’
         unsigned int nSize = BN_num_bytes(this);
                              ^
In file included from main.h:8:0,
                 from checkpoints.cpp:10:
bignum.h:313:40: error: cannot convert ‘const CBigNum*’ to ‘const BIGNUM* {aka const bignum_st*}’ for argument ‘1’ to ‘long unsigned int BN_get_word(const BIGNUM*)’
             nCompact = BN_get_word(this) << 8*(3-nSize);
                                        ^
bignum.h:317:45: error: cannot convert ‘CBigNum*’ to ‘BIGNUM* {aka bignum_st*}’ for argument ‘1’ to ‘int BN_rshift(BIGNUM*, const BIGNUM*, int)’
             BN_rshift(&bn, this, 8*(nSize-3));
                                             ^
bignum.h:318:39: error: cannot convert ‘CBigNum*’ to ‘const BIGNUM* {aka const bignum_st*}’ for argument ‘1’ to ‘long unsigned int BN_get_word(const BIGNUM*)’
             nCompact = BN_get_word(&bn);
                                       ^
bignum.h:328:41: error: cannot convert ‘const CBigNum*’ to ‘const BIGNUM* {aka const bignum_st*}’ for argument ‘1’ to ‘int BN_is_negative(const BIGNUM*)’
         nCompact |= (BN_is_negative(this) ? 0x00800000 : 0);
                                         ^
In file included from main.h:8:0,
                 from checkpoints.cpp:10:
bignum.h: In member function ‘std::__cxx11::string CBigNum::ToString(int) const’:
bignum.h:369:35: error: cannot convert ‘CBigNum*’ to ‘BIGNUM* {aka bignum_st*}’ for argument ‘1’ to ‘void BN_set_negative(BIGNUM*, int)’
         BN_set_negative(&bn, false);
                                   ^
bignum.h:372:29: error: cannot convert ‘CBigNum*’ to ‘const BIGNUM* {aka const bignum_st*}’ for argument ‘1’ to ‘int BN_cmp(const BIGNUM*, const BIGNUM*)’
         if (BN_cmp(&bn, &bn0) == 0)
                             ^
bignum.h:374:32: error: cannot convert ‘CBigNum*’ to ‘const BIGNUM* {aka const bignum_st*}’ for argument ‘1’ to ‘int BN_cmp(const BIGNUM*, const BIGNUM*)’
         while (BN_cmp(&bn, &bn0) > 0)
                                ^
bignum.h:376:54: error: cannot convert ‘CBigNum*’ to ‘BIGNUM* {aka bignum_st*}’ for argument ‘1’ to ‘int BN_div(BIGNUM*, BIGNUM*, const BIGNUM*, const BIGNUM*, BN_CTX*)’
             if (!BN_div(&dv, &rem, &bn, &bnBase, pctx))
                                                      ^
bignum.h:382:32: error: cannot convert ‘const CBigNum*’ to ‘const BIGNUM* {aka const bignum_st*}’ for argument ‘1’ to ‘int BN_is_negative(const BIGNUM*)’
         if (BN_is_negative(this))
                                ^
bignum.h: In member function ‘bool CBigNum::operator!() const’:
bignum.h:415:31: error: cannot convert ‘const CBigNum*’ to ‘const BIGNUM* {aka const bignum_st*}’ for argument ‘1’ to ‘int BN_is_zero(const BIGNUM*)’
         return BN_is_zero(this);
                               ^
bignum.h: In member function ‘CBigNum& CBigNum::operator+=(const CBigNum&)’:
bignum.h:420:35: error: cannot convert ‘CBigNum*’ to ‘BIGNUM* {aka bignum_st*}’ for argument ‘1’ to ‘int BN_add(BIGNUM*, const BIGNUM*, const BIGNUM*)’
         if (!BN_add(this, this, &b))
                                   ^
bignum.h: In member function ‘CBigNum& CBigNum::operator*=(const CBigNum&)’:
bignum.h:434:41: error: cannot convert ‘CBigNum*’ to ‘BIGNUM* {aka bignum_st*}’ for argument ‘1’ to ‘int BN_mul(BIGNUM*, const BIGNUM*, const BIGNUM*, BN_CTX*)’
         if (!BN_mul(this, this, &b, pctx))
                                         ^
bignum.h: In member function ‘CBigNum& CBigNum::operator<<=(unsigned int)’:
bignum.h:453:41: error: cannot convert ‘CBigNum*’ to ‘BIGNUM* {aka bignum_st*}’ for argument ‘1’ to ‘int BN_lshift(BIGNUM*, const BIGNUM*, int)’
         if (!BN_lshift(this, this, shift))
                                         ^
bignum.h: In member function ‘CBigNum& CBigNum::operator>>=(unsigned int)’:
bignum.h:464:28: error: cannot convert ‘CBigNum*’ to ‘const BIGNUM* {aka const bignum_st*}’ for argument ‘1’ to ‘int BN_cmp(const BIGNUM*, const BIGNUM*)’
         if (BN_cmp(&a, this) > 0)
                            ^
bignum.h:470:41: error: cannot convert ‘CBigNum*’ to ‘BIGNUM* {aka bignum_st*}’ for argument ‘1’ to ‘int BN_rshift(BIGNUM*, const BIGNUM*, int)’
         if (!BN_rshift(this, this, shift))
                                         ^
bignum.h: In member function ‘CBigNum& CBigNum::operator++()’:
bignum.h:479:47: error: cannot convert ‘CBigNum*’ to ‘BIGNUM* {aka bignum_st*}’ for argument ‘1’ to ‘int BN_add(BIGNUM*, const BIGNUM*, const BIGNUM*)’
         if (!BN_add(this, this, BN_value_one()))
                                               ^
bignum.h: In member function ‘CBigNum& CBigNum::operator--()’:
bignum.h:496:45: error: cannot convert ‘CBigNum*’ to ‘BIGNUM* {aka bignum_st*}’ for argument ‘1’ to ‘int BN_sub(BIGNUM*, const BIGNUM*, const BIGNUM*)’
         if (!BN_sub(&r, this, BN_value_one()))
                                             ^
bignum.h: In function ‘const CBigNum operator+(const CBigNum&, const CBigNum&)’:
bignum.h:521:27: error: cannot convert ‘CBigNum*’ to ‘BIGNUM* {aka bignum_st*}’ for argument ‘1’ to ‘int BN_add(BIGNUM*, const BIGNUM*, const BIGNUM*)’
     if (!BN_add(&r, &a, &b))
                           ^
bignum.h: In function ‘const CBigNum operator-(const CBigNum&, const CBigNum&)’:
bignum.h:529:27: error: cannot convert ‘CBigNum*’ to ‘BIGNUM* {aka bignum_st*}’ for argument ‘1’ to ‘int BN_sub(BIGNUM*, const BIGNUM*, const BIGNUM*)’
     if (!BN_sub(&r, &a, &b))
                           ^
bignum.h: In function ‘const CBigNum operator-(const CBigNum&)’:
bignum.h:537:43: error: cannot convert ‘CBigNum*’ to ‘const BIGNUM* {aka const bignum_st*}’ for argument ‘1’ to ‘int BN_is_negative(const BIGNUM*)’
     BN_set_negative(&r, !BN_is_negative(&r));
                                           ^
bignum.h: In function ‘const CBigNum operator*(const CBigNum&, const CBigNum&)’:
bignum.h:545:33: error: cannot convert ‘CBigNum*’ to ‘BIGNUM* {aka bignum_st*}’ for argument ‘1’ to ‘int BN_mul(BIGNUM*, const BIGNUM*, const BIGNUM*, BN_CTX*)’
     if (!BN_mul(&r, &a, &b, pctx))
                                 ^
bignum.h: In function ‘const CBigNum operator/(const CBigNum&, const CBigNum&)’:
bignum.h:554:39: error: cannot convert ‘CBigNum*’ to ‘BIGNUM* {aka bignum_st*}’ for argument ‘1’ to ‘int BN_div(BIGNUM*, BIGNUM*, const BIGNUM*, const BIGNUM*, BN_CTX*)’
     if (!BN_div(&r, NULL, &a, &b, pctx))
                                       ^
In file included from bignum.h:10:0,
                 from main.h:8,
                 from checkpoints.cpp:10:
bignum.h: In function ‘const CBigNum operator%(const CBigNum&, const CBigNum&)’:
bignum.h:563:10: error: cannot convert ‘CBigNum*’ to ‘BIGNUM* {aka bignum_st*}’ for argument ‘2’ to ‘int BN_div(BIGNUM*, BIGNUM*, const BIGNUM*, const BIGNUM*, BN_CTX*)’
     if (!BN_mod(&r, &a, &b, pctx))
          ^
In file included from main.h:8:0,
                 from checkpoints.cpp:10:
bignum.h: In function ‘const CBigNum operator<<(const CBigNum&, unsigned int)’:
bignum.h:571:33: error: cannot convert ‘CBigNum*’ to ‘BIGNUM* {aka bignum_st*}’ for argument ‘1’ to ‘int BN_lshift(BIGNUM*, const BIGNUM*, int)’
     if (!BN_lshift(&r, &a, shift))
                                 ^
bignum.h: In function ‘bool operator==(const CBigNum&, const CBigNum&)’:
bignum.h:583:83: error: cannot convert ‘const CBigNum*’ to ‘const BIGNUM* {aka const bignum_st*}’ for argument ‘1’ to ‘int BN_cmp(const BIGNUM*, const BIGNUM*)’
 perator==(const CBigNum& a, const CBigNum& b) { return (BN_cmp(&a, &b) == 0); }
                                                                      ^
bignum.h: In function ‘bool operator!=(const CBigNum&, const CBigNum&)’:
bignum.h:584:83: error: cannot convert ‘const CBigNum*’ to ‘const BIGNUM* {aka const bignum_st*}’ for argument ‘1’ to ‘int BN_cmp(const BIGNUM*, const BIGNUM*)’
 perator!=(const CBigNum& a, const CBigNum& b) { return (BN_cmp(&a, &b) != 0); }
                                                                      ^
bignum.h: In function ‘bool operator<=(const CBigNum&, const CBigNum&)’:
bignum.h:585:83: error: cannot convert ‘const CBigNum*’ to ‘const BIGNUM* {aka const bignum_st*}’ for argument ‘1’ to ‘int BN_cmp(const BIGNUM*, const BIGNUM*)’
 perator<=(const CBigNum& a, const CBigNum& b) { return (BN_cmp(&a, &b) <= 0); }
                                                                      ^
bignum.h: In function ‘bool operator>=(const CBigNum&, const CBigNum&)’:
bignum.h:586:83: error: cannot convert ‘const CBigNum*’ to ‘const BIGNUM* {aka const bignum_st*}’ for argument ‘1’ to ‘int BN_cmp(const BIGNUM*, const BIGNUM*)’
 perator>=(const CBigNum& a, const CBigNum& b) { return (BN_cmp(&a, &b) >= 0); }
                                                                      ^
bignum.h: In function ‘bool operator<(const CBigNum&, const CBigNum&)’:
bignum.h:587:83: error: cannot convert ‘const CBigNum*’ to ‘const BIGNUM* {aka const bignum_st*}’ for argument ‘1’ to ‘int BN_cmp(const BIGNUM*, const BIGNUM*)’
 operator<(const CBigNum& a, const CBigNum& b)  { return (BN_cmp(&a, &b) < 0); }
                                                                       ^
bignum.h: In function ‘bool operator>(const CBigNum&, const CBigNum&)’:
bignum.h:588:83: error: cannot convert ‘const CBigNum*’ to ‘const BIGNUM* {aka const bignum_st*}’ for argument ‘1’ to ‘int BN_cmp(const BIGNUM*, const BIGNUM*)’
 operator>(const CBigNum& a, const CBigNum& b)  { return (BN_cmp(&a, &b) > 0); }
                                                                       ^
makefile.unix:186: recipe for target 'obj/checkpoints.o' failed
make: *** [obj/checkpoints.o] Error 1

在main.h:8:0中包含的文件中，
来自检查点。cpp:10：
bignum.h:51:24:错误：不完整类型“bignum{aka struct bignum_st}”的使用无效
类CBigNum:public BIGNUM
^~~~~~
在/usr/include/openssl/bn.h:19:0中包含的文件中，
从bignum.h:10，
从main.h:8，
来自检查点。cpp:10：
/usr/include/openssl/ossl_typ.h:80:16：注意：转发声明'BIGNUM{aka struct BIGNUM_st}'
typedef struct bignum_st bignum；
^~~~~~~~~
在main.h:8:0中包含的文件中，
来自检查点。cpp:10：
bignum.h:在构造函数“CBigNum:：CBigNum（）”中：
bignum.h:56:9:错误：“BN_init”未在此作用域中声明
BN_init（本）；
^~~~~~~
bignum.h:56:9：注：建议的备选方案：“BNU打印”
BN_init（本）；
^~~~~~~
BNU印刷品
h:在复制构造函数“CBigNum:：CBigNum（const CBigNum&）”中：
bignum.h:61:9:错误：“BN_init”未在此作用域中声明
BN_init（本）；
^~~~~~~
bignum.h:61:9：注：建议的备选方案：“BNU打印”
BN_init（本）；
^~~~~~~
BNU印刷品
bignum.h:62:30:错误：无法将参数“1”的“CBigNum*”转换为“bignum*{aka bignum\u st*}”，将其转换为“bignum*BN\u copy（bignum*，const bignum*）”
如果（！BN_副本（此，&b））
^
bignum.h:64:31:错误：无法将参数“1”的“CBigNum*”转换为“bignum*{aka bignum\u st*}”转换为“void BN\u clear\u free（bignum*）”
BN_clear_free（本）；
^
h:在成员函数“CBigNum&CBigNum:：operator=（const CBigNum&）”中：
bignum.h:71:30:错误：无法将参数“1”的“CBigNum*”转换为“bignum*{aka bignum\u st*}”，将其转换为“bignum*BN\u copy（bignum*，const bignum*）”
如果（！BN_副本（此，&b））
^
bignum.h:在析构函数“CBigNum:：~CBigNum（）”中：
bignum.h:78:27:错误：无法将参数“1”的“CBigNum*”转换为“bignum*{aka bignum\u st*}”转换为“void BN\u clear\u free（bignum*）”
BN_clear_free（本）；
^
bignum.h:在构造函数“CBigNum:：CBigNum（签名字符）”中：
bignum.h:82:35:错误：“BN_init”未在此作用域中声明
CBigNum（有符号字符n）{BN_init（this）；if（n>=0）setulong（n）；else setint64（n）；}
^~~~~~~
bignum.h:82:35：注：建议的备选方案：“BNU打印”
CBigNum（有符号字符n）{BN_init（this）；if（n>=0）setulong（n）；else setint64（n）；}
^~~~~~~
BNU印刷品
bignum.h:在构造函数“CBigNum:：CBigNum（short int）”中：
bignum.h:83:35:错误：“BN_init”未在此作用域中声明
CBigNum（短n）{BN_init（this）；if（n>=0）setulong（n）；else setint64（n）；}
^~~~~~~
bignum.h:83:35：注：建议的备选方案：“BNU打印”
CBigNum（短n）{BN_init（this）；if（n>=0）setulong（n）；else setint64（n）；}
^~~~~~~
BNU印刷品
bignum.h:在构造函数“CBigNum:：CBigNum（int）”中：
bignum.h:84:35:错误：“BN_init”未在此作用域中声明
CBigNum（intn）{BN_init（this）；if（n>=0）setulong（n）；else setint64（n）；}
^~~~~~~
bignum.h:84:35：注：建议的备选方案：“BNU打印”
CBigNum（intn）{BN_init（this）；if（n>=0）setulong（n）；else setint64（n）；}
^~~~~~~
BNU印刷品
bignum.h:在构造函数“CBigNum:：CBigNum（long int）”中：
bignum.h:85:35:错误：“BN_init”未在此作用域中声明
CBigNum（long n）{BN_init（this）；if（n>=0）setulong（n）；else setint64（n）；}
^~~~~~~
bignum.h:85:35：注：建议的备选方案：“BNU打印”
CBigNum（long n）{BN_init（this）；if（n>=0）setulong（n）；else setint64（n）；}
^~~~~~~
BNU印刷品
bignum.h:在构造函数“CBigNum:：CBigNum（int64）”中：
bignum.h:86:35:错误：“BN_init”未在此作用域中声明
CBigNum（int64 n）{BN_init（this）；setint64（n）；}
^~~~~~~
bignum.h:86:35：注：建议的备选方案：“BNU打印”
CBigNum（int64 n）{BN_init（this）；setint64（n）；}
^~~~~~~
BNU印刷品
bignum.h:在构造函数“CBigNum:：CBigNum（unsigned char）”中：
bignum.h:87:35:错误：“BN_init”未在此作用域中声明
CBigNum（无符号字符n）{BN_init（this）；setulong（n）；}
^~~~~~~
bignum.h:87:35：注：建议的备选方案：“BNU打印”
CBigNum（无符号字符n）{BN_init（this）；setulong（n）；}
^~~~~~~
BNU印刷品
bignum.h:在构造函数“CBigNum:：CBigNum（短无符号int）”中：
bignum.h:88:35:错误：“BN_init”未在此作用域中声明
CBigNum（无符号短n）{BN_init（this）；setulong（n）；}
^~~~~~~
bignum.h:88:35：注：建议的备选方案：“BNU打印”
CBigNum（无符号短n）{BN_init（this）；setulong（n）；}
^~~~~~~
BNU印刷品
bignum.h:在构造函数“CBigNum:：CBigNum（unsigned int）”中：
bignum.h:89:35:错误：“BN_init”未在此作用域中声明
卡比努