Ideone.com

download

#ifndef VECTOR_H_
#define VECTOR_H_
 
#include <memory>
#include <stdexcept>
#include <type_traits>
 
namespace lab_07 {
    template <typename T, typename Alloc = std::allocator<T>>
    class vector {
        static_assert(std::is_nothrow_move_constructible_v<T>);
        static_assert(std::is_nothrow_move_assignable_v<T>);
        static_assert(std::is_nothrow_destructible_v<T>);
    private:
        std::size_t Capacity;
        std::size_t Size;
        std::unique_ptr<T[]> Data;
    public:
        vector() : Capacity(1), Size(0), Data(std::unique_ptr<T[]>{Alloc().allocate(Capacity)}) {}
 
        explicit vector(std::size_t n) {
            Capacity = 1;
            while (Capacity < n) {
                Capacity *= 2;
            }
            Size = n;
            Data = std::unique_ptr<T[]>{Alloc().allocate(Capacity)};
        }
 
        vector(std::size_t n, const T & value) : Capacity(1), Size(0), Data(std::unique_ptr<T[]>{Alloc().allocate(Capacity)}) {
            for (std::size_t i = 0; i < n; i++) {
                push_back(value);
            }
        }
 
        vector (const vector & other) : Capacity(other.Capacity), Size(other.Size), Data(std::unique_ptr<T[]>{Alloc().allocate(Capacity)}) {
            for (std::size_t i = 0; i < Size; i++) {
                Data[i] = other.Data[i];
            }
        }
 
        vector (vector &&) noexcept = default;
 
        vector & operator=(const vector & other) {
            Capacity = other.Capacity;
            Size = other.Size;
            Data.reset(Alloc().allocate(Capacity));
            for (std::size_t i = 0; i < Size; i++) {
                Data[i] = other.Data[i];
            }
            return *this;
        }
 
        vector & operator=(vector &&) noexcept = default;
 
        [[nodiscard]] bool empty() const {
            return Size == 0;
        }
 
        [[nodiscard]] std::size_t size() const {
            return Size;
        }
 
        [[nodiscard]] std::size_t capacity() const {
            return Capacity;
        }
 
        void push_back(const T & value) {
            if constexpr (std::is_move_assignable<T>::value) {
                Data[Size] = std::move(value);
            } else {
                Data[Size] = value;
            }
            Size++;
            if (Size == Capacity) {
                Capacity *= 2;
                std::unique_ptr<T[]> NewData(std::unique_ptr<T[]>{Alloc().allocate(Capacity)});
                for (std::size_t i = 0; i < Size; i++) {
                    if constexpr (std::is_move_assignable<T>::value) {
                        NewData[i] = std::move(Data[i]);
                    } else {
                        NewData[i] = Data[i];
                    }
                }
                Data = std::move(NewData);
            }
        }
 
        void push_back(T && value) {
            Data[Size] = std::move(value);
            Size++;
            if (Size == Capacity) {
                Capacity *= 2;
                std::unique_ptr<T[]> NewData(std::unique_ptr<T[]>{Alloc().allocate(Capacity)});
                for (std::size_t i = 0; i < Size; i++) {
                    NewData[i] = std::move(Data[i]);
                }
                Data = std::move(NewData);
            }
        }
 
        void pop_back() {
            Size--;
        }
 
        void clear() {
            Size = 0;
            Capacity = 1;
            Data.reset(Alloc().allocate(Capacity));
        }
 
        void resize(std::size_t k) {
            Size = k;
            if (Size >= Capacity) {
                while (Size >= Capacity) {
                    Capacity *= 2;
                }
                std::unique_ptr<T[]> NewData(std::unique_ptr<T[]>{Alloc().allocate(Capacity)});
                for (std::size_t i = 0; i < Size; i++) {
                    if constexpr (std::is_move_assignable<T>::value) {
                        NewData[i] = std::move(Data[i]);
                    } else {
                        NewData[i] = Data[i];
                    }
                }
                Data = std::move(NewData);
            }
        }
 
