#include <cstdlib>
#include <cstdio>
#include <cstdint>
#include <cstring>
#include <cerrno>
#include <iostream>

class AllocTest{
    private: std::string *in_class_str = NULL;
    private: std::string *local_str_ptr = NULL;

    public: AllocTest(){
        return;
    }

    public: void is_heap_or_stack( void *mem_addr ){
        if ( mem_addr == NULL ){
            std::cout << "Error: address is NULL\n";
            return;
        }
        if ( ((size_t)mem_addr << 8) >= 0x55000000000000 && ((size_t)mem_addr << 8) <= 0x5fffffffffffff ){
            std::cout << "Address is in heap memory area (address is " << mem_addr << ")\n";
            return;
        }
        else if ( ((size_t)mem_addr << 8) >= 0x7f000000000000 ){
            std::cout << "Address is in stack memory area (address is " << mem_addr << ")\n";
            return;
        }
        else
        {
            std::cout << "Unknown memory area (address is " << mem_addr << ")\n";
            return;
        }
    }

    public: void test_local_std_string(){
        std::string local_str( "test string" );
        this->local_str_ptr = &local_str;
        this->is_heap_or_stack( static_cast<void*>(&local_str) );
        return;
    }

    public: void local_std_string_exists(){
        if ( this->local_str_ptr == NULL ){
            std::cout << "Local std::string no longer exists in memory\n";
            return;
        }
        std::cout << "Local std::string is still non-NULL value: " << this->local_str_ptr->c_str() << "\n";
        return;
    }

    public: void test_new_std_string(){
        std::string *teststr = new std::string( "string created with new keyword" );
        this->is_heap_or_stack( static_cast<void*>(teststr) );
        delete teststr;
        return;
    }

    public: void test_in_class_str(){
        this->in_class_str = new std::string( "string created into class" );
        this->is_heap_or_stack( static_cast<void*>(this->in_class_str) );
        delete this->in_class_str;
        return;
    }

    public: ~AllocTest(){
        if ( this->local_str_ptr != NULL )
            this->local_str_ptr = NULL;
        return;
    }
};

int main( int argc, char *args[] ){
    AllocTest *alloc_test = new AllocTest();
    std::cout << "Testing class memory address\n";
    alloc_test->is_heap_or_stack( alloc_test );
    std::cout << "Testing locally created std::string\n";
    alloc_test->test_local_std_string();
    std::cout << "Checking if local std::string still exists in memory\n";
    alloc_test->local_std_string_exists();
    std::cout << "Testing std::string created with new keyword\n";
    alloc_test->test_new_std_string();
    std::cout << "Testing std::string created into class\n";
    alloc_test->test_in_class_str();
    delete alloc_test;
    exit( EXIT_SUCCESS );
}