Карта сайта Kansoftware
НОВОСТИУСЛУГИРЕШЕНИЯКОНТАКТЫ
Разработка программного обеспечения

Reference

Boost , The Boost C++ Libraries BoostBook Documentation Subset , Chapter 11. Boost.DLL

Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. — Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

PrevUpHomeNext
Shared Library Reference
Shared Library Refcountable Reference

Shared Library Reference

Header <boost/dll/alias.hpp>
Header <boost/dll/library_info.hpp>
Header <boost/dll/runtime_symbol_info.hpp>
Header <boost/dll/shared_library.hpp>
Header <boost/dll/shared_library_load_mode.hpp>
Header <boost/dll/smart_library.hpp>

Включает псевдонимные методы и макро. Вы можете включить эту заголовку или увеличить / dll/shared_library.hpp, чтобы уменьшить зависимости в случае, если вы не используете преломляемые функции.

BOOST_DLL_FORCE_ALIAS_INSTANTIATION
BOOST_DLL_FORCE_NO_WEAK_EXPORTS
BOOST_DLL_SELECTANY
BOOST_DLL_SECTION(SectionName, Permissions)
BOOST_DLL_ALIAS(FunctionOrVar, AliasName)
BOOST_DLL_ALIAS_SECTIONED(FunctionOrVar, AliasName, SectionName)
BOOST_DLL_AUTO_ALIAS(FunctionOrVar)

Содержит только boost::dll::library_info класс, способный извлекать различную информацию из бинарных файлов.

namespace boost {
  namespace dll {
    class library_info;
  }
}

Предоставляет методы для получения приемлемого по boost::dll::shared_library расположение символа, исходной линии или программы.

namespace boost {
  namespace dll {
    template<typename T> 
      boost::filesystem::path 
      symbol_location(const T &, boost::system::error_code &);
    template<typename T> boost::filesystem::path symbol_location(const T &);
    boost::filesystem::path this_line_location(boost::system::error_code &);
    boost::filesystem::path this_line_location();
    boost::filesystem::path program_location(boost::system::error_code &);
    boost::filesystem::path program_location();
  }
}

Содержит boost::dll::shared_library класс, основной класс для всех операций DLL/DSO.

namespace boost {
  namespace dll {
    class shared_library;
    // Very fast equality check that compares the actual DLL/DSO objects. Throws nothing. 
    bool operator==(const shared_library & lhs, const shared_library & rhs);
    // Very fast inequality check that compares the actual DLL/DSO objects. Throws nothing. 
    bool operator!=(const shared_library & lhs, const shared_library & rhs);
    // Compare the actual DLL/DSO objects without any guarantee to be stable between runs. Throws nothing. 
    bool operator<(const shared_library & lhs, const shared_library & rhs);
    // Swaps two shared libraries. Does not invalidate symbols and functions loaded from libraries. Throws nothing. 
    void swap(shared_library & lhs, shared_library & rhs);
  }
}

Содержит только импульс::dll::load_mode::type enum и операторов, связанных с ним.

namespace boost {
  namespace dll {
    namespace load_mode {
      enum type;
      // Free operators for load_mode::type flag manipulation. 
      BOOST_CONSTEXPR type operator|(type left, type right);
      BOOST_CXX14_CONSTEXPR type & operator|=(type & left, type right);
      BOOST_CONSTEXPR type operator&(type left, type right);
      BOOST_CXX14_CONSTEXPR type & operator&=(type & left, type right);
      BOOST_CONSTEXPR type operator^(type left, type right);
      BOOST_CXX14_CONSTEXPR type & operator^=(type & left, type right);
      BOOST_CONSTEXPR type operator~(type left);
    }
  }
}

Содержит boost::dll::experimental::smart_library класс для загрузки мангрированных символов.

[Warning]Warning

Очень экспериментально! Требуется C++14! изменится в следующей версии Boost! бульон / смарт _library.hpp не включен в бульвар / dll.hpp

namespace boost {
  namespace dll {
    namespace experimental {
      class smart_library;
      // Very fast equality check that compares the actual DLL/DSO objects. Throws nothing. 
      bool operator==(const smart_library & lhs, const smart_library & rhs);
      // Very fast inequality check that compares the actual DLL/DSO objects. Throws nothing. 
      bool operator!=(const smart_library & lhs, const smart_library & rhs);
      // Compare the actual DLL/DSO objects without any guarantee to be stable between runs. Throws nothing. 
      bool operator<(const smart_library & lhs, const smart_library & rhs);
      // Swaps two shared libraries. Does not invalidate symbols and functions loaded from libraries. Throws nothing. 
      void swap(smart_library & lhs, smart_library & rhs);
      template<typename T, typename T2> 
        void get(const smart_library &, const std::string &);
      template<typename T> 
        T & get(const smart_library & sm, const std::string & name, 
                typename boost::enable_if< boost::is_object< T >, T >::type * = nullptr);
      template<typename T> 
        auto get(const smart_library & sm, const std::string & name, 
                 typename boost::enable_if< boost::is_function< T >>::type * = nullptr);
      template<typename Class, typename Signature> 
        auto get(const smart_library &, const std::string &);
    }
  }
}

Shared Library Refcountable Reference