        void resize(std::size_t k, const T & value) {
            std::size_t OldSize = Size;
            Size = k;
            if (Size >= Capacity) {
                while (Size >= Capacity) {
                    Capacity *= 2;
                }
                std::unique_ptr<T[]> NewData(std::unique_ptr<T[]>{Alloc().allocate(Capacity)});
                for (std::size_t i = 0; i < Size; i++) {
                    if constexpr (std::is_move_assignable<T>::value) {
                        NewData[i] = std::move(Data[i]);
                    } else {
                        NewData[i] = Data[i];
                    }
                }
                Data = std::move(NewData);
            }
            for (std::size_t i = OldSize; i < Size; i++) {
                Data[i] = value;
            }
        }
 
        void reserve(std::size_t k) {
            resize(k);
        }
 
        T & at(std::size_t k) {
            if (k >= Size) {
                throw std::out_of_range(":) KAKAR-TO XYNHR (:");
            }
            return Data[k];
        }
 
        const T & at(std::size_t k) const {
            if (k >= Size) {
                throw std::out_of_range(":) KAKAR-TO XYNHR (:");
            }
            return Data[k];
        }
 
        T & operator[](std::size_t k) {
            return Data[k];
        }
 
        const T & operator[](std::size_t k) const {
            return Data[k];
        }
 
        ~vector() = default;
    };
 
}  // namespace lab_07
 
#endif  // VECTOR_H_
 
 
 
 
 
 
 
 
struct MinimalObj {
    int id;  // NOLINT(misc-non-private-member-variables-in-classes)
 
    // Draft check for leaks, double-frees and non-inits.
    // NOLINTNEXTLINE(misc-non-private-member-variables-in-classes)
    std::string data = std::string(500U, 'x');
 
    explicit MinimalObj(int id_) : id(id_) {}
    MinimalObj(MinimalObj &&) = default;
    MinimalObj &operator=(MinimalObj &&) = default;
 
    MinimalObj(const MinimalObj &) = delete;
    MinimalObj &operator=(const MinimalObj &) = delete;
 
    ~MinimalObj() = default;
};
 
signed main() {
    lab_07::vector<MinimalObj> v;
    MinimalObj a{5};
    v.push_back(a);
    v.pop_back();
    if (v.size() == 4) {}
    if (v.empty()) {}
    return 0;
}

#ifndef VECTOR_H_
#define VECTOR_H_

#include <memory>
#include <stdexcept>
#include <type_traits>

namespace lab_07 {
    template <typename T, typename Alloc = std::allocator<T>>
    class vector {
        static_assert(std::is_nothrow_move_constructible_v<T>);
        static_assert(std::is_nothrow_move_assignable_v<T>);
        static_assert(std::is_nothrow_destructible_v<T>);
    private:
        std::size_t Capacity;
        std::size_t Size;
        std::unique_ptr<T[]> Data;
    public:
        vector() : Capacity(1), Size(0), Data(std::unique_ptr<T[]>{Alloc().allocate(Capacity)}) {}

        explicit vector(std::size_t n) {
            Capacity = 1;
            while (Capacity < n) {
                Capacity *= 2;
            }
            Size = n;
            Data = std::unique_ptr<T[]>{Alloc().allocate(Capacity)};
        }

        vector(std::size_t n, const T & value) : Capacity(1), Size(0), Data(std::unique_ptr<T[]>{Alloc().allocate(Capacity)}) {
            for (std::size_t i = 0; i < n; i++) {
                push_back(value);
            }
        }

        vector (const vector & other) : Capacity(other.Capacity), Size(other.Size), Data(std::unique_ptr<T[]>{Alloc().allocate(Capacity)}) {
            for (std::size_t i = 0; i < Size; i++) {
                Data[i] = other.Data[i];
            }
        }

        vector (vector &&) noexcept = default;

        vector & operator=(const vector & other) {
            Capacity = other.Capacity;
            Size = other.Size;
            Data.reset(Alloc().allocate(Capacity));
            for (std::size_t i = 0; i < Size; i++) {
                Data[i] = other.Data[i];
            }
            return *this;
        }

        vector & operator=(vector &&) noexcept = default;

        [[nodiscard]] bool empty() const {
            return Size == 0;
        }

