Оценка кода

#include <iostream>
#include "string.h"
 
#define ENDOFARRAY -1
 
#define INTEGER 0x02
#define OCTET_STRING 0x04
#define OBJECT_IDENTIFIER 0x06
#define SEQUENCE 0x30
 
#define SETBIT(number,bit) ((number) |= (pow(2,bit)))
#define CHECKBIT(number,bit) ((number) & (1 << (bit)))
 
class decoder{
    public:
        decoder();
 
        ~decoder();
 
        char * decode(const unsigned char * ,int,char * cipherT = nullptr, char * Other = nullptr);
 
        void decode64(const char * ,char * cipherT = nullptr, char * Other = nullptr);
 
    private:
        //Calculates number in power
        int pow(int,int);
 
        char* IntToHexChar(int);
 
        void AppendOctetString(int);
 
        int CalculateLongSID(int&);
 
        //Calculates all decimal values of indentifier
        void CalculateIdentifier(int);
 
        //Calculates first byte of indentifier which is decoded to two values
        void CalculateIdentifierFirstByte();
 
        //Convert byte array to decimal value
        int CalculateBytes(int);
 
        //Decoding encoded ans1.der string
        void ParseData();
 
        //Appends passed array with new array
        char * Append(char *,char *);
 
        //Decodes length of front bytes
        int ParseLength(int);
 
        //Handles Octet String
        void OctetStringHandler();
 
        //Handles Object Indentifier
        void ObjectIdentifierHandler();
 
        //Handles Integer
        void IntegerHandler();
 
        //Handles Sequance
        void SequenceHandler();
 
        //Converts char array to int array
        void ToIntArray();
 
        //Copies value of passed array and returns new created one with same values
        const unsigned char *  NewArr(const unsigned char* );
 
        //Byte array as integers
        int * IntByteArray = nullptr;
 
        //Pointer to IntByteArray which is used to move through array
        int * pArr = nullptr;
 
        //Byte array as char
        const unsigned char * CharByteArray = nullptr;
 
        //The result decoded string
        char * Result = new char[1]{};
 
        //Size of IntByteArray
        int size = 0;
};

#include "asn1der.h"
 
