ConcurrentQueueUHD

#include <queue>
#include <mutex>
#include <thread>
#include <iostream>
#include <complex>
#include <condition_variable>

typedef std::vector< std::complex<double> > complex_double_vector;

class concurrent_queue
{
private:
    std::queue<complex_double_vector *> the_queue;
    mutable std::mutex the_mutex;
    std::condition_variable the_condition_variable;
public:
    void push(complex_double_vector *data)
    {
        std::unique_lock<std::mutex> lock(the_mutex);
        the_queue.push(data);
        lock.unlock();
        the_condition_variable.notify_one();
    }

    bool empty() const
    {
        std::unique_lock<std::mutex> lock(the_mutex);
        return the_queue.empty();
    }

    bool try_pop()
    {
        std::unique_lock<std::mutex> lock(the_mutex);
        if(the_queue.empty())
        {
            return false;
        }
        return true;
    }
    complex_double_vector* return_pop()
    {
        std::unique_lock<std::mutex> lock(the_mutex);
        complex_double_vector* temp_ptr;
        temp_ptr = the_queue.front();
        the_queue.pop();
        return temp_ptr;
    }

    void wait_for_pop()
    {
        std::unique_lock<std::mutex> lock(the_mutex);
        while(the_queue.empty())
        {
            the_condition_variable.wait(lock);
        }
    }

};
concurrent_queue myqueue;


//std::mutex print_mutex;
void Producer()
{
    bool toggler;
    while(true)
    {
        complex_double_vector *ptr = new complex_double_vector(100);
        complex_double_vector& r = *ptr;
        if(toggler)
        {
            for(int i=0;i<100;i++)
                r[i] = std::complex<double>(1,2);
        }
        else
        {
            for(int i=0;i<100;i++)
                r[i] = std::complex<double>(10,20);
        }
        toggler = !toggler;
        myqueue.push(ptr);
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
}


void Consumer()
{
    complex_double_vector* ptr;
    complex_double_vector new_vector;

    myqueue.wait_for_pop(); //conditional_variable_for empty check and change state till queue is empty
    while(true)
    {
        if(myqueue.try_pop())
        {
            ptr = myqueue.return_pop();
            complex_double_vector &r = *ptr;
            typename complex_double_vector::const_iterator first = r.begin();
            typename complex_double_vector::const_iterator last = first + 10;
            complex_double_vector newvector = complex_double_vector(first,last);
            std::this_thread::sleep_for(std::chrono::seconds(1));
            {
                for(int i=0;i<10;i++)
                    std::cout << newvector[i] << " ";
                std::cout << std::endl;
            }
            delete[]
        }
        if(myqueue.empty())
        {
            std::cout << "There is not data is queue so the thread is exiting" << std::endl;
            exit(0);
        }
    }

}


int main()
{
    std::thread t1(Producer);
    std::thread t2(Consumer);

    t1.join();
    t2.join();

    return 0;
}