Leetcode Peeking Iterator problem solution

import copy

class PeekingIterator(object):
    def __init__(self, iterator):
        self.iter = iterator

    def peek(self):
        peekIter = copy.copy(self.iter)
        return next(peekIter)

    def next(self):
        return next(self.iter)

    def hasNext(self):
        peekIter = copy.copy(self.iter)
        return next(peekIter, None) is not None

class PeekingIterator implements Iterator<Integer> {

    Iterator<Integer> iterator;
    Integer peek = Integer.MIN_VALUE;
    public PeekingIterator(Iterator<Integer> iterator) {
        // initialize any member here.
        this.iterator = iterator;
    }

    // Returns the next element in the iteration without advancing the iterator.
    public Integer peek() {
        if(peek == Integer.MIN_VALUE){
            peek = iterator.next();
            return peek; 
        }else{
            return peek;
        }
    }

    // hasNext() and next() should behave the same as in the Iterator interface.
    // Override them if needed.
    @Override
    public Integer next() {
        if(peek == Integer.MIN_VALUE){
            return iterator.next();
        }else{
            int value = peek;
            peek = Integer.MIN_VALUE;
            return value;   
        }
    }

    @Override
    public boolean hasNext() {
        return iterator.hasNext() || peek != Integer.MIN_VALUE;
    }
}

class PeekingIterator : public Iterator {
public:
    int val;
    int *cache=0;
    PeekingIterator(const vector<int>& nums) : Iterator(nums) {

    }

    int peek() {
        if (!cache) {
            val=Iterator::next();
            cache=&val;
        }
        return *cache;
    }

    int next() {
        if (cache) {
            int ret=*cache;
            cache=0;
            return ret;
        }
        else return Iterator::next();
    }

    bool hasNext() const {
        if (!Iterator::hasNext()&&!cache) return false;
        else return true;
    }
};

struct PeekingIterator {
    struct Iterator* iterator;
    bool hasPeeked;
    int next;
};

struct PeekingIterator* Constructor(struct Iterator* iter) {
    struct PeekingIterator* piter = malloc(sizeof(struct PeekingIterator));
    piter->iterator = iter;
    piter->hasPeeked = false;
    return piter;
}

int peek(struct PeekingIterator* obj) {
    if (!obj->hasPeeked) {
        obj->next = obj->iterator->next();
        obj->hasPeeked = true;
    }
    return obj->next;
}

int next(struct PeekingIterator* obj) {
    if (obj->hasPeeked) {
        obj->hasPeeked = false;
        return obj->next;
    }
    return obj->iterator->next();
}

bool hasNext(struct PeekingIterator* obj) {
    if (obj->hasPeeked) {
        return true;
    }
    return obj->iterator->hasNext();
}