decoder::decoder(){
}
 
 
decoder::~decoder(){
    if(CharByteArray)
        delete[] CharByteArray;
    if(IntByteArray)
        delete[] IntByteArray;
}
 
 
char * decoder::Append(char * dst,char * src){  
     int dstlen = strlen(dst),srclen =  strlen(src);
     char* temp = new char[dstlen+srclen+1]{};
     memcpy(temp, dst, dstlen);
     strcat(temp,src);
     delete[] dst;
     return temp;
}
 
 
const unsigned char *  decoder::NewArr(const unsigned char* arr) {
    unsigned char * temp = new unsigned char[size+1]{};
    for(int i = 0;i < size;++i){
        temp[i] = arr[i];
    }
    return temp;
}
 
 
void decoder::ToIntArray(){
    IntByteArray = new int[size+1]{};
    for(int i = 0;i<size;++i){
        IntByteArray[i] = (unsigned int)CharByteArray[i];
    }
    IntByteArray[size] = -1;
    pArr = IntByteArray;
}
 
 
void decoder::ParseData(){
    switch (*pArr)
    {
        case ENDOFARRAY:
            break;
        case INTEGER:
            IntegerHandler();
            ParseData();
            break;
        case OCTET_STRING:
            OctetStringHandler();
            ParseData();
            break;
        case OBJECT_IDENTIFIER:
            ObjectIdentifierHandler();
            ParseData();
            Result = Append(Result,const_cast<char *>("}"));
            break;
        case SEQUENCE:
            SequenceHandler();
            ParseData();
            Result = Append(Result,const_cast<char *>("\n}"));
            break;
        default:
            break;
    }
}
 
 
char * decoder::decode(const unsigned char * Text,int length,char * cipherT, char * Other){
    size = length;
      CharByteArray = NewArr(Text);
      ToIntArray();
      try{
          ParseData();
      }
      catch(const char* exception){
         std::cout << exception;
          return nullptr;
      }
      return Result;
}
 
 
int decoder::ParseLength(int num){
    num &= 63;
    return num;
}
 
 
int decoder::pow(int num, int times){
    if(times == 0)
        return 1;
    if(times == 1)
        return 2;
    if(times > 1)
        return num*pow(num,--times);
}
 
 
int decoder::CalculateBytes(int len){
    int calculated = 0,power = len*8-1;
    for(int i = 0;i < len && ++pArr;i++){
 
        if(*pArr == -1 )
            throw "CalculateBytes error";
 
        for(int q = 7;q >= 0;--q){
            if(CHECKBIT(*pArr,q)){
                calculated += pow(2,power);
            }
            --power;
        }
    }
    return calculated;
}
 
 
void decoder::CalculateIdentifierFirstByte(){ //there are only three types of first node 1,2,3 , first byte is calculated with (firstnode*40 + secondnode)
    if(*++pArr < 80){ //if first byte is less than 80 it means that first node is 1
 
        if(*pArr == -1 )
            throw "CalculateIndentifierFirstByte error";
 
        Result = Append(Result,const_cast<char *>((std::to_string(1) + ".").c_str()));
        Result = Append(Result,const_cast<char *>((std::to_string(*pArr-40)+ ".").c_str())); //if first node is 1 the second node is : number - (firstnode * 40)
        return;
    }else if (*pArr < 120) //means that first node is 2
    {
        Result = Append(Result,const_cast<char *>((std::to_string(2) + ".").c_str()));
        Result = Append(Result,const_cast<char *>((std::to_string(*pArr-80)+ ".").c_str())); //if first node is 1 the second node is : number - (firstnode * 40)
        return;
    }else // first node is 3
    {
        Result = Append(Result,const_cast<char *>((std::to_string(3) + ".").c_str()));
        Result = Append(Result,const_cast<char *>((std::to_string(*pArr-120)+ ".").c_str()));
        return;
    }
}
 
 
int decoder::CalculateLongSID(int& size) {
  int length = 1, value = 0, SID = 0;
  for (;; ++pArr) {
    if (!CHECKBIT(*pArr, 7)) {
      ++length;
      *pArr &= 127;
      value |= *pArr;
      break;
    }
    else
    {
      ++length;
      *pArr &= 127;
      value |= *pArr;
      value = value << 8;
    }
  }
  for (int i = 0; i < length*8-1; ++i) {
    if(CHECKBIT(value,i)){
        SETBIT(SID,i-i/8);
    }
  }
  size += length-2;
  return SID;
 
}
 
 
void decoder::CalculateIdentifier(int len){
    CalculateIdentifierFirstByte();
    for(int i = 0; i<len && ++pArr ; ++i){
        if(*pArr == -1 || *(pArr+1) == -1)
            throw "CalculateIndentifier error";
        if(!CHECKBIT(*pArr,7)){ //if decimal number consists of only one byte
            Result = Append(Result,const_cast<char *>((std::to_string(*pArr) + ".").c_str()));
        }else //if bit 7 is set it means that length of decimal number in bytes is bigger than one byte
        {
            Result = Append(Result,const_cast<char *>((std::to_string(CalculateLongSID(i)) + ".").c_str()));
        }
    }
}
 
 
char * decoder::IntToHexChar(int number){
    char * hex = new char[3]{};
    int num = number/16;
    for(int i = 0;i < 2;++i)
    switch (num)
    {
    case 15:
        hex[i] = 'F';
        num = number%16;
        break;
    case 14:
        hex[i] = 'E';
        num = number%16;
        break;
    case 13:
        hex[i] = 'D';
        num = number%16;
        break;
    case 12:
        hex[i] = 'C';
        num = number%16;
        break;
    case 11:
        hex[i] = 'B';
        num = number%16;
        break;
    case 10:
        hex[i] = 'A';
        num = number%16;
        break;
    case 9:
        hex[i] = '9';
        num = number%16;
        break;
    case 8:
        hex[i] = '8';
        num = number%16;
        break;
    case 7:
        hex[i] = '7';
        num = number%16;
        break;
    case 6:
        hex[i] = '6';
        num = number%16;
        break;
    case 5:
        hex[i] = '5';
        num = number%16;
        break;
    case 4:
        hex[i] = '4';
        num = number%16;
        break;
    case 3:
        hex[i] = '3';
        num = number%16;
        break;
    case 2:
        hex[i] = '2';
        num = number%16;
        break;
    case 1:
        hex[i] = '1';
        num = number%16;
        break;
    case 0:
        hex[i] = '0';
        num = number%16;
        break;
    default:
        break;
    }
    return hex;
}
 
 
void decoder::AppendOctetString(int length){
     for(int i = 0; i < length && ++pArr;++i){
         char * p = IntToHexChar(*pArr);
         Result = Append(Result,p);
         delete[] p;
     }
}
 
 
void decoder::OctetStringHandler(){
    if(!CHECKBIT(*++pArr,7)){
        if(*pArr == -1 )
            throw "IntegerHandler error";
 
        Result = Append(Result,const_cast<char *>(" Octet String : { "));
        AppendOctetString(ParseLength(*pArr));
        Result = Append(Result,const_cast<char *>("}"));
    }
    ++pArr;
}
 
 
void decoder::ObjectIdentifierHandler(){
    Result = Append(Result,const_cast<char *>(" OBJECT INDENTIFIED WITH VALUE: { "));
    if(!CHECKBIT(*++pArr,7)){ //if length in one byte
 
        if(*pArr == -1 )
            throw "IntegerHandler error";
 
        CalculateIdentifier(*pArr-1);
    }
    else //behaviour not described
    {
        CalculateIdentifierFirstByte();
        CalculateIdentifier(ParseLength(*pArr));
    }
    ++pArr;
}
 
 
void decoder::IntegerHandler(){
    if(!CHECKBIT(*++pArr,7)){
 
        if(*pArr == -1 )
            throw "IntegerHandler error";
 
        Result = Append(Result,const_cast<char *>(" INTEGER WITH VALUE: { "));
        Result = Append(Result, const_cast<char *>((std::to_string(CalculateBytes(ParseLength(*pArr)))+ " }").c_str()));
    }
    else
    {
        Result = Append(Result,const_cast<char *>(" INTEGER WITH VALUE: { "));
        Result = Append(Result, const_cast<char *>((std::to_string(CalculateBytes(CalculateBytes(ParseLength(*pArr))))+ " }").c_str()));
    }
    ++pArr;
}
 
 
void decoder::SequenceHandler(){
    if(!CHECKBIT(*++pArr,7)){
 
            if(*pArr == -1 )
                throw "SequenceHandler error";
 
            Result = Append(Result,const_cast<char *>(" SEQUENCE WITH LENGTH: "));
            Result = Append(Result, const_cast<char *>((std::to_string(*pArr) + "{ \n\t").c_str()));
      }
    else
    {
        Result = Append(Result,const_cast<char *>(" SEQUENCE WITH LENGTH: "));
        Result = Append(Result, const_cast<char *>((std::to_string(CalculateBytes(ParseLength(*pArr)))+ "\n\t").c_str()));
    }
    ++pArr;
}
 
 
void decoder::decode64(const char * Text,char * cipherT, char * Other){
    
}

