#如何获取指针变量指向的内存空间，分配了多少大小

#如何获取指针变量指向的内存空间，分配了多少大小

Karthik Iyengar 的nanolog github 来源
两个疑问，在代码里有写，

#include <iostream>
#include <thread>
#include <chrono>
#include <vector>

#include <atomic>
// 目的是为了看看线程这个指针变量// 指针就是数组，数组就是指针，退化的转变不回来了
struct SpinLock
    {
	SpinLock(std::atomic_flag & flag) : m_flag(flag)
	{
	    while (m_flag.test_and_set(std::memory_order_acquire));
	}

	~SpinLock()
	{
	    m_flag.clear(std::memory_order_release);
	}

    private:
	std::atomic_flag & m_flag;
    };


// 假设定义了NanoLogLine和SpinLock类
struct Person {
    int i{0};

    void printI() {
        std::cout << "i = " << i << std::endl;
    }

    void setI(int newValue) {
        i = newValue;
    }
};

enum class LogLevel {
    INFO
};



class RingBuffer {
public:
    struct Item {
        Item()
            : flag{ATOMIC_FLAG_INIT}
            , written(0) {
        }

        std::atomic_flag flag;
        char written;
        char padding[256 - sizeof(std::atomic_flag) - sizeof(char) - sizeof(Person)];
        Person logline;
    };

    RingBuffer(size_t const size)
        : m_size(size)
        , m_ring(static_cast<Item*>(std::malloc(size * sizeof(Item))))
        , m_write_index(0)
        , m_read_index(0) {
        for (size_t i = 0; i < m_size; ++i) {
            new (&m_ring[i]) Item();
        }
        static_assert(sizeof(Item) == 256, "Unexpected size != 256");
    }

    ~RingBuffer() {
        for (size_t i = 0; i < m_size; ++i) {
            m_ring[i].~Item();
        }
        std::free(m_ring);
    }

    void push(Person&& logline)  {
        unsigned int write_index = m_write_index.fetch_add(1, std::memory_order_relaxed) % m_size;
        Item& item = m_ring[write_index];
        SpinLock spinlock(item.flag);
        item.logline = std::move(logline);
        item.written = 1;
    }

    bool try_pop(Person& logline)  {
        Item& item = m_ring[m_read_index % m_size];
        SpinLock spinlock(item.flag);
        if (item.written == 1) {
            logline = std::move(item.logline);
            item.written = 0;
            ++m_read_index;
            return true;
        }
        return false;
    }

    RingBuffer(RingBuffer const&) = delete;
    RingBuffer& operator=(RingBuffer const&) = delete;


        // 怎么获取m_ring 变量的内存大小
    int get_size_of_m_ring(){
        return m_ring.size();
    }
public:
    size_t const m_size;
    Item* m_ring;
    std::atomic<unsigned int> m_write_index;
    char pad[64]; // do wut // 使得？ 作用？
    unsigned int m_read_index;
};


int main() {
    const size_t bufferSize = 10;
    RingBuffer buffer(bufferSize);

    // 启动一个生产者线程，模拟往环形缓冲区中推送日志

    
    std::cout << "Address of buffer.m_ring: " << sizeof(bufferSize) << std::endl; // 8 + 8 + 4 + 64 + 4
    // std::cout << "Address of buffer.m_ring: " << &(buffer.m_ring) << std::endl;

    std::thread producer([&]() {
        for (int i = 0; i < 2; ++i) {
            Person logline;
            logline.setI(i);
            buffer.push(std::move(logline));
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
        }
    });

    // 启动一个消费者线程，模拟从环形缓冲区中弹出日志
    std::thread consumer([&]() {
        for (int i = 0; i < 2; ++i) {
            Person logline;
            if (buffer.try_pop(logline)) {
                std::cout << "i value: " ;
                logline.printI() ;
                std::cout << std::endl;
            } else {
                std::cout << "Buffer is empty." << std::endl;
            }
            std::this_thread::sleep_for(std::chrono::milliseconds(200));
        }
    });

    std::cout << "Address of buffer.m_ring: " << &(buffer.m_ring) << std::endl;


    producer.join();
    consumer.join();



    return 0;
}