        [[nodiscard]] std::size_t size() const {
            return Size;
        }

        [[nodiscard]] std::size_t capacity() const {
            return Capacity;
        }

        void push_back(const T & value) {
            if constexpr (std::is_move_assignable<T>::value) {
                Data[Size] = std::move(value);
            } else {
                Data[Size] = value;
            }
            Size++;
            if (Size == Capacity) {
                Capacity *= 2;
                std::unique_ptr<T[]> NewData(std::unique_ptr<T[]>{Alloc().allocate(Capacity)});
                for (std::size_t i = 0; i < Size; i++) {
                    if constexpr (std::is_move_assignable<T>::value) {
                        NewData[i] = std::move(Data[i]);
                    } else {
                        NewData[i] = Data[i];
                    }
                }
                Data = std::move(NewData);
            }
        }

        void push_back(T && value) {
            Data[Size] = std::move(value);
            Size++;
            if (Size == Capacity) {
                Capacity *= 2;
                std::unique_ptr<T[]> NewData(std::unique_ptr<T[]>{Alloc().allocate(Capacity)});
                for (std::size_t i = 0; i < Size; i++) {
                    NewData[i] = std::move(Data[i]);
                }
                Data = std::move(NewData);
            }
        }

        void pop_back() {
            Size--;
        }

        void clear() {
            Size = 0;
            Capacity = 1;
            Data.reset(Alloc().allocate(Capacity));
        }

        void resize(std::size_t k) {
            Size = k;
            if (Size >= Capacity) {
                while (Size >= Capacity) {
                    Capacity *= 2;
                }
                std::unique_ptr<T[]> NewData(std::unique_ptr<T[]>{Alloc().allocate(Capacity)});
                for (std::size_t i = 0; i < Size; i++) {
                    if constexpr (std::is_move_assignable<T>::value) {
                        NewData[i] = std::move(Data[i]);
                    } else {
                        NewData[i] = Data[i];
                    }
                }
                Data = std::move(NewData);
            }
        }

        void resize(std::size_t k, const T & value) {
            std::size_t OldSize = Size;
            Size = k;
            if (Size >= Capacity) {
                while (Size >= Capacity) {
                    Capacity *= 2;
                }
                std::unique_ptr<T[]> NewData(std::unique_ptr<T[]>{Alloc().allocate(Capacity)});
                for (std::size_t i = 0; i < Size; i++) {
                    if constexpr (std::is_move_assignable<T>::value) {
                        NewData[i] = std::move(Data[i]);
                    } else {
                        NewData[i] = Data[i];
                    }
                }
                Data = std::move(NewData);
            }
            for (std::size_t i = OldSize; i < Size; i++) {
                Data[i] = value;
            }
        }

        void reserve(std::size_t k) {
            resize(k);
        }

        T & at(std::size_t k) {
            if (k >= Size) {
                throw std::out_of_range(":) KAKAR-TO XYNHR (:");
            }
            return Data[k];
        }

        const T & at(std::size_t k) const {
            if (k >= Size) {
                throw std::out_of_range(":) KAKAR-TO XYNHR (:");
            }
            return Data[k];
        }

        T & operator[](std::size_t k) {
            return Data[k];
        }

        const T & operator[](std::size_t k) const {
            return Data[k];
        }

        ~vector() = default;
    };

}  // namespace lab_07

#endif  // VECTOR_H_








struct MinimalObj {
    int id;  // NOLINT(misc-non-private-member-variables-in-classes)

    // Draft check for leaks, double-frees and non-inits.
    // NOLINTNEXTLINE(misc-non-private-member-variables-in-classes)
    std::string data = std::string(500U, 'x');

    explicit MinimalObj(int id_) : id(id_) {}
    MinimalObj(MinimalObj &&) = default;
    MinimalObj &operator=(MinimalObj &&) = default;

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

    ~MinimalObj() = default;
};

signed main() {
    lab_07::vector<MinimalObj> v;
    MinimalObj a{5};
    v.push_back(a);
    v.pop_back();
    if (v.size() == 4) {}
    if (v.empty()) {}
    return 0;
}

Compilation error #stdin compilation error #stdout 0s 0KB

