Memory code что это

Функции

value
Объект или функция, для которой необходимо получить истинный адрес.

Возвращаемое значение

Фактический адрес объекта или функции, на который ссылается value , даже если существует operator&() с перегрузкой.

Замечания

align

Соответствует хранилищу заданного размера, выровненного по заданной спецификации выравнивания, в первый возможный адрес данного хранилища.

void* align( size_t alignment, // input size_t size, // input void*& ptr, // input/output size_t& space // input/output );

Параметры

alignment
Граница выравнивания для выполнения попытки.

size
Размер в байтах для выровненного хранилища.

ptr
Начальный адрес доступного смежного пула хранилища для использования. Этот параметр также является выходным параметром и содержит новый начальный адрес, если выравнивание выполнено успешно. Если align() этот параметр не выполнен, этот параметр не изменяется.

space
Полный размер пространства, доступного align() , для использования при создании выровненного хранилища. Этот параметр также является параметром вывода и содержит откорректированное пространство, оставшееся в хранилище после вычитания выровненного хранилища и всей связанной с ним дополнительной нагрузки.

Если align() этот параметр не выполнен, этот параметр не изменяется.

Возвращаемое значение

Указатель NULL , если запрошенный выровненный буфер не будет помещаться в доступное пространство; в противном случае — новое значение ptr .

Замечания

Измененные параметры ptr и space позволяют вызывать align() повторно для того же буфера, возможно, с различными значениями для alignment и size . В следующем фрагменте кода показан один из способов использования align() .

#include // std::alignment_of() #include //. char buffer[256]; // for simplicity size_t alignment = std::alignment_of::value; void * ptr = buffer; std::size_t space = sizeof(buffer); // Be sure this results in the true size of your buffer while (std::align(alignment, sizeof(MyObj), ptr, space)) < // You now have storage the size of MyObj, starting at ptr, aligned on // int boundary. Use it here if you like, or save off the starting address // contained in ptr for later use. // . // Last, move starting pointer and decrease available space before // the while loop restarts. ptr = reinterpret_cast(ptr) + sizeof(MyObj); space -= sizeof(MyObj); > // At this point, align() has returned a null pointer, signaling it is not // possible to allow more aligned storage in this buffer.

allocate_shared

Создает shared_ptr для объектов, выделенных и созданных для заданного типа с помощью указанного распределителя. Возвращает shared_ptr .

template shared_ptr allocate_shared( Allocator alloc, Args&&. args);

Параметры

alloc
Распределитель используется для создания объектов.

args
Ноль или более аргументов, которые будут объектами.

Замечания

Функция создает объект shared_ptr , указатель на T(args. ) , как выделенный и созданный alloc .

atomic_compare_exchange_strong

template bool atomic_compare_exchange_strong( shared_ptr* u, shared_ptr* v, shared_ptr w);

atomic_compare_exchange_weak

template bool atomic_compare_exchange_weak( shared_ptr* u, shared_ptr* v, shared_ptr w);

atomic_compare_exchange_strong_explicit

template bool atomic_compare_exchange_strong_explicit( shared_ptr* u, shared_ptr* v, shared_ptr w, memory_order success, memory_order failure);

atomic_compare_exchange_weak_explicit

template bool atomic_compare_exchange_weak_explicit( shared_ptr* u, shared_ptr* v, shared_ptr w, memory_order success, memory_order failure);

atomic_exchange

template shared_ptr atomic_exchange( shared_ptr* u, shared_ptr r);

atomic_exchange_explicit

template shared_ptr atomic_exchange_explicit( shared_ptr* u, shared_ptr r, memory_order mo);

atomic_is_lock_free

template bool atomic_is_lock_free( const shared_ptr* u);

atomic_load

template shared_ptr atomic_load( const shared_ptr* u);

atomic_load_explicit

template shared_ptr atomic_load_explicit( const shared_ptr* u, memory_order mo);

atomic_store

template void atomic_store( shared_ptr* u, shared_ptr r);

atomic_store_explicit

template void atomic_store_explicit( shared_ptr* u, shared_ptr r, memory_order mo);

const_pointer_cast

Постоянное приведение к shared_ptr .

template shared_ptr const_pointer_cast( const shared_ptr& sp) noexcept; template shared_ptr const_pointer_cast( shared_ptr&& sp) noexcept;

Параметры

T
Тип, управляемый возвращаемым общим указателем.

Other
Тип, управляемый общим указателем на аргумент.

sp
Общий указатель на аргумент.

Замечания

Функция шаблона возвращает пустой shared_ptr объект, если const_cast(sp.get()) возвращает указатель null; в противном случае возвращает shared_ptr объект, принадлежащий sp ресурсу. Выражение const_cast(sp.get()) должно быть допустимым.

Пример

// std__memory__const_pointer_cast.cpp // compile with: /EHsc #include #include int main() < std::shared_ptrsp0(new int); std::shared_ptr sp1 = std::const_pointer_cast(sp0); *sp0 = 3; std::cout

sp1 == 3

declare_no_pointers

Сообщает сборщику мусора, что символы в блоке памяти, определенном указателем на базовый адрес и размером блока, не содержат трассируемых указателей.

void declare_no_pointers( char* ptr, size_t size);

Параметры

ptr
Адрес первого символа, который больше не содержит трассируемых указателей.

size
Размер блока, который начинается с ptr и не содержит трассируемых указателей.

Замечания

Функция сообщает любому сборщику мусора, что адреса в диапазоне [ptr, ptr + size) больше не содержат отслеживаемых указателей. (Все указатели на выделенное хранилище не должны быть разыменованы, если не сделано доступным.)

declare_reachable

Уведомляет сборщик мусора, что указанный адрес относится к выделенной памяти и является доступным.

void declare_reachable( void* ptr);

Параметры

ptr
Указатель на доступную, выделенную, допустимую область хранения.

Замечания

Если ptr значение не равно null, функция сообщает любому сборщику мусора, ptr который теперь доступен, то есть указывает на допустимое выделенное хранилище.

default_delete

Удаляет объекты, выделенные с помощью operator new . Подходит для использования с unique_ptr .

struct default_delete < constexpr default_delete() noexcept = default; template ::value, void>::type>> default_delete(const default_delete&) noexcept; void operator()(T* ptr) const noexcept; >;

Параметры

ptr
Указатель на объект, который нужно удалить.

Other
Тип представленных в массиве элементов, который нужно удалить.

Замечания

Шаблон класса описывает удаленный объект, который удаляет скалярные объекты, выделенные с operator new помощью шаблона unique_ptr класса. Также имеет явную специализацию default_delete .

destroy_at

template void destroy_at( T* location);

destroy

template void destroy( ForwardIterator first, ForwardIterator last);

То же самое, что:

for (; first != last; ++first) destroy_at(addressof(*first));

destroy_n

template ForwardIterator destroy_n( ForwardIterator first, Size count);

То же самое, что:

for (; count > 0; (void)++first, --count) destroy_at(addressof(*first)); return first;

dynamic_pointer_cast

Динамическое приведение к shared_ptr .

template shared_ptr dynamic_pointer_cast( const shared_ptr& sp) noexcept; template shared_ptr dynamic_pointer_cast( shared_ptr&& sp) noexcept;

Параметры

T
Тип, управляемый возвращаемым общим указателем.

Other
Тип, управляемый общим указателем на аргумент.

sp
Общий указатель на аргумент.

Замечания

Функция шаблона возвращает пустой shared_ptr объект, если dynamic_cast(sp.get()) возвращает указатель null; в противном случае возвращает shared_ptr объект, принадлежащий sp ресурсу. Выражение dynamic_cast(sp.get()) должно быть допустимым.

Пример

// std__memory__dynamic_pointer_cast.cpp // compile with: /EHsc #include #include struct base < virtual ~base() <>int value; >; struct derived : public base < >; int main() < std::shared_ptrsp0(new derived); std::shared_ptr sp1 = std::dynamic_pointer_cast(sp0); sp0->value = 3; std::cout value == " value

sp1->value == 3

get_deleter

Получите удаленный shared_ptr объект из .

template Deleter* get_deleter( const shared_ptr& sp) noexcept;

Параметры

Deleter
Тип метода удаления.

T
Тип, управляемый общим указателем.

Замечания

Функция шаблона возвращает указатель на удаленный тип Deleter , принадлежащий объекту shared_ptr sp . Если sp нет метода удаления или если его удаление не имеет типа Deleter , функция возвращает значение 0.

Пример

// std__memory__get_deleter.cpp // compile with: /EHsc #include #include struct base < int value; >; struct deleter < void operator()(base *pb) < delete pb; >>; int main() < std::shared_ptrsp0(new base); sp0->value = 3; std::cout (sp0) != 0) << std::endl; std::shared_ptrsp1(new base, deleter()); sp0->value = 3; std::cout (sp1) != 0)

get_deleter(sp0) != 0 == false get_deleter(sp1) != 0 == true

get_pointer_safety

Возвращает тип безопасности указателя, подразумеваемый любым сборщиком мусора.

pointer_safety get_pointer_safety() noexcept;

Замечания

Функция возвращает тип безопасности указателя, предполагаемый любым автоматическим сборщиком мусора.

get_temporary_buffer

Выделяет временное хранилище для последовательности элементов, не превышающих указанное количество элементов.

template pair get_temporary_buffer( ptrdiff_t count);

Параметры

count
Максимальное количество запрошенных элементов, для которых нужно выделить память.

Возвращаемое значение

pair , первый компонент которого — это указатель на память, которая была выделена, а второй компонент — размер буфера (наибольшее количество элементов, которые он может сохранить).

Замечания

Функция делает запрос на выделение памяти, и она может не завершиться успешно. Если буфер не выделен, функция возвращает пару, второй компонент которой равен нулю, а первый компонент — пустой указатель.

Используйте эту функцию только для памяти, которая является временной.

Пример

// memory_get_temp_buf.cpp // compile with: /EHsc #include #include using namespace std; int main( ) < // Create an array of ints int intArray [] = < 10, 20, 30, 40, 100, 200, 300, 1000, 2000 >; int count = sizeof ( intArray ) / sizeof ( int ); cout resultPair; resultPair = get_temporary_buffer( count ); cout

The number of integers in the array is: 9. The number of elements that the allocated memory could store is given by: resultPair.second = 9.

make_shared

Создает и возвращает shared_ptr , указывающий на выделенные объекты, созданные без аргументов или с помощью нескольких аргументов с использованием распределителя по умолчанию. Выделяет и создает объект указанного типа и shared_ptr для управления общим владением объекта и возвращает shared_ptr .

template shared_ptr make_shared( Args&&. args);

Параметры

args
Без аргументов или несколько аргументов конструктора. Функция определяет перегрузку конструктора, которую нужно вызвать, на основе переданных аргументов.

Замечания

Используйте одновременно make_shared как простой и эффективный способ создания объекта и shared_ptr для управления общим доступом к объекту. Семантически следующие два оператора эквивалентны:

auto sp = std::shared_ptr(new Example(argument)); auto msp = std::make_shared(argument);

Однако первый оператор назначает два выделения, и при сбое выделения shared_ptr после успешного выделения объекта Example происходит утечка неименованного объекта Example . Оператор с make_shared проще, поскольку используется только один вызов функции. Он более эффективен, так как библиотека может создать одно и то же выделение для объекта и интеллектуального указателя. Эта функция выполняется как быстрее, так и приводит к уменьшению фрагментации памяти, и нет возможности исключения для одного выделения, но не другого. Благодаря более оптимальному расположению кода, указывающего на объект и обновляющего счетчики в интеллектуальном указателе, повышается производительность.

Рекомендуется использовать, make_unique если вам не нужен общий доступ к объекту. Используйте allocate_shared , если необходимо указать пользовательский распределитель для объекта. Невозможно использовать make_shared , если объекту требуется пользовательский средство удаления, так как нет способа передать его в качестве аргумента.

В приведенном ниже примере показано, как можно создавать общие указатели на тип, задавая определенные перегрузки конструктора.

Пример

// stl_make_shared.cpp // Compile by using: cl /W4 /EHsc stl_make_shared.cpp #include #include #include #include class Song < public: std::wstring title_; std::wstring artist_; Song(std::wstring title, std::wstring artist) : title_(title), artist_(artist) <>Song(std::wstring title) : title_(title), artist_(L"Unknown") <> >; void CreateSharedPointers() < // Okay, but less efficient to have separate allocations for // Song object and shared_ptr control block. auto song = new Song(L"Ode to Joy", L"Beethoven"); std::shared_ptrsp0(song); // Use make_shared function when possible. Memory for control block // and Song object are allocated in the same call: auto sp1 = std::make_shared(L"Yesterday", L"The Beatles"); auto sp2 = std::make_shared(L"Blackbird", L"The Beatles"); // make_shared infers which constructor to use based on the arguments. auto sp3 = std::make_shared(L"Greensleeves"); // The playlist vector makes copies of the shared_ptr pointers. std::vector playlist; playlist.push_back(sp0); playlist.push_back(sp1); playlist.push_back(sp2); playlist.push_back(sp3); playlist.push_back(sp1); playlist.push_back(sp2); for (auto&& sp : playlist) < std::wcout title_ artist_ > int main()

В примере получается следующий результат.

Playing Ode to Joy by Beethoven, use count: 2 Playing Yesterday by The Beatles, use count: 3 Playing Blackbird by The Beatles, use count: 3 Playing Greensleeves by Unknown, use count: 2 Playing Yesterday by The Beatles, use count: 3 Playing Blackbird by The Beatles, use count: 3

make_unique

Создает и возвращает unique_ptr объект указанного типа, который создается с помощью указанных аргументов.

// make_unique template unique_ptr make_unique(Args&&. args); // make_unique template unique_ptr make_unique(size_t size); // make_unique disallowed template /* unspecified */ make_unique(Args&&. ) = delete;

Параметры

T
Тип объекта, на который будет указывать unique_ptr .

Args
Типы аргументов конструктора, определяемые args .

args
Аргументы для передачи конструктору объекта типа T .

elements
Массив элементов типа T .

size
Количество элементов, для которых нужно выделить место в новом массиве.

Замечания

Первая перегрузка используется для отдельных объектов. Для массивов вызывается вторая перегрузка. Третья перегрузка предотвращает указание размера массива в аргументе типа ( make_unique ). Эта конструкция не поддерживается текущим стандартом. При использовании make_unique для создания unique_ptr в массив требуется инициализировать элементы массива отдельно. Вместо того, чтобы использовать эту перегрузку, возможно, лучший выбор — использовать std::vector .

Так как make_unique тщательно реализована для безопасности исключений, рекомендуется использовать make_unique вместо прямого вызова конструкторов unique_ptr .

Пример

В следующем примере показано, как использовать make_unique . Дополнительные примеры см. в разделе Примеры: создание и использование экземпляров unique_ptr.

class Animal < private: std::wstring genus; std::wstring species; int age; double weight; public: Animal(const wstring&, const wstring&, int, double)Animal()<> >; void MakeAnimals() < // Use the Animal default constructor. unique_ptrp1 = make_unique(); // Use the constructor that matches these arguments auto p2 = make_unique(L"Felis", L"Catus", 12, 16.5); // Create a unique_ptr to an array of 5 Animals unique_ptr p3 = make_unique(5); // Initialize the elements p3[0] = Animal(L"Rattus", L"norvegicus", 3, 2.1); p3[1] = Animal(L"Corynorhinus", L"townsendii", 4, 1.08); // auto p4 = p2; //C2280 vector vec; // vec.push_back(p2); //C2280 // vector vec2 = vec; // C2280 // OK. p2 no longer points to anything vec.push_back(std::move(p2)); // unique_ptr overloads operator bool wcout

При появлении ошибки C2280 в связи с unique_ptr , это почти наверняка связано с тем, что вы пытаетесь вызвать его конструктор копированием, который является удаленной функцией.

owner_less

Разрешает смешанные сравнения общих и слабых указателей на основе собственности. Возвращает true , если левый параметр размещен по порядку перед правым параметром функцией-членом owner_before .

template struct owner_less; // not defined template struct owner_less> < bool operator()( const shared_ptr& left, const shared_ptr& right) const noexcept; bool operator()( const shared_ptr& left, const weak_ptr& right) const noexcept; bool operator()( const weak_ptr& left, const shared_ptr& right) const noexcept; >; template struct owner_less bool operator()( const weak_ptr& left, const weak_ptr& right) const noexcept; bool operator()( const weak_ptr& left, const shared_ptr& right) const noexcept; bool operator()( const shared_ptr& left, const weak_ptr& right) const noexcept; >; template<> struct owner_less  < templatebool operator()( const shared_ptr& left, const shared_ptr& right) const noexcept; template bool operator()( const shared_ptr& left, const weak_ptr& right) const noexcept; template bool operator()( const weak_ptr& left, const shared_ptr& right) const noexcept; template bool operator()( const weak_ptr& left, const weak_ptr& right) const noexcept; >;

Параметры

left
Общий или слабый указатель.

right
Общий или слабый указатель.

Замечания

Шаблоны классов определяют все операторы-члены как возвращаемые left.owner_before(right) .

reinterpret_pointer_cast

Создает новый shared_ptr объект из существующего общего указателя с помощью приведения.

template shared_ptr reinterpret_pointer_cast( const shared_ptr& ptr) noexcept; template shared_ptr reinterpret_pointer_cast( shared_ptr&& ptr) noexcept;

Параметры

ptr
Ссылка на shared_ptr .

Замечания

Если ptr он пуст, новый shared_ptr также пуст, в противном случае он разделяет владение ptr . Новый общий указатель является результатом оценки reinterpret_cast(ptr.get()) , где Y находится typename std::shared_ptr::element_type . Поведение не определено, если reinterpret_cast((U*)nullptr) он не является хорошо сформированным.

Функция шаблона, принимаюющая ссылку lvalue, новая в C++17. Функция шаблона, принимаюющая ссылку rvalue, является новой в C++20.

return_temporary_buffer

Отменяет выделение временной памяти, выделенной с помощью функции шаблона get_temporary_buffer .

template void return_temporary_buffer( T* buffer);

Параметры

buffer
Указатель на память, которую нужно освободить.

Замечания

Используйте эту функцию только для памяти, которая является временной.

Пример

// memory_ret_temp_buf.cpp // compile with: /EHsc #include #include using namespace std; int main( ) < // Create an array of ints int intArray [] = < 10, 20, 30, 40, 100, 200, 300 >; int count = sizeof ( intArray ) / sizeof ( int ); cout resultPair; resultPair = get_temporary_buffer( count ); cout

The number of integers in the array is: 7. The number of elements that the allocated memory could store is given by: resultPair.second = 7.

static_pointer_cast

Статическое приведение к shared_ptr .

template shared_ptr static_pointer_cast( const shared_ptr& sp) noexcept; template shared_ptr static_pointer_cast( shared_ptr&& sp) noexcept;

Параметры

T
Тип, управляемый возвращаемым общим указателем.

Other
Тип, управляемый общим указателем на аргумент.

sp
Общий указатель на аргумент.

Замечания

Функция шаблона возвращает пустой объект, если sp является пустым shared_ptr shared_ptr объектом; в противном случае возвращает shared_ptr объект, которому принадлежит sp ресурс. Выражение static_cast(sp.get()) должно быть допустимым.

Пример

// std__memory__static_pointer_cast.cpp // compile with: /EHsc #include #include struct base < int value; >; struct derived : public base < >; int main() < std::shared_ptrsp0(new derived); std::shared_ptr sp1 = std::static_pointer_cast(sp0); sp0->value = 3; std::cout value == " value

sp1->value == 3

swap

Переключение двух shared_ptr объектов или unique_ptr weak_ptr объектов.

template void swap( shared_ptr& left, shared_ptr& right) noexcept; template void swap( unique_ptr& left, unique_ptr& right) noexcept; template void swap( weak_ptr& left, weak_ptr& right) noexcept;

Параметры

T
Тип, управляемый указателем аргумента.

Deleter
Удаление уникального типа указателя.

left
Левый указатель.

right
Правый указатель.

Замечания

Функция шаблона вызывает left.swap(right) .

Пример

// std__memory__swap.cpp // compile with: /EHsc #include #include int main() < std::shared_ptrsp1(new int(5)); std::shared_ptr sp2(new int(10)); std::cout << "*sp1 == " << *sp1 << std::endl; sp1.swap(sp2); std::cout << "*sp1 == " << *sp1 << std::endl; swap(sp1, sp2); std::cout << "*sp1 == " << *sp1 << std::endl; std::cout << std::endl; std::weak_ptrwp1(sp1); std::weak_ptr wp2(sp2); std::cout

*sp1 == 5 *sp1 == 10 *sp1 == 5 *wp1 == 5 *wp1 == 10 *wp1 == 5

undeclare_no_pointers

Сообщает сборщику мусора, что символы в блоке памяти, определенном указателем на базовый адрес и размером блока, теперь могут содержать трассируемые указатели.

void undeclare_no_pointers( char* ptr, size_t size);

Параметры

ptr
Указатель на адрес памяти, помеченный ранее с помощью declare_no_pointers .

size
Количество байтов в диапазоне памяти. Это значение должно совпадать с номером, используемым в вызове declare_no_pointers .

Замечания

Функция сообщает любому сборщику мусора, что диапазон адресов [ptr, ptr + size) теперь может содержать отслеживаемые указатели.

undeclare_reachable

Отменяет объявление доступности для указанного расположения памяти.

template T *undeclare_reachable( T* ptr);

Параметры

ptr
Указатель на адрес памяти, помеченный ранее с помощью declare_reachable .

Замечания

Если ptr это не nullptr так, функция сообщает любому сборщику мусора, который ptr больше недоступен. Он возвращает безопасный производный указатель, который сравнивается с равным ptr .

uninitialized_copy

Копирует объекты из указанного исходного диапазона в неинициализированный конечный диапазон.

template ForwardIterator uninitialized_copy( InputIterator first, InputIterator last, ForwardIterator dest); template ForwardIterator uninitialized_copy( ExecutionPolicy&& policy, InputIterator first, InputIterator last, ForwardIterator dest);

Параметры

policy
Используемая политика выполнения.

first
Итератор ввода, обращающийся к первому элементу в исходном диапазоне.

last
Итератор ввода, обращающийся к последнему элементу в исходном диапазоне.

dest
Прямой оператор, обращающийся к первому элементу в диапазоне назначения.

Возвращаемое значение

Итератор пересылки, обращаюющийся к первой позиции за пределами диапазона назначения, если исходный диапазон не был пустым.

Замечания

Этот алгоритм позволяет отделить выделение памяти от создания объекта.

Шаблонная функция фактически выполняется.

while (first != last) < new (static_cast(&* dest++)) typename iterator_traits::value_type(*first++); > return dest;

если код не создает исключение. В этом случае все созданные объекты уничтожаются, и создается исключение.

Перегрузка с политикой выполнения новая в C++17.

Пример

// memory_uninit_copy.cpp // compile with: /EHsc /W3 #include #include using namespace std; class Integer < public: Integer(int x) : value(x) <>int get() < return value; >private: int value; >; int main() < int Array[] = < 10, 20, 30, 40 >; const int N = sizeof(Array) / sizeof(int); cout cout

uninitialized_copy_n

Создает копию заданного числа элементов из итератора ввода. Копии помещаются в прямой итератор.

template ForwardIterator uninitialized_copy_n( InputIterator first, Size count, ForwardIterator dest); template ForwardIterator uninitialized_copy_n( ExecutionPolicy&& policy, InputIterator first, Size count, ForwardIterator dest);

Параметры

policy
Используемая политика выполнения.

first
Итератор ввода, который ссылается на объект, подлежащий копированию.

count
Целочисленный тип со знаком или без знака, указывающий количество операций копирования объекта.

dest
Прямой итератор, ссылающийся на место размещения новых копий.

Возвращаемое значение

Прямой итератор, обращающийся к первой позиции после места назначения. Если исходный диапазон был пустым, адрес first итератора.

Замечания

Функция шаблона эффективно выполняет следующий код:

 for (; 0 < count; --count) new (static_cast(&* dest++)) typename iterator_traits::value_type(*first++); return dest;

если код не создает исключение. В этом случае все созданные объекты уничтожаются, и создается исключение.

Перегрузка с политикой выполнения новая в C++17.

uninitialized_default_construct

По умолчанию создаются объекты итераторов value_type в указанном диапазоне.

template void uninitialized_default_construct( ForwardIterator first, ForwardIterator last); template void uninitialized_default_construct( ExecutionPolicy&& policy, ForwardIterator first, ForwardIterator last);

Параметры

policy
Используемая политика выполнения.

first
Итератор, обращаюющийся к первому элементу в диапазоне для создания.

last
Итератор, обращаюющийся к одному последнему элементу в диапазоне для создания.

Замечания

Версия без политики выполнения фактически аналогична:

for (; first != last; ++first) ::new (static_cast(addressof(*first))) typename iterator_traits::value_type;

При возникновении исключения ранее созданные объекты уничтожаются в неопределенном порядке.

Версия с политикой выполнения имеет тот же результат, но выполняется в соответствии с указанным policy .

Эти функции являются новыми в C++17.

uninitialized_default_construct_n

По умолчанию создается указанное количество объектов итератора value_type , начиная с указанного расположения.

template ForwardIterator uninitialized_default_construct_n( ForwardIterator first, Size count); template ForwardIterator uninitialized_default_construct_n( ExecutionPolicy&& policy, ForwardIterator first, Size count);

Параметры

policy
Используемая политика выполнения.

first
Итератор, обращаюющийся к первому элементу в диапазоне назначения для создания.

count
Количество элементов в диапазоне назначения для создания.

Возвращаемое значение

Замечания

Версия без политики выполнения фактически аналогична:

for (; count>0; (void)++first, --count) ::new (static_cast(addressof(*first))) typename iterator_traits::value_type; return first;

При возникновении исключения ранее созданные объекты уничтожаются в неопределенном порядке.

Версия с политикой выполнения имеет тот же результат, но выполняется в соответствии с указанным policy .

Эти функции являются новыми в C++17.

uninitialized_fill

Копирует объекты с указанным значением в неинициализированный конечный диапазон.

template void uninitialized_fill( ForwardIterator first, ForwardIterator last, const T& value); template void uninitialized_fill( ExecutionPolicy&& policy, ForwardIterator first, ForwardIterator last, const T& value);

Параметры

policy
Используемая политика выполнения.

first
Итератор пересылки, обращаюющийся к первому элементу в диапазоне назначения для инициализации.

last
Итератор пересылки, обращаюющийся к последнему элементу в диапазоне назначения для инициализации.

value
Значение, используемое для инициализации диапазона назначения.

Замечания

Этот алгоритм позволяет отделить выделение памяти от создания объекта.

Шаблонная функция фактически выполняется.

while (first != last) new (static_cast(&* first ++)) typename iterator_traits::value_type (value);

если код не создает исключение. В этом случае все созданные объекты уничтожаются, и создается исключение.

Перегрузка с политикой выполнения новая в C++17.

Пример

// memory_uninit_fill.cpp // compile with: /EHsc #include #include using namespace std; class Integer < public: // No default constructor Integer( int x ) : value( x ) <>int get() < return value; >private: int value; >; int main() < const int N = 10; Integer value ( 25 ); Integer* Array = ( Integer* ) malloc( N * sizeof( int ) ); uninitialized_fill( Array, Array + N, value ); cout cout

The initialized Array contains: 25 25 25 25 25 25 25 25 25 25

uninitialized_fill_n

Копирует объекты указанного значения в указанное число элементов неинициализированного диапазона назначения.

template ForwardIterator uninitialized_fill_n( ForwardIterator first, Size count, const T& value); template ForwardIterator uninitialized_fill_n( ExecutionPolicy&& policy, ForwardIterator first, Size count, const T& value);

Параметры

policy
Используемая политика выполнения.

first
Итератор пересылки, обращаюющийся к первому элементу в диапазоне назначения для инициализации.

count
Количество элементов для инициализации.

value
Значение, используемое для инициализации диапазона назначения.

Замечания

Этот алгоритм позволяет отделить выделение памяти от создания объекта.

Шаблонная функция фактически выполняется.

while (0 < count--) new (static_cast(&* first++)) typename iterator_traits::value_type(value); return first;

если код не создает исключение. В этом случае все созданные объекты уничтожаются, и создается исключение.

Перегрузка с политикой выполнения новая в C++17.

Пример

// memory_uninit_fill_n.cpp // compile with: /EHsc /W3 #include #include using namespace std; class Integer < public: // No default constructor Integer( int x ) : value( x ) <>int get() < return value; >private: int value; >; int main() < const int N = 10; Integer value( 60 ); Integer* Array = ( Integer* ) malloc( N * sizeof( int ) ); uninitialized_fill_n( Array, N, value ); // C4996 cout

uninitialized_move

Перемещает элементы из исходного диапазона в неинициализированную область памяти назначения.

template ForwardIterator uninitialized_move( InputIterator first, InputIterator last, ForwardIterator dest); template ForwardIterator uninitialized_move( ExecutionPolicy&& policy, InputIterator first, InputIterator last, ForwardIterator dest);

Параметры

policy
Используемая политика выполнения.

first
Входной итератор, обращаюющийся к первому элементу в исходном диапазоне для перемещения.

last
Входной итератор, обращаюющийся к одному последнему элементу в исходном диапазоне для перемещения.

dest
Начало диапазона назначения.

Замечания

Версия без политики выполнения фактически аналогична:

for (; first != last; (void)++dest, ++first) ::new (static_cast(addressof(*dest))) typename iterator_traits::value_type(std::move(*first)); return dest;

Если создается исключение, некоторые объекты в исходном диапазоне могут оставаться в допустимом, но неопределенном состоянии. Ранее созданные объекты уничтожаются в неопределенном порядке.

Версия с политикой выполнения имеет тот же результат, но выполняется в соответствии с указанным policy .

Эти функции являются новыми в C++17.

uninitialized_move_n

Перемещает указанное число элементов из исходного диапазона в неинициализированную область памяти назначения.

template pair uninitialized_move_n( InputIterator first, Size count, ForwardIterator dest); template pair uninitialized_move_n( ExecutionPolicy&& policy, InputIterator first, Size count, ForwardIterator dest);

Параметры

policy
Используемая политика выполнения.

first
Входной итератор, обращаюющийся к первому элементу в исходном диапазоне для перемещения.

count
Количество элементов в исходном диапазоне для перемещения.

dest
Начало диапазона назначения.

Замечания

Версия без политики выполнения фактически аналогична:

for (; count > 0; ++dest, (void) ++first, --count) ::new (static_cast(addressof(*dest))) typename iterator_traits::value_type(std::move(*first)); return ;

Версия с политикой выполнения имеет тот же результат, но выполняется в соответствии с указанным policy .

Эти функции являются новыми в C++17.

uninitialized_value_construct

Создает объекты итераторов value_type по инициализации значений в указанном диапазоне.

template void uninitialized_value_construct( ForwardIterator first, ForwardIterator last); template void uninitialized_value_construct( ExecutionPolicy&& policy, ForwardIterator first, ForwardIterator last);

Параметры

policy
Используемая политика выполнения.

first
Итератор, обращаюющийся к первому элементу в диапазоне, к конструкции значений.

last
Итератор, обращаюющийся к одному последнему элементу в диапазоне, к конструкции значений.

Замечания

Версия без политики выполнения фактически аналогична:

for (; first != last; ++first) ::new (static_cast(addressof(*first))) typename iterator_traits::value_type();

При возникновении исключения ранее созданные объекты уничтожаются в неопределенном порядке.

Версия с политикой выполнения имеет тот же результат, но выполняется в соответствии с указанным policy .

Если возникает сбой выделения памяти, std::bad_alloc создается исключение.

Эти функции являются новыми в C++17.

uninitialized_value_construct_n

Создает указанное количество объектов итератора value_type по инициализации значений, начиная с указанного расположения.

template ForwardIterator uninitialized_value_construct_n( ForwardIterator first, Size count); template ForwardIterator uninitialized_value_construct_n( ExecutionPolicy&& policy, ForwardIterator first, Size count);

Параметры

policy
Используемая политика выполнения.

first
Итератор, обращаюющийся к первому элементу в диапазоне назначения для создания.

count
Количество элементов в диапазоне назначения для создания.

Замечания

Версия без политики выполнения фактически аналогична:

for (; count > 0; (void)++first, --count) ::new (static_cast(addressof(*first))) typename iterator_traits::value_type(); return first;

При возникновении исключения ранее созданные объекты уничтожаются в неопределенном порядке.

Версия с политикой выполнения имеет тот же результат, но выполняется в соответствии с указанным policy .

Если возникает сбой выделения памяти, std::bad_alloc создается исключение.

Эти функции являются новыми в C++17.

uses_allocator_v

Вспомогательный шаблон переменной для доступа к значению uses_allocator шаблона.

template inline constexpr bool uses_allocator_v = uses_allocator::value;

Memory reference code (MRC)

Как повелось - отвечаю на свой же вопрос. MRC это по сути своей обычный программный код, который нацелен на инициализацию постоянной (она же оперативная) взамен временной (а именно "Cash as RAM") памяти, которой процессор пользуется сразу после запуска кода в микросхеме BIOS.

Отслеживать
ответ дан 28 апр 2017 в 13:48
147 9 9 бронзовых знаков

bios
uefi

Важное на Мете

Подписаться на ленту

Лента вопроса

Для подписки на ленту скопируйте и вставьте эту ссылку в вашу программу для чтения RSS.

Нажимая «Принять все файлы cookie» вы соглашаетесь, что Stack Exchange может хранить файлы cookie на вашем устройстве и раскрывать информацию в соответствии с нашей Политикой в отношении файлов cookie.

Ключи Touch Memory iButton

Электронный ключ iButton (Touch Memory) производства компании Dallas Semiconductor — это компьютерный чип, заключенный в 16-миллиметровую «таблетку» из нержавеющей стали. Благодаря уникальному надежному корпусу, информация, заключенная в чипе, будет сохранена в любых условиях. Стальная «таблетка» может применяться где угодно благодаря своим свойствам противостоять условиям агрессивной внешней среды. Её компактные размеры позволяют закрепить её на кольце для ключей или брелке, и использовать для таких повседневных задач, как контроль и учет доступа.

Компоненты ключа iButton (Touch Memory)

Корпус и начинка «таблетки»

Электронный ключ iButton компании Dallas Semiconductor (Touch Memory) использует в качестве интерфейса сам металлический корпус-таблетку. Каждая «таблетка» имеет основной контакт («крышка») и основание («корпус»). Оба эти контакта присоединены к кремниевому чипу внутри «таблетки» и изолированы друг от друга полипропиленовой вставкой. Основание формирует корпус таблетки, а основной контакт — крышку. Корпус «таблетки» подходит для установки в пластиковые держатели, которые позволяют с удобством пользоваться ключом iButton (Touch Memory).

Интерфейс 1-wire

Считывание ключа осуществляется по протоколу 1-wire путем простого прикосновения к двум контактам, описанным выше. Интерфейс 1-wire имеет две скорости передачи данных: стандартная — 16 кбит/с и ускоренная — 142 кбит/с.

Адрес (код ключа)

Каждый ключ iButton (Touch Memory) содержит единственный и уникальный адрес, который занесен в чип внутри «таблетки». Этот адрес может быть использован как идентификатор для каждой таблетки (например 2700000095C33108).

Версии iButton (Touch Memory)

На базе технологии iButton (Touch Memory) компании Dallas Semiconductor реализованы 20 различных типов «таблеток» с различной функциональностью:

Адресные (DS1990A, Touch Memory);
с памятью;
с часами;
защищенные;
регистрирующие (температуру, влажность).

Надежность

Кремниевый чип «таблетки» iButton (Touch Memory) защищен прочной нержавеющей сталью. Вы можете бросать iButton (Touch Memory), наступать на него или царапать. Таблетки iButton (Touch Memory) тестированы для работы в течение 10 лет в различных погодных условиях.

Модификации ключей Touch Memory DS1990A

Все типы электронных ключей iButton (Touch Memory) являются адресными, то есть содержат в чипе шестнадцатизначное число, уникальное для каждой таблетки. Концепция мобильного чипа памяти, который связывается с внешними устройствами путем касания, легла в основу всех модификаций iButton (Touch Memory). По мере роста семейства iButton (Touch Memory), адресные ключи DS1990A iButton (Touch Memory) были отделены от других модификаций с расширенными функциями, такими, как микропроцессор, часы и/или датчики температуры, влажности.

Уникальный и неизменяемый адрес, занесенный внутрь чипа при его изготовлении с помощью лазерного луча;
Недорогой интерфейс 1-wire с низким энергопотреблением.

Модели DS1990A, DS1990A-F3, DS1990A-F5

Ключи DS1990A Touch Memory содержат в себе уникальный код, который используется для автоматической идентификации. Данные передаются через последовательный интерфейс по протоколу 1-wire, который использует один проводник для передачи данных и один в качестве общего провода. В каждом ключе DS1990A записан гарантированно уникальный 64-битный номер. Прочный корпус из нержавеющей стали предохраняет ключ от грязи, влаги и ударов. Компактный корпус в виде таблетки удобно прикладывать к разъему считывателя.

Время считывания — менее 5 миллисекунд;
Условия работы: напряжение питания от 2,8 В до 6,0 В, температура от -40°С до +85°С;
Уникальный 64-битный код;
Встроенный контроллер для интерфейса 1-wire;
Идентификация по касанию;
Конструкция корпуса, упрощающая правильное прикладывание;
Прочный корпус из нержавеющей стали с регистрационным номером, выдерживающим суровые условия внешней среды;
Простое крепление на пластиковом держателе.

Вы можете купить оригинальные ключи Touch Memory в интернет-магазине или заказать изготовление дубликата существующего электронного ключа в нашем офисе.

Оперативная память (ОЗУ): что это, для чего она нужна и какая бывает

Бывает ли такое, что компьютер не виснет из-за количества вкладок в браузере.

Иллюстрация: Оля Ежак для Skillbox Media

Мария Толчёнова

Филолог и технарь, пишет об IT так, что поймут даже новички. Коммерческий редактор, автор технических статей для vc.ru и «Хабра».

Оперативная память, она же оперативка, она же RAM (random access memory), она же ОЗУ (оперативное запоминающее устройство), хранит исполняемый машинный код и данные, которые необходимы программе в текущий момент. Если у компьютера мало оперативки, то команды выполняются долго и компьютер подвисает. Но объём памяти не единственная характеристика, которую стоит учитывать при выборе ОЗУ.

В этой статье расскажем:

Что такое оперативная память
Какие виды ОЗУ существуют
Какие характеристики у неё бывают
Как выбрать оперативную память
Что запомнить про ОЗУ

Что такое оперативная память

Оперативная память, или оперативное запоминающее устройство (ОЗУ), — это тип памяти, в котором во время работы компьютера хранится выполняемый машинный код и данные, которые в этот момент обрабатывает процессор.

Физически ОЗУ представляет собой микросхемы памяти, которые вместе с необходимой электронной обвязкой из SMD-компонентов распаиваются напрямую на материнской плате, либо на текстолитовых плашках. Первый вариант можно встретить в одноплатных компьютерах и некоторых моделях ноутбуков. В настольных компьютерах ОЗУ чаще всего исполнена в виде отдельных модулей.

ОЗУ отличается от устройств постоянной памяти, например жёстких дисков или твердотельных накопителей, большей скоростью работы. Так, современный SSD M.2 NVMe с портом PCI-E 5.0 передаёт данные на скорости до 15 ГБ/с, а оперативная память стандарта DDR5, работающая на минимальной для такого типа ОЗУ частоте в 4800 МГц, выжимает уже 56 ГБ/с. Разница — в 3,7 раза!

Поэтому процессор для обработки информации обращается за необходимыми данными именно к ОЗУ, а не к постоянной памяти. Если бы он общался напрямую с SSD или HDD, то привычные вычисления, которые обычно занимают мгновения, выполнялись бы в несколько раз дольше.

Другими словами, оперативная память — это своего рода посредник между процессором и устройствами постоянной памяти.

Когда пользователь закрывает программу, оперативка выгружает её данные из себя, так как они больше не нужны процессору. Это освобождает место под другие процессы, которые будут запущены пользователем позднее.

Другое важное отличие ОЗУ от постоянных запоминающих устройств, таких как жёсткие диски, SSD или USB-накопители, — энергозависимость. Если прекратить подачу электропитания, например выключить компьютер, вся хранящаяся в оперативной памяти информация стирается.

Виды оперативной памяти

Устройства оперативной памяти делятся на два типа: SRAM и DRAM , различающиеся между собой технологией хранения данных.

SRAM — это статическая ОЗУ, в которой данные хранятся в ячейке с 4–6 транзисторами и конденсаторами. Между транзисторами есть электрическая петля обратной связи, поддерживающая общий заряд ячейки. Поэтому регенерация памяти, то есть сохранение уровня заряда, извне для SRAM не требуется.

DRAM — динамическая оперативная память. Ячейка, как правило, состоит из одного транзистора и одного конденсатора. Последний имеет небольшой размер и быстро разряжается. Поэтому для данного типа ОЗУ необходима регенерация памяти — специальный микроконтроллер на чипах памяти постоянно перезаписывает информацию в ячейке, чтобы она не пропала.

SRAM быстрее DRAM, но дороже в производстве. Поэтому она используется в тех частях устройства, где требуется наибольшее быстродействие. Например, в кэш-памяти процессора . DRAM дешевле и медленнее. Но её скорости достаточно для работы ОЗУ современных компьютеров. Поэтому в плашках оперативной памяти используется именно DRAM.

Также ОЗУ разделяют по форм-фактору. Современный форм-фактор — DIMM , он пришёл на смену SIMM . В последнем контакты были расположены симметрично в один ряд. При этом контакты на противоположных сторонах SIMM замкнуты друг на друге. В DIMM контакты расположены с обеих сторон и не зависят друг от друга. Благодаря этому такой форм-фактор быстрее. Сейчас ОЗУ с SIMM уже нигде не встретить.

DIMM — это общее название группы плашек оперативной памяти, используемой в настольных компьютерах и серверах. Она, в свою очередь, делится на три подтипа:

R-DIMM — серверная ОЗУ. Имеет встроенный механизм автоматического распознавания и коррекции случайных изменений — ошибок битов памяти. Как правило, R-DIMM работает на относительно низких частотах, так как в серверах куда важнее стабильность и отказоустойчивость оборудования, чем скорость обмена информацией с процессором.

U-DIMM — память для обычных настольных компьютеров. В отличие от R-DIMM, она лишена буферного регистра и механизма коррекции ошибок, из-за чего она дешевле в производстве.

SO-DIMM — почти то же самое, что и U-DIMM, только у этого типа памяти плашки поменьше. Используется в ноутбуках, мини-ПК и, очень редко, в стационарных компьютерах с небольшими материнскими платами формата Mini-ITX.

Характеристики оперативной памяти

Теперь, когда мы разобрались с видами оперативной памяти, изучим её характеристики: тип памяти, объём, тактовую частоту и тайминг.

Объём памяти

ОЗУ хранит в себе выполняемый машинный код и все данные, которые необходимы процессору для работы в текущий момент. Благодаря этому ему не нужно обращаться за информацией к медленным устройствам постоянной памяти, например к жёсткому диску, поэтому команды выполняются быстро.

Но объём оперативной памяти ограничен — если используемые процессором данные не будут в него помещаться, то работа замедлится. Часть информации начнёт считываться из постоянной памяти, приводя к задержкам в выполнении команд.

Объём памяти ОЗУ измеряется в гигабайтах. Чем их больше, тем лучше. Сегодня минимальным объёмом для домашнего компьютера можно считать 8 ГБ — этого будет достаточно для работы с текстовыми документами или веб-сёрфинга.

Тип памяти

Тип памяти в современных ОЗУ — DDR (double data rate, «удвоенная скорость передачи»). Этот стандарт появился в 2000 году и используется до сих пор.

Предшественник DDR — SDR (single data rate) — работал так: команда считывалась в момент перехода заряда из 0 в 1. В DDR схему работы изменили — кроме перехода 0 в 1, такой тип памяти учитывает и обратный переход из 1 в 0. То есть за одинаковый промежуток времени обрабатывает два сигнала, а не один, как SDR. Именно с этим связано удвоение скорости передачи данных и название типа памяти.

DDR насчитывает пять поколений, определить которые можно по цифре в названии типа памяти. Они отличаются друг от друга максимальным объёмом памяти на одной плашке и базовой частотой:

Название	Максимальный объём на одной плашке, ГБ	Базовая частота, МГц	Актуальность
DDR	2	200	Устарела
DDR2	4	533	Устарела
DDR3	16	1066	Устарела, но может встречаться на устройствах старше 10 лет
DDR4	128	2133	Активно используется
DDR5	256	4800	Активно используется

Важно! Модули одного поколения физически несовместимы с разъёмами других поколений. Вставить планку DDR3 в слот для DDR4 невозможно.

Тактовая частота

Тактовая частота определяет, сколько операций в секунду может выполнить ОЗУ, — чем она выше, тем выше пропускная способность памяти.

Тактовая частота зависит от поколения оперативной памяти. Например, для DDR4 этот показатель равен 2133 МГц. Некоторые умельцы пытаются увеличить рабочую частоту с помощью её разгона, по аналогии с разгоном процессоров. Например, DDR4 можно разогнать до 3200 МГц, повысив тактовую частоту почти на 30%. Но стоит помнить, что самостоятельный разгон часто заканчивается выходом ОЗУ из строя.

В названиях некоторых плашек оперативной памяти встречается обозначение XMP. XMP, или Extreme Memory Profiles, — технология, позволяющая производителю «зашить» в контроллер ОЗУ профиль, с помощью которого пользователь может разогнать память до частоты, превышающей рекомендуемую JEDEC. Включить XMP можно в BIOS компьютера. Информация о том, как это сделать обычно содержится в инструкции к ОЗУ.

Производители плашек с XMP разгоняют их на заводе и тестируют на стабильность. Поэтому такая память редко выходит из строя, в отличие от устройств, которые для разгона не предназначены.

Тайминги

Тайминги — показатель задержки ОЗУ между отправкой команды и её фактическим исполнением, измеряемый в тактах. Чтобы разобраться в том, что это такое, придётся погрузиться в устройство оперативной памяти на физическом уровне.

Данные в ОЗУ хранятся в виде таблицы со строками и столбцами. В месте их пересечения образуется ячейка, которая содержит заряд — это физическая форма бита. Получив команду чтения или записи данных, микросхема оперативной памяти начинает перебирать строки таблицы в поиске нужной. Делает она это тактами, или «шагами». Количество этих шагов до попадания в нужную строку и столбец таблицы и формирует тайминг, то есть задержку между отправкой команды с микросхемы оперативной памяти до её исполнения.

В зависимости от производителя или магазина в характеристиках могут быть указаны как одна, так и четыре цифры. Делается это потому, что тайминги отражают скорость нескольких процессов обращения к данным, записанным в ячейке. Самое важное число — первое. Поэтому принято называть тайминг именно по её значению. Например, на ОЗУ может быть написано 14-16-16-35 или просто CL14. И то и другое — «четырнадцатый тайминг».

Что значат цифры в этом ряду:

CAS latency (CL) — самый важный показатель. Определяет число тактов, которые успевают пройти между отправкой и исполнением команды.

RAS to CAS delay — число тактов, необходимых для перехода из нужной строки в нужный столбец памяти с данными.

RAS precharge — число тактов, которые пройдут от момента закрытия строки до перехода к следующей строке.

Row activate time — количество тактов до закрытия строки.

Чем меньше значения таймингов — тем лучше. Таким образом, среди двух планок ОЗУ с одинаковой частотой, производительней будет та, у которой тайминги ниже.

Как выбрать оперативную память

При выборе оперативной памяти важно учитывать, какие модели процессора и материнской платы установлены в компьютере, наличие двухканального режима, а также характеристики, о которых мы рассказали выше. Пройдёмся по самым важным аспектам.

Процессор

В любом процессоре установлен контроллер ОЗУ, который определяет, с какими типами оперативной памяти он совместим. Если это не учесть, то купленная плашка оперативки может просто не заработать на компьютере.

Как правило, контроллер ОЗУ работает с одним или реже с двумя стандартами DDR. Поэтому при выборе следует ориентироваться на максимально свежий тип памяти, поддерживаемый процессором.

Например, если кто-то решит собрать себе компьютер на базе недорого процессора Ryzen 5 5600, то в документации к нему он увидит поддержку модулей DDR4 с частотой не выше 3200 МГц. Значит, ему подойдёт любая ОЗУ с данными характеристиками — AMD Radeon R7 Performance Series и её аналоги.

Материнская плата

На материнской плате есть разъёмы для подключения оперативной памяти. Важно, что они совместимы только с конкретными поколениями DDR. То есть в разъём для DDR3 невозможно установить DDR4 и наоборот. Поэтому перед обновлением ОЗУ на компьютере следует изучить руководство к материнской плате, чтобы определить поддерживаемые поколения оперативной памяти.

Тайминги

Помним: чем они ниже — тем лучше. Но не стоит гнаться за самыми низкими значениями — например, CL14 у DDR4, так как особого прироста производительности по сравнению с CL16 или CL18 нет, а цены на них могут различаться очень ощутимо. Например, сравним плашки DDR4 с разным таймингом, но с одинаковым объёмом в 16 ГБ и частотой 3200 МГц. Такая конфигурация с таймингом CL16 обойдётся примерно в 7500 рублей, а с CL14 — уже в 20 500 рублей.

Несмотря на низкие цены, лучше избегать ОЗУ DDR4 с таймингами CL20 и больше. С ними не получится играть без лагов в современные игры, работать с большими проектами в IDE или в программах для видеомонтажа.

Важно! DDR5 в сравнении с DDR4 имеет более высокие тайминги. Например, хороший показатель для пятого поколения ОЗУ — 30. Почему так? Ответ прост. DDR5 имеет большую базовую частоту по сравнению с DDR4, она обеспечивает высокую скорость работы, несмотря на большее значение тайминга. Поэтому не стоит сравнивать тайминги разных поколений ОЗУ.

Объём

С объёмом всё просто:

8 ГБ — необходимый минимум для веб-сёрфинга, офисной работы и нетребовательных игр;
16 ГБ — достаточный объём для игр и простых проектов видеомонтажа и 3D-графики;
32 ГБ и более — для серьёзных задач, связанных с монтажом 4К- и 8К- видео с большим количеством эффектов или для профессионального 3D-моделирования.

Двухканальный режим

Ускорить работу ОЗУ можно с помощью установки двух и более планок одновременно. Это активирует двухканальный режим их работы, распараллеливающий обмен информацией с процессором. Благодаря этому пропускная способность памяти может увеличиться вдвое, что повышает производительность компьютера. Конкретные показатели прироста пропускной способности зависят от модели материнской платы и ОЗУ.

Для правильной установки и активации двухканального режима прочтите руководство к вашей модели материнской платы. В нём будет указано, в какие слоты нужно установить модули для включения двухканального режима.

Что запомнить

Резюме по тому, о чём рассказали в статье:

ОЗУ, или оперативная память, содержит только ту информацию, которая необходима для текущей работы операционной системы и запущенных программ. Это тип памяти, предназначенный для быстрой передачи данных на обработку процессору.
Стандарт DDR обозначает поколение оперативной памяти. Самые современные — DDR4 и DDR5.
Объём ОЗУ — это показатель того, как много данных она может хранить в себе, передавая их процессору. Чем больше объём, тем ниже шансы подвисания программы или игр.
Тактовая частота ОЗУ определяет то, сколько операций в секунду может выполнить ОЗУ. Чем она выше, тем выше пропускная способность памяти.
Тайминги ОЗУ показывают задержку между отправкой команды и её фактическим исполнением, измеряемую в тактах. Чем они ниже, тем быстрее работа оперативной памяти.
При выборе оперативной памяти для вашего компьютера нужно обращать внимание на модель материнской платы и процессора, требуемый объём и величину тайминга, а также на возможность модуля работать в двухканальном режиме.

Больше интересного про код — в нашем телеграм-канале. Подписывайтесь!