#include <cassert>
#include <cstddef>
#include <utility>
template <typename K, typename V>
struct key_value_pair {
using key_type = K;
using value_type = V;
key_value_pair()
: key_(),
value_()
{}
key_value_pair(key_type&& key, value_type&& value)
: key_(std::move(key)),
value_(std::move(value))
{}
key_value_pair(const key_value_pair& other)
: key_(other.key_),
value_(other.value_)
{}
key_value_pair(key_value_pair&& other)
: key_(std::move(other.key_)),
value_(std::move(other.value_))
{}
key_value_pair& operator =(key_value_pair&& other)
{
this->swap(std::move(other));
return *this;
}
void swap(key_value_pair&& other)
{
std::swap(this->key_, other.key_);
std::swap(this->value_, other.value_);
}
private:
key_type key_;
value_type value_;
};
template <typename K, typename V, std::size_t N>
class key_value_pair_stack {
public:
using value_type = key_value_pair<K, V>;
public:
key_value_pair_stack() : data_(), i_(0)
{
}
void push(value_type&& obj)
{
assert(i_ < N);
data_[i_++] = std::move(obj);
}
void push(
typename value_type::key_type&& key,
typename value_type::value_type&& value)
{
this->push(std::move(value_type(std::move(key), std::move(value))));
}
value_type pop()
{
assert(i_ > 0);
return data_[--i_];
}
std::size_t max_size() const
{
return N;
}
std::size_t size()
{
return i_;
}
void clear()
{
i_ = 0;
}
private:
value_type data_[N];
std::size_t i_;
};
constexpr std::size_t default_max_size = 5;
template <typename Key, typename Value>
using my_stack = key_value_pair_stack<Key, Value, default_max_size>;
int main() {
my_stack<int, double> s;
s.push(5, 10.);
s.push(4, 10.);
const auto t = s.pop(); //(4, 10.)
return 0;
}
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