#include <stdexcept>
#include <iostream>
#include <cstdlib>
 
struct Seq2d
{
    Seq2d& operator=(const Seq2d&) = delete;
    Seq2d(const Seq2d&)            = delete;
    
    Seq2d(size_t x, size_t y)
        : m_xseq(new(std::nothrow) int *[x])
        , m_yseq(new(std::nothrow) int[x * y]{})
    { 
        if(!m_xseq || !m_yseq)            
            throw std::bad_alloc();
    }
    ~Seq2d()
    {
         delete[] m_xseq;
         delete[] m_yseq;
    }
    
    int ** m_xseq; 
    int  * m_yseq;
};
 
int main()
{
    try
    {
        Seq2d(100, 500);
    }
    catch(const std::exception& e)
    {
        std::cerr << e.what();
        return EXIT_FAILURE;
    }
    return EXIT_SUCCESS;
}

#include <stdexcept>
#include <iostream>
#include <cstdlib>
#include <string>
 
bool need_throw;
 
struct value
{
    value(const std::string& n) : name(n)
    {
        std::cout << "value: " << name << '\n';
        if(need_throw)
            throw std::runtime_error("simulate error: " + name);
        need_throw = true;
    }
        
    ~value()
    {
        std::cout << "~value: " << name << '\n';
    }
    
    std::string name;
};
 
struct sample
{
    sample(const sample&)            = delete;
    sample& operator=(const sample&) = delete;
    
    sample() : first(), second()
    {
        std::cout <<"body of sample`s constructor\n";
        try
        {
            first  = new value("first" );
            second = new value("second");
        }
        catch (const std::exception& e)
        {
            delete first;
            delete second;
            throw;
        }
    }
    
    ~sample()
    {
        delete first;
        delete second;
    }
    
    value* first;
    value* second;
};
 
 
int main()
{
    try 
    {
        sample example;
    }
    catch (const std::exception& e)
    {
        std::cerr << "main: " << e.what() << std::endl;
        return EXIT_FAILURE;
    }
    return EXIT_SUCCESS;
}