Menu

- Learn
- Documentation
  - Language Reference
  - Library Reference
  - Command-line Reference
  - Feature Overview
  - Articles
- Downloads
- Packages
- Community
  - Blog
  - Orgs using D
  - Twitter
  - Calendar
  - Forums
  - IRC
  - Community Discord
  - Wiki
  - GitHub
  - Issues
  - Get involved
  - Contributors
  - Foundation
  - Security Team
  - Donate
  - Sponsors
- Resources
  - Tour
  - Books
  - Tutorials
  - Tools
  - Editors
  - IDEs
  - run.dlang.io
  - Visual D
  - Acknowledgments
  - D Style
  - Glossary
  - Sitemap

Search
Report a bug
If you spot a problem with this page, click here to create a Bugzilla issue.
Improve this page
Quickly fork, edit online, and submit a pull request for this page. Requires a signed-in GitHub account. This works well for small changes. If you'd like to make larger changes you may want to consider using a local clone.

# std.experimental.allocator.mallocator

The C heap allocator.

Source std/experimental/allocator/mallocator.d

struct `Mallocator`;
  The C heap allocator.
  Examples:

      auto buffer = Mallocator.instance.allocate(1024 * 1024 * 4);
      scope(exit) Mallocator.instance.deallocate(buffer);
      //...

  enum uint `alignment`;
    The alignment is a static constant equal to platformAlignment, which ensures proper alignment for any D data type.
  shared const pure nothrow @nogc @trusted void[] `allocate`(size_t `bytes`);
  shared const pure nothrow @nogc @system bool `deallocate`(void[] `b`);
  shared const pure nothrow @nogc @system bool `reallocate`(ref void[] `b`, size_t `s`);
    Standard allocator methods per the semantics defined above. The `deallocate` and `reallocate` methods are @system because they may move memory around, leaving dangling pointers in user code. Somewhat paradoxically, malloc is @safe but that's only useful to safe programs that can afford to leak memory allocated.
  static shared Mallocator `instance`;
    Returns the global instance of this allocator type. The C heap allocator is thread-safe, therefore all of its methods and it itself are shared.
struct `AlignedMallocator`;
  Aligned allocator using OS-specific primitives, under a uniform API.
  Examples:

      auto buffer = AlignedMallocator.instance.alignedAllocate(1024 * 1024 * 4,
          128);
      scope(exit) AlignedMallocator.instance.deallocate(buffer);
      //...

  enum uint `alignment`;
    The default alignment is platformAlignment.
  shared nothrow @nogc @trusted void[] `allocate`(size_t `bytes`);
    Forwards to alignedAllocate(bytes, platformAlignment).
  shared nothrow @nogc @trusted void[] `alignedAllocate`(size_t `bytes`, uint `a`);
    Uses posix_memalign on Posix and __aligned_malloc on Windows.
  shared nothrow @nogc @system bool `deallocate`(void[] `b`);
    Calls free(`b`.ptr) on Posix and __aligned_free(`b`.ptr) on Windows.
  shared nothrow @nogc @system bool `reallocate`(ref void[] `b`, size_t `newSize`);
  shared nothrow @nogc @system bool `alignedReallocate`(ref void[] `b`, size_t `s`, uint `a`);
    Forwards to alignedReallocate(b, newSize, platformAlignment). Should be used with blocks obtained with allocate otherwise the custom alignment passed with alignedAllocate can be lost.
  static shared AlignedMallocator `instance`;
    Returns the global instance of this allocator type. The C heap allocator is thread-safe, therefore all of its methods and `instance` itself are shared.

Copyright © 1999-2021 by the D Language Foundation | Page generated by Ddoc on Sun Dec 19 20:55:10 2021