stdin

Standard input is empty

compilation info

Main.java:1: error: illegal character: '#'
#ifndef VECTOR_H_
^
Main.java:2: error: illegal character: '#'
#define VECTOR_H_
^
Main.java:4: error: illegal character: '#'
#include <memory>
^
Main.java:5: error: illegal character: '#'
#include <stdexcept>
^
Main.java:6: error: illegal character: '#'
#include <type_traits>
^
Main.java:11: error: invalid method declaration; return type required
        static_assert(std::is_nothrow_move_constructible_v<T>);
        ^
Main.java:11: error: <identifier> expected
        static_assert(std::is_nothrow_move_constructible_v<T>);
                         ^
Main.java:11: error: illegal start of type
        static_assert(std::is_nothrow_move_constructible_v<T>);
                                                             ^
Main.java:12: error: invalid method declaration; return type required
        static_assert(std::is_nothrow_move_assignable_v<T>);
        ^
Main.java:12: error: <identifier> expected
        static_assert(std::is_nothrow_move_assignable_v<T>);
                         ^
Main.java:12: error: illegal start of type
        static_assert(std::is_nothrow_move_assignable_v<T>);
                                                          ^
Main.java:13: error: invalid method declaration; return type required
        static_assert(std::is_nothrow_destructible_v<T>);
        ^
Main.java:13: error: <identifier> expected
        static_assert(std::is_nothrow_destructible_v<T>);
                         ^
Main.java:13: error: illegal start of type
        static_assert(std::is_nothrow_destructible_v<T>);
                                                       ^
Main.java:14: error: illegal start of type
    private:
           ^
Main.java:15: error: <identifier> expected
        std::size_t Capacity;
           ^
Main.java:16: error: <identifier> expected
        std::size_t Size;
           ^
Main.java:17: error: <identifier> expected
        std::unique_ptr<T[]> Data;
           ^
Main.java:18: error: illegal start of type
    public:
          ^
Main.java:19: error: ';' expected
        vector() : Capacity(1), Size(0), Data(std::unique_ptr<T[]>{Alloc().allocate(Capacity)}) {}
                ^
Main.java:19: error: > expected
        vector() : Capacity(1), Size(0), Data(std::unique_ptr<T[]>{Alloc().allocate(Capacity)}) {}
                                                               ^
Main.java:19: error: ';' expected
        vector() : Capacity(1), Size(0), Data(std::unique_ptr<T[]>{Alloc().allocate(Capacity)}) {}
                                                                                             ^
Main.java:19: error: illegal start of type
        vector() : Capacity(1), Size(0), Data(std::unique_ptr<T[]>{Alloc().allocate(Capacity)}) {}
                                                                                              ^
