Не могу отловить крайние случаи

#include <iostream>
#include <cstdlib>
 
using namespace std;
int **m = 0;
int **mt = 0;
int rows =3, cols = 5;
int main() {
    
    int ** transpose(const int * const * m, unsigned rows, unsigned cols);
    
    transpose(m, rows, cols);
    for (int i = 0; i != cols; ++i) {
        for (int j = 0; j != rows; ++j)
            cout << mt[i][j] << " ";
        cout << endl;
    }
    void free_array2d(int **m, int rows, int cols);
    return 0;
}
 
 
int ** transpose(const int * const * m, unsigned rows, unsigned cols){
    
    int ** create_array2d(int rows, int cols);
    m=create_array2d(rows, cols);
    mt = create_array2d(cols, rows);
    int count = 0;
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j)
            cout << m[i][j] << " ";
        cout << endl;
    }
    for (int i = 0; i != cols; ++i) {
        for (int j = 0; j != rows; ++j)
            mt[i][j] = m[j][i];
    }
    
    return mt;
}
 
 
int ** create_array2d(int rows, int cols) {
 
        int ** m = new int*[rows];
        m[0] = new int[rows*cols];
        for (size_t i = 1; i != rows; i++)
            m[i] = m[i - 1] + cols;
        int count = 0;
        for (int i = 0; i != rows; ++i) {
            for (int j = 0; j != cols; ++j){
                m[i][j] = count;
                count++;
            }
        }
 
    
    return m;
}

#include <iostream>
using namespace std;
 
const char text[] = "";
const char pattern[] = "";
unsigned Strlen(const char *str);
int len_text = Strlen(text);
int len_pattern = Strlen(pattern);
int Strstr(const char *text, const char *pattern);
 
int main() {
    cout << Strstr(text, pattern);
    return 0;
}
 
int Strstr(const char *text, const char *pattern) {
    
    if (len_text < len_pattern) return -1;
    if ((len_text == 0) && (len_pattern == 0)) return 0;
    if ((len_text == 0) && (len_pattern != 0)) return -1;
    if ((len_text != 0) && (len_pattern == 0)) return 0;
    int j = 0;
    int i = 0;
    if ((len_text == 1) && (len_pattern == 1)) {
        if (*text == *pattern) { return 0; }
        else { return -1; }
    }
    else {
        for (i = 0; i < len_text; i++) {
            if (text[i] == pattern[j])
            {
                j++;
            }
            else
            {
                if (j > 0) i -= j;
                j = 0;  
            }
 
            if (j == len_pattern)
            {
                return i - len_pattern + 1;
            }
        }
    }
    if (i == len_text - len_pattern + 1) return -1;
 
    return -1;
}
 
unsigned Strlen(const char *str) {
    int count1 = 0;
    while (*str != 0) {
        str++;
        count1++;
 
    }
    return count1;
}

#include <iostream>
#include <limits.h>
 
struct Number;
struct BinaryOperation;
 
struct Visitor {
    virtual void visitNumber(Number const * number) = 0;
    virtual void visitBinaryOperation(BinaryOperation const * operation) = 0;
    virtual ~Visitor() { }
};
 
struct Expression
{
    virtual double evaluate() const = 0;
    virtual void visit(Visitor * vistitor) const = 0;
    virtual ~Expression() {}
};
 
struct Number : Expression
{
    Number(double value) { this->value=value; }
    double evaluate() const{ return value; }
 
    double get_value() const { return value; }
 
    void visit(Visitor * visitor) const { visitor->visitNumber(this); }
 
private:
    double value;
};
 
struct BinaryOperation : Expression
{
    enum {
            PLUS = '+',
            MINUS = '-',
            DIV = '/',
            MUL = '*'
        };
    BinaryOperation(Expression const * left, char op, Expression const * right) : left(left), op(op), right(right)
    {  }
    ~BinaryOperation() {
            delete left;
            delete right;
        }
 
    double evaluate() const
{
        double left = this->left->evaluate();
        double right = this->right->evaluate();
        switch (op)
        {
        case PLUS: return left + right;
        case MINUS: return left - right;
        case DIV: return left / right;
        case MUL: return left * right;
        }
        return 0.0;
    }
 
    Expression const * get_left() const { return left; }
    Expression const * get_right() const { return right; }
    char get_op() const { return op; }
 
    void visit(Visitor * visitor) const { visitor->visitBinaryOperation(this); }
 
private:
    Expression const * left;
    Expression const * right;
    char op;
};
 
struct PrintVisitor : Visitor {
    void visitNumber(Number const * number)
    {
        std::cout << number->get_value() << " ";
    }
 
