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

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

ru en cn

5787082

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

Thanks to the CWC partners from the GreenTeaNeko

Время

20:42<< 16.11.2021 20:43 (27 д. 18:44) 20:49>>

Обработка

20:43 ... 20:43 (1,48 сек.)

Файл

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

Турнир

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

Задача

C: Smart Pointer

Набор тестов

Ограничения

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

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

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

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

SmartPointer.hpp:8:  Do not indent within a namespace  [runtime/indentation_namespace] [4]
SmartPointer.hpp:17:  Do not indent within a namespace  [runtime/indentation_namespace] [4]
SmartPointer.hpp:27:  An else should appear on the same line as the preceding }  [whitespace/newline] [4]
SmartPointer.hpp:27:  If an else has a brace on one side, it should have it on both  [readability/braces] [5]
SmartPointer.hpp:78:  An else should appear on the same line as the preceding }  [whitespace/newline] [4]
SmartPointer.hpp:78:  If an else has a brace on one side, it should have it on both  [readability/braces] [5]
SmartPointer.hpp:92:  An else should appear on the same line as the preceding }  [whitespace/newline] [4]
SmartPointer.hpp:92:  If an else has a brace on one side, it should have it on both  [readability/braces] [5]
SmartPointer.hpp:101:  An else should appear on the same line as the preceding }  [whitespace/newline] [4]
SmartPointer.hpp:101:  If an else has a brace on one side, it should have it on both  [readability/braces] [5]
SmartPointer.hpp:110:  An else should appear on the same line as the preceding }  [whitespace/newline] [4]
SmartPointer.hpp:110:  If an else has a brace on one side, it should have it on both  [readability/braces] [5]
SmartPointer.hpp:119:  An else should appear on the same line as the preceding }  [whitespace/newline] [4]
SmartPointer.hpp:119:  If an else has a brace on one side, it should have it on both  [readability/braces] [5]
SmartPointer.hpp:146:  An else should appear on the same line as the preceding }  [whitespace/newline] [4]
SmartPointer.hpp:146:  If an else has a brace on one side, it should have it on both  [readability/braces] [5]
SmartPointer.hpp:164:  Closing brace should be aligned with beginning of class SmartPointer  [whitespace/indent] [3]
SmartPointer.hpp:165:  Namespace should be terminated with "// namespace smart_pointer"  [readability/namespace] [5]
SmartPointer.hpp:165:  Line ends in whitespace.  Consider deleting these extra spaces.  [whitespace/end_of_line] [4]
Done processing SmartPointer.hpp
Total errors found: 19

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

≡

#include <memory>
#include "Test.hpp"

#ifndef SMARTPOINTER_HPP
#define SMARTPOINTER_HPP

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

template<
        typename T,
        typename Allocator
    >
        class SmartPointer {
        ENABLE_CLASS_TESTS;

public:
            using value_type = T;

explicit SmartPointer(value_type* x = nullptr) {
                if (x == nullptr) {
                    this->core = nullptr;
                }
                else {
                    this->core = new Core();
                    core->info = x;
                    core->cnt = 1;
                }
            }

SmartPointer(const SmartPointer& x) {
                this->core = x.core;
                if (x.core != nullptr) {
                    core->cnt++;
                }
            }

SmartPointer(SmartPointer&& x) {
                this->core = x.core;
                x.core = nullptr;
            }

void remove() {
                if (core != nullptr) {
                    core->cnt -= 1;
                    if (core->cnt == 0) {
                        delete (core);
                    }
                }
            }

SmartPointer& operator=(const SmartPointer& x) {
                remove();
                this->core = x.core;
                if (x.core != nullptr) {
                    core->cnt++;
                }
                return *this;
            }

SmartPointer& operator=(SmartPointer&& x) {
                remove();
                this->core = x.core;
                x.core = nullptr;
                return *this;
            }

SmartPointer& operator=(value_type* x) {
                remove();
                if (x != nullptr) {
                    this->core = new Core();
                    core->info = x;
                    core->cnt = 1;
                }
                else {
                    this->core = nullptr;
                }
                return *this;
            }

~SmartPointer() {
                remove();
            }

value_type& operator*() {
                if (core == nullptr) {
                    throw smart_pointer::exception();
                }
                else {
                    return *(core->info);
                }
            }

const value_type& operator*() const {
                if (core == nullptr) {
                    throw smart_pointer::exception();
                }
                else {
                    return *(core->info);
                }
            }

value_type* operator->() const {
                if (core == nullptr) {
                    return nullptr;
                }
                else {
                    return core->info;
                }
            }

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

operator bool() const {
                return core != nullptr;
            }

template <typename U, typename AnotherAllocator>
            bool operator==(const SmartPointer<U,
                AnotherAllocator>& pointer) const {
                return static_cast<void*>(this->get()) ==
                    static_cast<void*>(pointer.get());
            }

template <typename U, typename AnotherAllocator>
            bool operator!=(const SmartPointer<U,
                AnotherAllocator>& pointer) const {
                return static_cast<void*>(this->get()) !=
                    static_cast<void*>(pointer.get());
            }

std::size_t count_owners() const {
                if (core != nullptr) {
                    return core->cnt;
                }
                else {
                    return 0;
                }
            }

private:
            class Core {
             public:
                std::size_t cnt;
                value_type* info;

~Core() {
                    Allocator allocator;
                    allocator.deallocate(info, sizeof(value_type));
                    info = nullptr;
                }
            };
            Core* core;
    };
} 
#endif

(4 630 b)

0.044s 0.009s 10