Main.java:21: error: <identifier> expected
        explicit vector(std::size_t n) {
                           ^
Main.java:27: error: '.class' expected
            Data = std::unique_ptr<T[]>{Alloc().allocate(Capacity)};
                                      ^
Main.java:27: error: illegal start of expression
            Data = std::unique_ptr<T[]>{Alloc().allocate(Capacity)};
                                       ^
Main.java:27: error: ';' expected
            Data = std::unique_ptr<T[]>{Alloc().allocate(Capacity)};
                                                                  ^
Main.java:30: error: <identifier> expected
        vector(std::size_t n, const T & value) : Capacity(1), Size(0), Data(std::unique_ptr<T[]>{Alloc().allocate(Capacity)}) {
                  ^
Main.java:30: error: > expected
        vector(std::size_t n, const T & value) : Capacity(1), Size(0), Data(std::unique_ptr<T[]>{Alloc().allocate(Capacity)}) {
                                                                                             ^
Main.java:30: error: ';' expected
        vector(std::size_t n, const T & value) : Capacity(1), Size(0), Data(std::unique_ptr<T[]>{Alloc().allocate(Capacity)}) {
                                                                                                                           ^
Main.java:30: error: illegal start of type
        vector(std::size_t n, const T & value) : Capacity(1), Size(0), Data(std::unique_ptr<T[]>{Alloc().allocate(Capacity)}) {
                                                                                                                            ^
Main.java:31: error: not a statement
            for (std::size_t i = 0; i < n; i++) {
                 ^
Main.java:31: error: ';' expected
            for (std::size_t i = 0; i < n; i++) {
                            ^
Main.java:31: error: not a statement
            for (std::size_t i = 0; i < n; i++) {
                                      ^
Main.java:31: error: ')' expected
            for (std::size_t i = 0; i < n; i++) {
                                         ^
Main.java:31: error: ';' expected
            for (std::size_t i = 0; i < n; i++) {
                                              ^
Main.java:36: error: illegal start of type
        vector (const vector & other) : Capacity(other.Capacity), Size(other.Size), Data(std::unique_ptr<T[]>{Alloc().allocate(Capacity)}) {
                ^
Main.java:36: error: > expected
        vector (const vector & other) : Capacity(other.Capacity), Size(other.Size), Data(std::unique_ptr<T[]>{Alloc().allocate(Capacity)}) {
                                                                                                          ^
Main.java:36: error: ';' expected
        vector (const vector & other) : Capacity(other.Capacity), Size(other.Size), Data(std::unique_ptr<T[]>{Alloc().allocate(Capacity)}) {
                                                                                                                                        ^
Main.java:36: error: illegal start of type
        vector (const vector & other) : Capacity(other.Capacity), Size(other.Size), Data(std::unique_ptr<T[]>{Alloc().allocate(Capacity)}) {
                                                                                                                                         ^
Main.java:37: error: not a statement
            for (std::size_t i = 0; i < Size; i++) {
                 ^
Main.java:37: error: ';' expected
            for (std::size_t i = 0; i < Size; i++) {
                            ^
Main.java:37: error: not a statement
            for (std::size_t i = 0; i < Size; i++) {
                                      ^
Main.java:37: error: ')' expected
            for (std::size_t i = 0; i < Size; i++) {
                                            ^
Main.java:37: error: ';' expected
            for (std::size_t i = 0; i < Size; i++) {
                                                 ^
Main.java:42: error: <identifier> expected
        vector (vector &&) noexcept = default;
                      ^
Main.java:44: error: <identifier> expected
        vector & operator=(const vector & other) {
              ^
Main.java:44: error: <identifier> expected
        vector & operator=(const vector & other) {
                         ^
Main.java:44: error: illegal start of expression
        vector & operator=(const vector & other) {
                           ^
Main.java:44: error: <identifier> expected
        vector & operator=(const vector & other) {
                                       ^
Main.java:44: error: <identifier> expected
        vector & operator=(const vector & other) {
                                               ^
Main.java:48: error: not a statement
            for (std::size_t i = 0; i < Size; i++) {
                 ^
Main.java:48: error: ';' expected
            for (std::size_t i = 0; i < Size; i++) {
                            ^
Main.java:48: error: not a statement
            for (std::size_t i = 0; i < Size; i++) {
                                      ^
Main.java:48: error: ')' expected
            for (std::size_t i = 0; i < Size; i++) {
                                            ^
Main.java:48: error: ';' expected
            for (std::size_t i = 0; i < Size; i++) {
                                                 ^
Main.java:51: error: illegal start of expression
            return *this;
                   ^
Main.java:54: error: <identifier> expected
        vector & operator=(vector &&) noexcept = default;
              ^
Main.java:54: error: <identifier> expected
        vector & operator=(vector &&) noexcept = default;
                         ^
Main.java:54: error: illegal start of expression
        vector & operator=(vector &&) noexcept = default;
                                    ^
Main.java:54: error: ';' expected
        vector & operator=(vector &&) noexcept = default;
                                     ^
Main.java:54: error: <identifier> expected
        vector & operator=(vector &&) noexcept = default;
                                              ^
Main.java:54: error: illegal start of expression
        vector & operator=(vector &&) noexcept = default;
                                                 ^
Main.java:56: error: illegal start of type
        [[nodiscard]] bool empty() const {
        ^
Main.java:56: error: ']' expected
        [[nodiscard]] bool empty() const {
         ^
Main.java:56: error: ']' expected
        [[nodiscard]] bool empty() const {
          ^
Main.java:56: error: <identifier> expected
        [[nodiscard]] bool empty() const {
                   ^
Main.java:56: error: ';' expected
        [[nodiscard]] bool empty() const {
                                  ^
Main.java:60: error: illegal start of type
        [[nodiscard]] std::size_t size() const {
        ^
Main.java:60: error: ']' expected
        [[nodiscard]] std::size_t size() const {
         ^
Main.java:60: error: ']' expected
        [[nodiscard]] std::size_t size() const {
          ^
Main.java:60: error: <identifier> expected
        [[nodiscard]] std::size_t size() const {
                   ^
Main.java:60: error: <identifier> expected
        [[nodiscard]] std::size_t size() const {
                         ^
Main.java:60: error: ';' expected
        [[nodiscard]] std::size_t size() const {
                                        ^
Main.java:64: error: illegal start of type
        [[nodiscard]] std::size_t capacity() const {
        ^
Main.java:64: error: ']' expected
        [[nodiscard]] std::size_t capacity() const {
         ^
Main.java:64: error: ']' expected
        [[nodiscard]] std::size_t capacity() const {
          ^
Main.java:64: error: <identifier> expected
        [[nodiscard]] std::size_t capacity() const {
                   ^
Main.java:64: error: <identifier> expected
        [[nodiscard]] std::size_t capacity() const {
                         ^
Main.java:64: error: ';' expected
        [[nodiscard]] std::size_t capacity() const {
                                            ^
Main.java:68: error: illegal start of type
        void push_back(const T & value) {
                       ^
Main.java:69: error: '(' expected
            if constexpr (std::is_move_assignable<T>::value) {
              ^
Main.java:69: error: illegal start of expression
            if constexpr (std::is_move_assignable<T>::value) {
                                                    ^
Main.java:70: error: ';' expected
                Data[Size] = std::move(value);
                                      ^
Main.java:70: error: not a statement
                Data[Size] = std::move(value);
                                       ^
Main.java:70: error: ';' expected
                Data[Size] = std::move(value);
                                            ^
Main.java:77: error: '.class' expected
                std::unique_ptr<T[]> NewData(std::unique_ptr<T[]>{Alloc().allocate(Capacity)});
                                   ^
Main.java:77: error: '.class' expected
                std::unique_ptr<T[]> NewData(std::unique_ptr<T[]>{Alloc().allocate(Capacity)});
                                                                ^
Main.java:77: error: illegal start of expression
                std::unique_ptr<T[]> NewData(std::unique_ptr<T[]>{Alloc().allocate(Capacity)});
                                                                 ^
Main.java:77: error: ';' expected
                std::unique_ptr<T[]> NewData(std::unique_ptr<T[]>{Alloc().allocate(Capacity)});
                                                                                            ^
Main.java:77: error: illegal start of expression
                std::unique_ptr<T[]> NewData(std::unique_ptr<T[]>{Alloc().allocate(Capacity)});
                                                                                             ^
Main.java:78: error: not a statement
                for (std::size_t i = 0; i < Size; i++) {
                     ^
Main.java:78: error: ';' expected
                for (std::size_t i = 0; i < Size; i++) {
                                ^
Main.java:78: error: not a statement
                for (std::size_t i = 0; i < Size; i++) {
                                          ^
Main.java:78: error: ')' expected
                for (std::size_t i = 0; i < Size; i++) {
                                                ^
Main.java:78: error: ';' expected
                for (std::size_t i = 0; i < Size; i++) {
                                                     ^
Main.java:79: error: '(' expected
                    if constexpr (std::is_move_assignable<T>::value) {
                      ^
Main.java:79: error: illegal start of expression
                    if constexpr (std::is_move_assignable<T>::value) {
                                                            ^
Main.java:80: error: ';' expected
                        NewData[i] = std::move(Data[i]);
                                              ^
Main.java:80: error: not a statement
                        NewData[i] = std::move(Data[i]);
                                                   ^
100 errors

stdout

Standard output is empty

https://ideone.com/MydUWJ

language:

Java (HotSpot 12)

created:

visibility:

public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!

Discover > Sphere Engine API

Discover > IDE Widget

Choose your language