2 курс. Программирование на C++. Турнир 2, осень 2021

вход курсы / турниры задачи участники консоль модули компиляторы ключевые слова результаты

ru en cn

5788448

Пользователь

Матвеев Ян Альбертович

Время

23:55<< 16.11.2021 23:55 (27 д. 21:56) 23:56>>

Обработка

23:55 ... 23:55 (6,64 сек.)

Файл

5788448.cpp (CLang++ 5.0.0 + Address Sanitizer)

Турнир

2 курс. Программирование на C++. Турнир 2, осень 2021

Задача

C: Smart Pointer

Набор тестов

Ограничения

Время: 25с Память: 512Мб

Состояние [?]

LI	Ошибка проверки исходного кода

код | результаты

SmartPointer.hpp:20:  "public:" should be preceded by a blank line  [whitespace/blank_line] [3]
SmartPointer.hpp:144:  public: should be indented +1 space inside class Core  [whitespace/indent] [3]
SmartPointer.hpp:156:  Closing brace should be aligned with beginning of class SmartPointer  [whitespace/indent] [3]
SmartPointer.hpp:157:  Namespace should be terminated with "// namespace smart_pointer"  [readability/namespace] [5]
Done processing SmartPointer.hpp
Total errors found: 4

[печатать | | ]

≡

#pragma once
#include <utility>
#include <memory>
#include "Test.hpp"

namespace smart_pointer {
// `exception` class definition
class exception : std::exception {
        using base_class = std::exception;
        using base_class::base_class;
};

// `SmartPointer` class declaration
    template<
        typename T,
        typename Allocator>
class SmartPointer {
        // don't remove this macro
        ENABLE_CLASS_TESTS;
 public:
            using value_type = T;

explicit SmartPointer(value_type* xPtr = nullptr) :
                core((xPtr == nullptr ? nullptr : new Core(xPtr))) {
            }

// copy constructor
            SmartPointer(const SmartPointer& other) :
                core(other.core != nullptr ? other.core : nullptr) {
                if (core != nullptr) {
                    this->core->owners++;
                }
            }

// move constructor
            SmartPointer(SmartPointer&& other) :
                core(std::exchange(other.core, nullptr)) { }

// copy assigment
            SmartPointer& operator=(const SmartPointer& other) {
                this->~SmartPointer();
                this->core = other.core;
                if (this->core != nullptr) this->core->owners++;
                return *this;
            }

// move assigment
            SmartPointer& operator=(SmartPointer&& other) {
                this->~SmartPointer();
                this->core = std::move(other.core);
                other.core = nullptr;
                return *this;
            }

//
            SmartPointer& operator=(value_type* p) {
                this->~SmartPointer();
                if (p == nullptr) {
                    this->core = nullptr;
                } else {
                    this->core = new Core(p);
                }
                return *this;
            }

~SmartPointer() {
                if (this->core != nullptr) {
                    if (this->core->owners <= 1) {
                        delete this->core;
                    } else {
                        this->core->owners--;
                    }
                }
            }

// return reference to the object of class/type T
            // if SmartPointer contains nullptr throw `SmartPointer::exception`
            value_type& operator*() {
                if (this->core == nullptr || this->core->valPtr == nullptr) {
                    throw smart_pointer::exception();
                } else {
                    return *(this->core->valPtr);
                }
            }
            const value_type& operator*() const {
                if (this->core == nullptr || this->core->valPtr == nullptr) {
                    throw smart_pointer::exception();
                }
                return *(this->core->valPtr);
            }

// return pointer to the object of class/type T
            value_type* operator->() const {
                return this->get();
            }

value_type* get() const {
                if (this->core == nullptr) {
                    return nullptr;
                } else {
                    return this->core->valPtr;
                }
            }

// if pointer == nullptr => return false
            operator bool() const {
                if (this->core == nullptr || this->core->valPtr == nullptr) {
                    return false;
                } else {
                    return true;
                }
            }

decltype(auto) getCore() const {
                return static_cast<void*>(this->core);
            }

// if pointers points to the same address or both null => true
            template<typename U, typename AnotherAllocator>
            bool operator==(const SmartPointer<U, AnotherAllocator>& other)
            const {
                return this->getCore() == other.getCore();
            }

// if pointers points to the same address or both null => false
            template<typename U, typename AnotherAllocator>
            bool operator!=(const SmartPointer<U, AnotherAllocator>& other)
            const {
                return !(SmartPointer::operator==(other));
            }

// if smart pointer contains non-nullptr => return count owners
            // if smart pointer contains nullptr => return 0
            std::size_t count_owners() const {
                if (this->core == nullptr) {
                    return 0;
                } else {
                    return this->core->owners;
                }
            }

private:
            class Core {
 public:
                explicit Core(value_type* x) :
                    valPtr(x),
                    owners(1) { }
                ~Core() {
                    if (valPtr != nullptr) delete valPtr;
                }

value_type* valPtr;
                std::size_t owners;
            };
            Core* core;
    };
};

(5 185 b)

0.042s 0.009s 10