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

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

ru en cn

5786405

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

Павленко Георгий Александрович

Время

19:30<< 16.11.2021 19:33 (27 д. 17:33) 19:35>>

Обработка

19:33 ... 19:33 (2,70 сек.)

Файл

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

Турнир

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

Задача

C: Smart Pointer

Набор тестов

Ограничения

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

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

CE	Ошибка компиляции

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

In file included from main.cpp:2:0:
SmartPointer.hpp: In member function 'bool smart_pointer::SmartPointer<T, Allocator>::operator==(const smart_pointer::SmartPointer<U, AnotherAllocator>&) const':
SmartPointer.hpp:140:3: error: expected ',' or ';' before 'return'
   return exp1 || exp2;
   ^~~~~~
SmartPointer.hpp:141:1: error: no return statement in function returning non-void [-Werror=return-type]
 }
 ^
SmartPointer.hpp: In member function 'bool smart_pointer::SmartPointer<T, Allocator>::operator!=(const smart_pointer::SmartPointer<U, AnotherAllocator>&) const':
SmartPointer.hpp:149:3: error: expected ',' or ';' before 'return'
   return !(exp1 || exp2);
   ^~~~~~
SmartPointer.hpp:150:1: error: no return statement in function returning non-void [-Werror=return-type]
 }
 ^
SmartPointer.hpp: In instantiation of 'bool smart_pointer::SmartPointer<T, Allocator>::operator==(const smart_pointer::SmartPointer<U, AnotherAllocator>&) const [with U = float; AnotherAllocator = std::allocator<float>; T = float; Allocator = std::allocator<float>]':
Test_SmartPointer.hpp:299:9:   required from here
SmartPointer.hpp:137:8: error: unused variable 'exp1' [-Werror=unused-variable]
   auto exp1 = get() == nullptr && val.get() == nullptr;
        ^~~~
SmartPointer.hpp:138:8: error: unused variable 'exp2' [-Werror=unused-variable]
   auto exp2 = static_cast<void*>(get()) == static_cast<void*>(val.get())
        ^~~~
SmartPointer.hpp: In instantiation of 'bool smart_pointer::SmartPointer<T, Allocator>::operator==(const smart_pointer::SmartPointer<U, AnotherAllocator>&) const [with U = long unsigned int; AnotherAllocator = std::allocator<long unsigned int>; T = float; Allocator = std::allocator<float>]':
Test_SmartPointer.hpp:305:9:   required from here
SmartPointer.hpp:137:8: error: unused variable 'exp1' [-Werror=unused-variable]
   auto exp1 = get() == nullptr && val.get() == nullptr;
        ^~~~
SmartPointer.hpp:138:8: error: unused variable 'exp2' [-Werror=unused-variable]
   auto exp2 = static_cast<void*>(get()) == static_cast<void*>(val.get())
        ^~~~
SmartPointer.hpp: In instantiation of 'bool smart_pointer::SmartPointer<T, Allocator>::operator!=(const smart_pointer::SmartPointer<U, AnotherAllocator>&) const [with U = float; AnotherAllocator = std::allocator<float>; T = float; Allocator = std::allocator<float>]':
Test_SmartPointer.hpp:349:9:   required from here
SmartPointer.hpp:146:8: error: unused variable 'exp1' [-Werror=unused-variable]
   auto exp1 = get() == nullptr && val.get() == nullptr;
        ^~~~
SmartPointer.hpp:147:8: error: unused variable 'exp2' [-Werror=unused-variable]
   auto exp2 = static_cast<void*>(get()) == static_cast<void*>(val.get())
        ^~~~
SmartPointer.hpp: In instantiation of 'bool smart_pointer::SmartPointer<T, Allocator>::operator!=(const smart_pointer::SmartPointer<U, AnotherAllocator>&) const [with U = long unsigned int; AnotherAllocator = std::allocator<long unsigned int>; T = float; Allocator = std::allocator<float>]':
Test_SmartPointer.hpp:355:9:   required from here
SmartPointer.hpp:146:8: error: unused variable 'exp1' [-Werror=unused-variable]
   auto exp1 = get() == nullptr && val.get() == nullptr;
        ^~~~
SmartPointer.hpp:147:8: error: unused variable 'exp2' [-Werror=unused-variable]
   auto exp2 = static_cast<void*>(get()) == static_cast<void*>(val.get())
        ^~~~
cc1plus: all warnings being treated as errors

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

≡

#pragma once

#include <memory>
#include "Test.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 *val = nullptr):
    core(val == nullptr ? nullptr :new Core(val, 1)) {}

SmartPointer(const SmartPointer &val) {
  core = val.core;
  if (core != nullptr)
    core->ptr_count++;
}

SmartPointer(SmartPointer &&val) {
  core = val.core;
  val.core = nullptr;
}

SmartPointer &operator=(const SmartPointer &val) {
  if (core != nullptr) {
    core->ptr_count--;
    if (core->ptr_count == 0) {
      delete core->ptr;
      delete core;
    }
  }
  core = val.core;
  if (core != nullptr)
    core->ptr_count++;

return *this;
}

SmartPointer &operator=(SmartPointer &&val) {
  if (core != nullptr) {
    core->ptr_count--;
    if (core->ptr_count == 0) {
      delete core->ptr;
      delete core;
    }
  }
  core = val.core;
  val.core = nullptr;

return *this;
}

SmartPointer &operator=(value_type *val) {
  if (core != nullptr) {
    core->ptr_count--;
    if (core->ptr_count == 0) {
      delete core->ptr;
      delete core;
    }
  }
  if (val == nullptr) {
    core = nullptr;
    return *this;
  }
  core = new Core(val, 1);

return *this;
}

~SmartPointer() {
  if (core != nullptr) {
    core->ptr_count--;
    if (core->ptr_count == 0) {
      delete core->ptr;
      delete core;
    }
  }
}

value_type &operator*() {
  if (core == nullptr || core->ptr == nullptr)
    throw smart_pointer::exception();

return *(core->ptr);
}

const value_type &operator*() const {
  if (core == nullptr || core->ptr == nullptr)
    throw smart_pointer::exception();

return *(core->ptr);
}

value_type *operator->() const {
  if (core != nullptr)
    return core->ptr;

return nullptr;
}

value_type *get() const {
  if (core != nullptr)
    return core->ptr;

return nullptr;
}

operator bool() const {
  if (core == nullptr)
    return false;

return core->ptr != nullptr;
}

template<typename U, typename AnotherAllocator>
bool operator==(const SmartPointer<U, AnotherAllocator> &val) const {
  auto exp1 = get() == nullptr && val.get() == nullptr;
  auto exp2 = static_cast<void*>(get()) == static_cast<void*>(val.get())

return exp1 || exp2;
}

template<typename U, typename AnotherAllocator>
bool operator!=(const SmartPointer<U, AnotherAllocator> &val) const {
  auto exp1 = get() == nullptr && val.get() == nullptr;
  auto exp2 = static_cast<void*>(get()) == static_cast<void*>(val.get())

return !(exp1 || exp2);
}

std::size_t count_owners() const {
  if (core != nullptr)
    return core->ptr_count;

return 0;
}

private:
  class Core {
   public:
    Core(value_type *val, size_t count) : ptr(val), ptr_count(count) {}
    value_type *ptr;
    size_t ptr_count;
  };
  Core *core;
};
}  // namespace smart_pointer

(3 173 b)

0.047s 0.011s 10