    void visitBinaryOperation(BinaryOperation const * bop)
    {
        std::cout << '(';
        bop->get_left()->visit(this);
        std::cout << bop->get_op() << " ";
        bop->get_right()->visit(this);
        std::cout << ')';
    }
};
 
int main() {
    Expression * l = new Number(7);
      Expression * r = new Number(2);
      BinaryOperation evo = BinaryOperation(l, '/', r);
      Visitor *v = new PrintVisitor;
      evo.visit(v);
 
  return 0;
}

#include <cstddef>
#include <iostream>
 
#include <vld.h>
 
struct Expression
{
    virtual double evaluate() const = 0;
    virtual ~Expression() {}
 
};
 
struct Number : Expression
{
    Number(double value)
    : value(value)
    {}
    ~Number() { }
    double evaluate() const {
        return value;
    }
private:
    double value;
};
 
struct BinaryOperation : Expression
{
 
    BinaryOperation(Expression const * left, char op, Expression const * right)
    : left(left), op(op), right(right)
    { }
 
    double evaluate() const {
 
        if (op == '+') return left->evaluate() + right->evaluate();
        if (op == '-') return left->evaluate() - right->evaluate();
        if (op == '*') return left->evaluate() * right->evaluate();
        if (op == '/') return left->evaluate() / right->evaluate();
    }
    ~BinaryOperation() {
        delete left;
        delete right;
    }
private:
    Expression const * left;
    Expression const * right;
    char op;
};
 
struct SharedPtr
{
    // реализуйте следующие методы
    //
    std::size_t count() const {
        if (stored) {
            return stored->count;
        }
        return 0;
    }
    /*Expression* get() const {
    return stored->ptr_;
    }*/
 
    //void reset(Expression *ptr = 0) {
    //  this->~SharedPtr();
    //  new (this) SharedPtr(ptr);
    //}
 
    /*Expression& operator*() const { return *get(); }
    Expression* operator->() const { return stored->ptr_; }*/
 
    //SharedPtr() : stored(0) {}
 
    explicit SharedPtr(int * const ptr) : stored(new storage(ptr)) {}
 
    //SharedPtr(SharedPtr const& other) : stored(other.stored) {
    //  increment();
    //}
 
    //SharedPtr & operator =(SharedPtr const& other) {
    //  if (stored != other.stored) {
    //      decrement();
    //      stored = other.stored;
    //      increment();
    //  }
    //  return *this;
    //}
 
    ~SharedPtr() {
        decrement();
    }
private:
    /*void increment() {
    if (stored) {
    ++stored->count;
    }
    }*/
 
    void decrement() {
        if (stored && (--stored->count == 0)) {
            delete stored->ptr_;
            delete stored;
            stored = 0;
        }
    }
 
    struct storage {
 
        explicit storage(int * const ptr) : ptr_(ptr), count(1) {}
        
        int * ptr_;
        std::size_t    count;
    };
 
    storage * stored;
 
};
 
int main() {
    int a = 10;
    int * b = &a;
    SharedPtr a1(b);
    std::cout << a1.count() << std::endl;
    if (_CrtDumpMemoryLeaks())
        std::cout << "memory leak is detected" << std::endl;
    else
        std::cout << "no memory leaks" << std::endl;
    return 0;
}

    void reset(int *ptr = 0) {
        if (stored && (--stored->count == 0)) {
            delete stored->ptr_;
            delete stored;
            stored = 0;
        }
        storage stored(ptr);
    }

 if(stored->count>1) --stored->count;

struct String {
    String(const char *str = "");
    String(size_t n, char c);
    ~String();
 
    String(const String &other);
    String &operator=(const String &other);
 
    void append(const String &other);
 
 
 
    struct SubString{
 
        String* str_str;
        int sub_i;
 
        SubString(String* str, int i)
            :str_str(str), sub_i(i)
        {   
            
        }
 
        String operator[](int j) const
        {
           return str_str[j];
        }
    
    };
 
    SubString operator[](int i)
    {
       return SubString(this,i);
    }
 
 
 
    size_t size;
    char *str;
};

struct String {
    String(const char *str = "");
    String(size_t n, char c);
    ~String();
 
    String(const String &other);
    String &operator=(const String &other);
 
    void append(const String &other);
    
    struct SubString{
 
        String* str_str;
        int sub_i;
 
        SubString(String* str, int i)
            :str_str(str), sub_i(i)
        {   
            
        }
 
        ~SubString();
 
        String operator[](int j) const
        {
           String* temp = new String[j - sub_i+1];
           for (int k=0; k < sizeof(temp); ++k)
           {
              temp[k] = str_str[sub_i+k];
           }
           temp[j+1] = "0";
           return *temp;
        }
 
    };
 
    SubString operator[](int i)
    {
       return SubString(this,i);
    }
 
    size_t size;
    char *str;
};