Header <boost/dll/import.hpp>
Header <boost/dll/import_class.hpp>
Header <boost/dll/import_mangled.hpp>

Содержит весь импульс::dll:: Import* контрольные функции подсчета, которые имеют общий указатель на случай увеличения::dll::shared_library.

namespace boost {
  namespace dll {
    template<typename T> 
      result_type import(const boost::filesystem::path &, const char *, 
                         load_mode::type = load_mode::default_mode);
    template<typename T> 
      result_type import(const boost::filesystem::path &, const std::string &, 
                         load_mode::type = load_mode::default_mode);
    template<typename T> 
      result_type import(const shared_library &, const char *);
    template<typename T> 
      result_type import(const shared_library &, const std::string &);
    template<typename T> result_type import(shared_library &&, const char *);
    template<typename T> 
      result_type import(shared_library &&, const std::string &);
    template<typename T> 
      result_type import_alias(const boost::filesystem::path &, const char *, 
                               load_mode::type = load_mode::default_mode);
    template<typename T> 
      result_type import_alias(const boost::filesystem::path &, 
                               const std::string &, 
                               load_mode::type = load_mode::default_mode);
    template<typename T> 
      result_type import_alias(const shared_library &, const char *);
    template<typename T> 
      result_type import_alias(const shared_library &, const std::string &);
    template<typename T> 
      result_type import_alias(shared_library &&, const char *);
    template<typename T> 
      result_type import_alias(shared_library &&, const std::string &);
  }
}
namespace boost {
  namespace dll {
    namespace experimental {
      template<typename T> class imported_class;
      template<typename T, typename... Args> 
        imported_class< T > 
        import_class(const smart_library &, std::size_t, Args...);
      template<typename T, typename... Args> 
        imported_class< T > 
        import_class(const smart_library &, std::size_t, const std::string &, 
                     Args...);
      template<typename T, typename... Args> 
        imported_class< T > 
        import_class(const smart_library &, const std::string &, std::size_t, 
                     Args...);
      template<typename T, typename... Args> 
        imported_class< T > import_class(smart_library &&, Args...);
      template<typename T, typename... Args> 
        imported_class< T > 
        import_class(smart_library &&, const std::string &, Args...);
      template<typename T, typename... Args> 
        imported_class< T > 
        import_class(smart_library &&, std::size_t, Args...);
      template<typename T, typename... Args> 
        imported_class< T > 
        import_class(smart_library &&, std::size_t, const std::string &, 
                     Args...);
      template<typename T, typename... Args> 
        imported_class< T > 
        import_class(smart_library &&, const std::string &, std::size_t, 
                     Args...);
      template<typename T, typename... Args> 
        imported_class< T > import_class(smart_library & lib, Args... args);
      template<typename T, typename... Args> 
        imported_class< T > 
        import_class(smart_library & lib, const std::string & alias_name, 
                     Args... args);
      template<typename T, typename... Args> 
        imported_class< T > 
        import_class(smart_library & lib, std::size_t size, Args... args);
      template<typename T, typename... Args> 
        imported_class< T > 
        import_class(smart_library & lib, std::size_t size, 
                     const std::string & alias_name, Args... args);
      template<typename T, typename... Args> 
        imported_class< T > 
        import_class(smart_library & lib, const std::string & alias_name, 
                     std::size_t size, Args... args);
    }
  }
}
namespace boost {
  namespace dll {
    namespace experimental {
      template<class... Args> 
        result_type import_mangled(const boost::filesystem::path &, 
                                   const char *, 
                                   load_mode::type = load_mode::default_mode);
      template<class... Args> 
        result_type import_mangled(const boost::filesystem::path &, 
                                   const std::string &, 
                                   load_mode::type = load_mode::default_mode);
      template<class... Args> 
        result_type import_mangled(const smart_library &, const char *);
      template<class... Args> 
        result_type import_mangled(const smart_library &, const std::string &);
      template<class... Args> 
        result_type import_mangled(smart_library &&, const char *);
      template<class... Args> 
        result_type import_mangled(smart_library &&, const std::string &);
      template<class... Args> 
        result_type import_mangled(const shared_library &, const char *);
      template<class... Args> 
        result_type import_mangled(const shared_library &, 
                                   const std::string &);
      template<class... Args> 
        result_type import_mangled(shared_library &&, const char *);
      template<class... Args> 
        result_type import_mangled(shared_library &&, const std::string &);
    }
  }
}
Copyright © 2014 Renato Tegon Forti, Antony Polukhin
Copyright © 2015 Antony Polukhin
Copyright © 2016 Antony Polukhin, Klemens Morgenstern

Distributed under the Boost Software License, Version 1.0. http://www.boost.org/LICENSE_1_0.txt

PrevUpHomeNext

Статья Reference раздела The Boost C++ Libraries BoostBook Documentation Subset Chapter 11. Boost.DLL может быть полезна для разработчиков на c++ и boost.




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


:: Главная :: Chapter 11. Boost.DLL ::

реклама
©KANSoftWare (разработка программного обеспечения, создание программ, создание интерактивных сайтов), 2007
Top.Mail.Ru

Время компиляции файла: 2024-08-30 11:47:00
2025-05-19 17:49:08/0.010707139968872/1