Repository: Alinshans/MyTinySTL Branch: master Commit: f86437ecffe8 Files: 59 Total size: 620.5 KB Directory structure: gitextract_bjpk8nmi/ ├── .gitattributes ├── .gitignore ├── .travis.yml ├── CMakeLists.txt ├── License.txt ├── MSVC/ │ ├── MyTinySTL_VS2015.sln │ ├── MyTinySTL_VS2015.vcxproj │ └── MyTinySTL_VS2015.vcxproj.filters ├── MyTinySTL/ │ ├── algo.h │ ├── algobase.h │ ├── algorithm.h │ ├── alloc.h │ ├── allocator.h │ ├── astring.h │ ├── basic_string.h │ ├── construct.h │ ├── deque.h │ ├── exceptdef.h │ ├── functional.h │ ├── hashtable.h │ ├── heap_algo.h │ ├── iterator.h │ ├── list.h │ ├── map.h │ ├── memory.h │ ├── numeric.h │ ├── queue.h │ ├── rb_tree.h │ ├── set.h │ ├── set_algo.h │ ├── stack.h │ ├── stream_iterator.h │ ├── type_traits.h │ ├── uninitialized.h │ ├── unordered_map.h │ ├── unordered_set.h │ ├── util.h │ └── vector.h ├── README.md ├── Test/ │ ├── CMakeLists.txt │ ├── Lib/ │ │ └── redbud/ │ │ ├── io/ │ │ │ └── color.h │ │ └── platform.h │ ├── README.md │ ├── algorithm_performance_test.h │ ├── algorithm_test.h │ ├── deque_test.h │ ├── iterator_test.h │ ├── list_test.h │ ├── map_test.h │ ├── queue_test.h │ ├── set_test.h │ ├── stack_test.h │ ├── string_test.h │ ├── test.cpp │ ├── test.h │ ├── unordered_map_test.h │ ├── unordered_set_test.h │ └── vector_test.h └── appveyor.yml ================================================ FILE CONTENTS ================================================ ================================================ FILE: .gitattributes ================================================ ############################################################################### # Set default behavior to automatically normalize line endings. ############################################################################### * text=auto ############################################################################### # Set default behavior for command prompt diff. # # This is need for earlier builds of msysgit that does not have it on by # default for csharp files. # Note: This is only used by command line ############################################################################### #*.cs diff=csharp ############################################################################### # Set the merge driver for project and solution files # # Merging from the command prompt will add diff markers to the files if there # are conflicts (Merging from VS is not affected by the settings below, in VS # the diff markers are never inserted). Diff markers may cause the following # file extensions to fail to load in VS. An alternative would be to treat # these files as binary and thus will always conflict and require user # intervention with every merge. To do so, just uncomment the entries below ############################################################################### #*.sln merge=binary #*.csproj merge=binary #*.vbproj merge=binary #*.vcxproj merge=binary #*.vcproj merge=binary #*.dbproj merge=binary #*.fsproj merge=binary #*.lsproj merge=binary #*.wixproj merge=binary #*.modelproj merge=binary #*.sqlproj merge=binary #*.wwaproj merge=binary ############################################################################### # behavior for image files # # image files are treated as binary by default. ############################################################################### #*.jpg binary #*.png binary #*.gif binary ############################################################################### # diff behavior for common document formats # # Convert binary document formats to text before diffing them. This feature # is only available from the command line. Turn it on by uncommenting the # entries below. ############################################################################### #*.doc diff=astextplain #*.DOC diff=astextplain #*.docx diff=astextplain #*.DOCX diff=astextplain #*.dot diff=astextplain #*.DOT diff=astextplain #*.pdf diff=astextplain #*.PDF diff=astextplain #*.rtf diff=astextplain #*.RTF diff=astextplain ================================================ FILE: .gitignore ================================================ ## Ignore Visual Studio temporary files, build results, and ## files generated by popular Visual Studio add-ons. # Local build files *c.cmd *a.exe # User-specific files *.suo *.user *.userosscache *.sln.docstates # User-specific files (MonoDevelop/Xamarin Studio) *.userprefs # Build results [Dd]ebug/ [Dd]ebugPublic/ [Rr]elease/ [Rr]eleases/ [Xx]64/ [Xx]86/ [Bb]uild/ bld/ [Bb]in/ [Oo]bj/ # Visual Studio 2015 cache/options directory .vs/ # Visual Studio Code .vscode/ # Uncomment if you have tasks that create the project's static files in wwwroot #wwwroot/ # MSTest test Results [Tt]est[Rr]esult*/ [Bb]uild[Ll]og.* # NUNIT *.VisualState.xml TestResult.xml # Build Results of an ATL Project [Dd]ebugPS/ [Rr]eleasePS/ dlldata.c # DNX project.lock.json artifacts/ *_i.c *_p.c *_i.h *.ilk *.meta *.obj *.pch *.pdb *.pgc *.pgd *.rsp *.sbr *.tlb *.tli *.tlh *.tmp *.tmp_proj *.log *.vspscc *.vssscc .builds *.pidb *.svclog *.scc # Chutzpah Test files _Chutzpah* # Visual C++ cache files ipch/ *.aps *.ncb *.opendb *.opensdf *.sdf *.cachefile *.VC.db # Visual Studio profiler *.psess *.vsp *.vspx *.sap # TFS 2012 Local Workspace $tf/ # Guidance Automation Toolkit *.gpState # ReSharper is a .NET coding add-in _ReSharper*/ *.[Rr]e[Ss]harper *.DotSettings.user # JustCode is a .NET coding add-in .JustCode # TeamCity is a build add-in _TeamCity* # DotCover is a Code Coverage Tool *.dotCover # NCrunch _NCrunch_* .*crunch*.local.xml nCrunchTemp_* # MightyMoose *.mm.* AutoTest.Net/ # Web workbench (sass) .sass-cache/ # Installshield output folder [Ee]xpress/ # DocProject is a documentation generator add-in DocProject/buildhelp/ DocProject/Help/*.HxT DocProject/Help/*.HxC DocProject/Help/*.hhc DocProject/Help/*.hhk DocProject/Help/*.hhp DocProject/Help/Html2 DocProject/Help/html # Click-Once directory publish/ # Publish Web Output *.[Pp]ublish.xml *.azurePubxml # TODO: Un-comment the next line if you do not want to checkin # your web deploy settings because they may include unencrypted # passwords #*.pubxml *.publishproj # NuGet Packages *.nupkg # The packages folder can be ignored because of Package Restore **/packages/* # except build/, which is used as an MSBuild target. !**/packages/build/ # Uncomment if necessary however generally it will be regenerated when needed #!**/packages/repositories.config # NuGet v3's project.json files produces more ignoreable files *.nuget.props *.nuget.targets # Microsoft Azure Build Output csx/ *.build.csdef # Microsoft Azure Emulator ecf/ rcf/ # Microsoft Azure ApplicationInsights config file ApplicationInsights.config # Windows Store app package directory AppPackages/ BundleArtifacts/ # Visual Studio cache files # files ending in .cache can be ignored *.[Cc]ache # but keep track of directories ending in .cache !*.[Cc]ache/ # Others ClientBin/ [Ss]tyle[Cc]op.* ~$* *~ *.dbmdl *.dbproj.schemaview *.pfx *.publishsettings node_modules/ orleans.codegen.cs # RIA/Silverlight projects Generated_Code/ # Backup & report files from converting an old project file # to a newer Visual Studio version. Backup files are not needed, # because we have git ;-) _UpgradeReport_Files/ Backup*/ UpgradeLog*.XML UpgradeLog*.htm # SQL Server files *.mdf *.ldf # Business Intelligence projects *.rdl.data *.bim.layout *.bim_*.settings # Microsoft Fakes FakesAssemblies/ # GhostDoc plugin setting file *.GhostDoc.xml # Node.js Tools for Visual Studio .ntvs_analysis.dat # Visual Studio 6 build log *.plg # Visual Studio 6 workspace options file *.opt # Visual Studio LightSwitch build output **/*.HTMLClient/GeneratedArtifacts **/*.DesktopClient/GeneratedArtifacts **/*.DesktopClient/ModelManifest.xml **/*.Server/GeneratedArtifacts **/*.Server/ModelManifest.xml _Pvt_Extensions # LightSwitch generated files GeneratedArtifacts/ ModelManifest.xml # Paket dependency manager .paket/paket.exe # FAKE - F# Make .fake/ ================================================ FILE: .travis.yml ================================================ language: cpp # ubuntu 14.04 version sudo: required dist: trusty matrix: include: - os: linux compiler: gcc addons: apt: sources: ['ubuntu-toolchain-r-test'] packages: ['g++-5'] env: - MATRIX_EVAL="CC=gcc-5 && CXX=g++-5" - os: linux compiler: gcc addons: apt: sources: ['ubuntu-toolchain-r-test'] packages: ['g++-6'] env: - MATRIX_EVAL="CC=gcc-6 && CXX=g++-6" - os: linux compiler: gcc addons: apt: sources: ['ubuntu-toolchain-r-test'] packages: ['g++-7'] env: - MATRIX_EVAL="CC=gcc-7 && CXX=g++-7" - os: osx osx_image: xcode5 env: - MATRIX_EVAL="CC=clang && CXX=clang++" - os: osx osx_image: xcode6 env: - MATRIX_EVAL="CC=clang && CXX=clang++" - os: osx osx_image: xcode7 env: - MATRIX_EVAL="CC=clang && CXX=clang++" - os: osx osx_image: xcode8 env: - MATRIX_EVAL="CC=clang && CXX=clang++" before_script: - eval "${MATRIX_EVAL}" - $CXX --version script: - mkdir build && cd ./build - cmake .. - make - cd ../bin && ./stltest branches: only: - master notifications: email: false ================================================ FILE: CMakeLists.txt ================================================ cmake_minimum_required(VERSION 2.8) project(MyTinySTL) # version set(MyTinySTL_VERSION_MAJOR 2) set(MyTinySTL_VERSION_MINOR 0) set(MyTinySTL_VERSION_PATCH 0) set(MyTinySTL_VERSION "${MyTinySTL_VERSION_MAJOR}.${MyTinySTL_VERSION_MINOR}.${MyTinySTL_VERSION_PATCH}") message(STATUS "The version of this project is: ${MyTinySTL_VERSION}") # build type set(CMAKE_BUILD_TYPE release) if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O2 -Wall -Wextra -Wno-sign-compare -Wno-unused-but-set-variable -Wno-array-bounds") # set(EXTRA_CXX_FLAGS -Weffc++ -Wswitch-default -Wfloat-equal -Wconversion -Wsign-conversion) if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS "5.0.0") message(FATAL_ERROR "required GCC 5.0 or later") else() set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11") endif() elseif (CMAKE_CXX_COMPILER_ID MATCHES "Clang") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O2 -Wall -Wextra -Wno-sign-compare") # set(EXTRA_CXX_FLAGS -Weffc++ -Wswitch-default -Wfloat-equal -Wconversion -Wimplicit-fallthrough) if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS "3.5.0") message(FATAL_ERROR "required Clang 3.5 or later") else() set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11") endif() endif() message(STATUS "The cmake_cxx_flags is: ${CMAKE_CXX_FLAGS}") add_subdirectory(${PROJECT_SOURCE_DIR}/Test) ================================================ FILE: License.txt ================================================ Copyright (c) 2016-2017 Alinshans. All rights reserved. First published on github, see https://github.com/Alinshans/MyTinySTL The MyTinySTL source code is licensed under the MIT License. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ================================================ FILE: MSVC/MyTinySTL_VS2015.sln ================================================ Microsoft Visual Studio Solution File, Format Version 12.00 # Visual Studio 14 VisualStudioVersion = 14.0.25420.1 MinimumVisualStudioVersion = 10.0.40219.1 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "MyTinySTL", "MyTinySTL_VS2015.vcxproj", "{E88807F6-B07C-4371-BD38-FB1569F894E4}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|x64 = Debug|x64 Debug|x86 = Debug|x86 Release|x64 = Release|x64 Release|x86 = Release|x86 EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution {E88807F6-B07C-4371-BD38-FB1569F894E4}.Debug|x64.ActiveCfg = Debug|x64 {E88807F6-B07C-4371-BD38-FB1569F894E4}.Debug|x64.Build.0 = Debug|x64 {E88807F6-B07C-4371-BD38-FB1569F894E4}.Debug|x86.ActiveCfg = Debug|Win32 {E88807F6-B07C-4371-BD38-FB1569F894E4}.Debug|x86.Build.0 = Debug|Win32 {E88807F6-B07C-4371-BD38-FB1569F894E4}.Release|x64.ActiveCfg = Release|x64 {E88807F6-B07C-4371-BD38-FB1569F894E4}.Release|x64.Build.0 = Release|x64 {E88807F6-B07C-4371-BD38-FB1569F894E4}.Release|x86.ActiveCfg = Release|Win32 {E88807F6-B07C-4371-BD38-FB1569F894E4}.Release|x86.Build.0 = Release|Win32 EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE EndGlobalSection EndGlobal ================================================ FILE: MSVC/MyTinySTL_VS2015.vcxproj ================================================  Debug Win32 Release Win32 Debug x64 Release x64 {E88807F6-B07C-4371-BD38-FB1569F894E4} Win32Proj MyTinySTL 8.1 MyTinySTL Application true v140 Unicode Application false v140 true Unicode Application true v140 Unicode Application false v140 true Unicode true true false false Level3 Disabled WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) true Console true Level4 Disabled _DEBUG;_CONSOLE;%(PreprocessorDefinitions) true Console true Level3 MaxSpeed true true WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) true Console true true true Level4 MaxSpeed true true NDEBUG;_CONSOLE;%(PreprocessorDefinitions) true Console true true true ================================================ FILE: MSVC/MyTinySTL_VS2015.vcxproj.filters ================================================  {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms {93995380-89BD-4b04-88EB-625FBE52EBFB} h;hh;hpp;hxx;hm;inl;inc;xsd {4FC737F1-C7A5-4376-A066-2A32D752A2FF} cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx {ec314ff3-dcde-4cac-a63a-4f6827750d0a} {c6f24d77-e6f0-439e-954a-c0ca577689d5} include include include include include include include include include include include include include include include include include include include include include include include include include include test test test test test test test test test test test test test test\Lib test\Lib include include include test ================================================ FILE: MyTinySTL/algo.h ================================================ #ifndef MYTINYSTL_ALGO_H_ #define MYTINYSTL_ALGO_H_ #ifdef _MSC_VER #pragma warning(push) #pragma warning(disable : 4244) #endif // 这个头文件包含了 mystl 的一系列算法 #include #include #include "algobase.h" #include "memory.h" #include "heap_algo.h" #include "functional.h" namespace mystl { /*****************************************************************************************/ // all_of // 检查[first, last)内是否全部元素都满足一元操作 unary_pred 为 true 的情况，满足则返回 true /*****************************************************************************************/ template bool all_of(InputIter first, InputIter last, UnaryPredicate unary_pred) { for (; first != last; ++first) { if (!unary_pred(*first)) return false; } return true; } /*****************************************************************************************/ // any_of // 检查[first, last)内是否存在某个元素满足一元操作 unary_pred 为 true 的情况，满足则返回 true /*****************************************************************************************/ template bool any_of(InputIter first, InputIter last, UnaryPredicate unary_pred) { for (; first != last; ++first) { if (unary_pred(*first)) return true; } return false; } /*****************************************************************************************/ // none_of // 检查[first, last)内是否全部元素都不满足一元操作 unary_pred 为 true 的情况，满足则返回 true /*****************************************************************************************/ template bool none_of(InputIter first, InputIter last, UnaryPredicate unary_pred) { for (; first != last; ++first) { if (unary_pred(*first)) return false; } return true; } /*****************************************************************************************/ // count // 对[first, last)区间内的元素与给定值进行比较，缺省使用 operator==，返回元素相等的个数 /*****************************************************************************************/ template size_t count(InputIter first, InputIter last, const T& value) { size_t n = 0; for (; first != last; ++first) { if (*first == value) ++n; } return n; } /*****************************************************************************************/ // count_if // 对[first, last)区间内的每个元素都进行一元 unary_pred 操作，返回结果为 true 的个数 /*****************************************************************************************/ template size_t count_if(InputIter first, InputIter last, UnaryPredicate unary_pred) { size_t n = 0; for (; first != last; ++first) { if (unary_pred(*first)) ++n; } return n; } /*****************************************************************************************/ // find // 在[first, last)区间内找到等于 value 的元素，返回指向该元素的迭代器 /*****************************************************************************************/ template InputIter find(InputIter first, InputIter last, const T& value) { while (first != last && *first != value) ++first; return first; } /*****************************************************************************************/ // find_if // 在[first, last)区间内找到第一个令一元操作 unary_pred 为 true 的元素并返回指向该元素的迭代器 /*****************************************************************************************/ template InputIter find_if(InputIter first, InputIter last, UnaryPredicate unary_pred) { while (first != last && !unary_pred(*first)) ++first; return first; } /*****************************************************************************************/ // find_if_not // 在[first, last)区间内找到第一个令一元操作 unary_pred 为 false 的元素并返回指向该元素的迭代器 /*****************************************************************************************/ template InputIter find_if_not(InputIter first, InputIter last, UnaryPredicate unary_pred) { while (first != last && unary_pred(*first)) ++first; return first; } /*****************************************************************************************/ // search // 在[first1, last1)中查找[first2, last2)的首次出现点 /*****************************************************************************************/ template ForwardIter1 search(ForwardIter1 first1, ForwardIter1 last1, ForwardIter2 first2, ForwardIter2 last2) { auto d1 = mystl::distance(first1, last1); auto d2 = mystl::distance(first2, last2); if (d1 < d2) return last1; auto current1 = first1; auto current2 = first2; while (current2 != last2) { if (*current1 == *current2) { ++current1; ++current2; } else { if (d1 == d2) { return last1; } else { current1 = ++first1; current2 = first2; --d1; } } } return first1; } // 重载版本使用函数对象 comp 代替比较操作 template ForwardIter1 search(ForwardIter1 first1, ForwardIter1 last1, ForwardIter2 first2, ForwardIter2 last2, Compared comp) { auto d1 = mystl::distance(first1, last1); auto d2 = mystl::distance(first2, last2); if (d1 < d2) return last1; auto current1 = first1; auto current2 = first2; while (current2 != last2) { if (comp(*current1, *current2)) { ++current1; ++current2; } else { if (d1 == d2) { return last1; } else { current1 = ++first1; current2 = first2; --d1; } } } return first1; } /*****************************************************************************************/ // search_n // 在[first, last)中查找连续 n 个 value 所形成的子序列，返回一个迭代器指向该子序列的起始处 /*****************************************************************************************/ template ForwardIter search_n(ForwardIter first, ForwardIter last, Size n, const T& value) { if (n <= 0) { return first; } else { first = mystl::find(first, last, value); while (first != last) { auto m = n - 1; auto i = first; ++i; while (i != last && m != 0 && *i == value) { ++i; --m; } if (m == 0) { return first; } else { first = mystl::find(i, last, value); } } return last; } } // 重载版本使用函数对象 comp 代替比较操作 template ForwardIter search_n(ForwardIter first, ForwardIter last, Size n, const T& value, Compared comp) { if (n <= 0) { return first; } else { while (first != last) { if (comp(*first, value)) break; ++first; } while (first != last) { auto m = n - 1; auto i = first; ++i; while (i != last && m != 0 && comp(*i, value)) { ++i; --m; } if (m == 0) { return first; } else { while (i != last) { if (comp(*i, value)) break; ++i; } first = i; } } return last; } } /*****************************************************************************************/ // find_end // 在[first1, last1)区间中查找[first2, last2)最后一次出现的地方，若不存在返回 last1 /*****************************************************************************************/ // find_end_dispatch 的 forward_iterator_tag 版本 template ForwardIter1 find_end_dispatch(ForwardIter1 first1, ForwardIter1 last1, ForwardIter2 first2, ForwardIter2 last2, forward_iterator_tag, forward_iterator_tag) { if (first2 == last2) { return last1; } else { auto result = last1; while (true) { // 利用 search 查找某个子序列的首次出现点，找不到则返回 last1 auto new_result = mystl::search(first1, last1, first2, last2); if (new_result == last1) { return result; } else { result = new_result; first1 = new_result; ++first1; } } } } // find_end_dispatch 的 bidirectional_iterator_tag 版本 template BidirectionalIter1 find_end_dispatch(BidirectionalIter1 first1, BidirectionalIter1 last1, BidirectionalIter2 first2, BidirectionalIter2 last2, bidirectional_iterator_tag, bidirectional_iterator_tag) { typedef reverse_iterator reviter1; typedef reverse_iterator reviter2; reviter1 rlast1(first1); reviter2 rlast2(first2); reviter1 rresult = mystl::search(reviter1(last1), rlast1, reviter2(last2), rlast2); if (rresult == rlast1) { return last1; } else { auto result = rresult.base(); mystl::advance(result, -mystl::distance(first2, last2)); return result; } } template ForwardIter1 find_end(ForwardIter1 first1, ForwardIter1 last1, ForwardIter2 first2, ForwardIter2 last2) { typedef typename iterator_traits::iterator_category Category1; typedef typename iterator_traits::iterator_category Category2; return mystl::find_end_dispatch(first1, last1, first2, last2, Category1(), Category2()); } // 重载版本使用函数对象 comp 代替比较操作 // find_end_dispatch 的 forward_iterator_tag 版本 template ForwardIter1 find_end_dispatch(ForwardIter1 first1, ForwardIter1 last1, ForwardIter2 first2, ForwardIter2 last2, forward_iterator_tag, forward_iterator_tag, Compared comp) { if (first2 == last2) { return last1; } else { auto result = last1; while (true) { // 利用 search 查找某个子序列的首次出现点，找不到则返回 last1 auto new_result = mystl::search(first1, last1, first2, last2, comp); if (new_result == last1) { return result; } else { result = new_result; first1 = new_result; ++first1; } } } } // find_end_dispatch 的 bidirectional_iterator_tag 版本 template BidirectionalIter1 find_end_dispatch(BidirectionalIter1 first1, BidirectionalIter1 last1, BidirectionalIter2 first2, BidirectionalIter2 last2, bidirectional_iterator_tag, bidirectional_iterator_tag, Compared comp) { typedef reverse_iterator reviter1; typedef reverse_iterator reviter2; reviter1 rlast1(first1); reviter2 rlast2(first2); reviter1 rresult = mystl::search(reviter1(last1), rlast1, reviter2(last2), rlast2, comp); if (rresult == rlast1) { return last1; } else { auto result = rresult.base(); mystl::advance(result, -mystl::distance(first2, last2)); return result; } } template ForwardIter1 find_end(ForwardIter1 first1, ForwardIter1 last1, ForwardIter2 first2, ForwardIter2 last2, Compared comp) { typedef typename iterator_traits::iterator_category Category1; typedef typename iterator_traits::iterator_category Category2; return mystl::find_end_dispatch(first1, last1, first2, last2, Category1(), Category2(), comp); } /*****************************************************************************************/ // find_first_of // 在[first1, last1)中查找[first2, last2)中的某些元素，返回指向第一次出现的元素的迭代器 /*****************************************************************************************/ template InputIter find_first_of(InputIter first1, InputIter last1, ForwardIter first2, ForwardIter last2) { for (; first1 != last1; ++first1) { for (auto iter = first2; iter != last2; ++iter) { if (*first1 == *iter) return first1; } } return last1; } // 重载版本使用函数对象 comp 代替比较操作 template InputIter find_first_of(InputIter first1, InputIter last1, ForwardIter first2, ForwardIter last2, Compared comp) { for (; first1 != last1; ++first1) { for (auto iter = first2; iter != last2; ++iter) { if (comp(*first1, *iter)) return first1; } } return last1; } /*****************************************************************************************/ // for_each // 使用一个函数对象 f 对[first, last)区间内的每个元素执行一个 operator() 操作，但不能改变元素内容 // f() 可返回一个值，但该值会被忽略 /*****************************************************************************************/ template Function for_each(InputIter first, InputIter last, Function f) { for (; first != last; ++first) { f(*first); } return f; } /*****************************************************************************************/ // adjacent_find // 找出第一对匹配的相邻元素，缺省使用 operator== 比较，如果找到返回一个迭代器，指向这对元素的第一个元素 /*****************************************************************************************/ template ForwardIter adjacent_find(ForwardIter first, ForwardIter last) { if (first == last) return last; auto next = first; while (++next != last) { if (*first == *next) return first; first = next; } return last; } // 重载版本使用函数对象 comp 代替比较操作 template ForwardIter adjacent_find(ForwardIter first, ForwardIter last, Compared comp) { if (first == last) return last; auto next = first; while (++next != last) { if (comp(*first, *next)) return first; first = next; } return last; } /*****************************************************************************************/ // lower_bound // 在[first, last)中查找第一个不小于 value 的元素，并返回指向它的迭代器，若没有则返回 last /*****************************************************************************************/ // lbound_dispatch 的 forward_iterator_tag 版本 template ForwardIter lbound_dispatch(ForwardIter first, ForwardIter last, const T& value, forward_iterator_tag) { auto len = mystl::distance(first, last); auto half = len; ForwardIter middle; while (len > 0) { half = len >> 1; middle = first; mystl::advance(middle, half); if (*middle < value) { first = middle; ++first; len = len - half - 1; } else { len = half; } } return first; } // lbound_dispatch 的 random_access_iterator_tag 版本 template RandomIter lbound_dispatch(RandomIter first, RandomIter last, const T& value, random_access_iterator_tag) { auto len = last - first; auto half = len; RandomIter middle; while (len > 0) { half = len >> 1; middle = first + half; if (*middle < value) { first = middle + 1; len = len - half - 1; } else { len = half; } } return first; } template ForwardIter lower_bound(ForwardIter first, ForwardIter last, const T& value) { return mystl::lbound_dispatch(first, last, value, iterator_category(first)); } // 重载版本使用函数对象 comp 代替比较操作 // lbound_dispatch 的 forward_iterator_tag 版本 template ForwardIter lbound_dispatch(ForwardIter first, ForwardIter last, const T& value, forward_iterator_tag, Compared comp) { auto len = mystl::distance(first, last); auto half = len; ForwardIter middle; while (len > 0) { half = len >> 1; middle = first; mystl::advance(middle, half); if (comp(*middle, value)) { first = middle; ++first; len = len - half - 1; } else { len = half; } } return first; } // lbound_dispatch 的 random_access_iterator_tag 版本 template RandomIter lbound_dispatch(RandomIter first, RandomIter last, const T& value, random_access_iterator_tag, Compared comp) { auto len = last - first; auto half = len; RandomIter middle; while (len > 0) { half = len >> 1; middle = first + half; if (comp(*middle, value)) { first = middle + 1; len = len - half - 1; } else { len = half; } } return first; } template ForwardIter lower_bound(ForwardIter first, ForwardIter last, const T& value, Compared comp) { return mystl::lbound_dispatch(first, last, value, iterator_category(first), comp); } /*****************************************************************************************/ // upper_bound // 在[first, last)中查找第一个大于value 的元素，并返回指向它的迭代器，若没有则返回 last /*****************************************************************************************/ // ubound_dispatch 的 forward_iterator_tag 版本 template ForwardIter ubound_dispatch(ForwardIter first, ForwardIter last, const T& value, forward_iterator_tag) { auto len = mystl::distance(first, last); auto half = len; ForwardIter middle; while (len > 0) { half = len >> 1; middle = first; mystl::advance(middle, half); if (value < *middle) { len = half; } else { first = middle; ++first; len = len - half - 1; } } return first; } // ubound_dispatch 的 random_access_iterator_tag 版本 template RandomIter ubound_dispatch(RandomIter first, RandomIter last, const T& value, random_access_iterator_tag) { auto len = last - first; auto half = len; RandomIter middle; while (len > 0) { half = len >> 1; middle = first + half; if (value < *middle) { len = half; } else { first = middle + 1; len = len - half - 1; } } return first; } template ForwardIter upper_bound(ForwardIter first, ForwardIter last, const T& value) { return mystl::ubound_dispatch(first, last, value, iterator_category(first)); } // 重载版本使用函数对象 comp 代替比较操作 // ubound_dispatch 的 forward_iterator_tag 版本 template ForwardIter ubound_dispatch(ForwardIter first, ForwardIter last, const T& value, forward_iterator_tag, Compared comp) { auto len = mystl::distance(first, last); auto half = len; ForwardIter middle; while (len > 0) { half = len >> 1; middle = first; mystl::advance(middle, half); if (comp(value, *middle)) { len = half; } else { first = middle; ++first; len = len - half - 1; } } return first; } // ubound_dispatch 的 random_access_iterator_tag 版本 template RandomIter ubound_dispatch(RandomIter first, RandomIter last, const T& value, random_access_iterator_tag, Compared comp) { auto len = last - first; auto half = len; RandomIter middle; while (len > 0) { half = len >> 1; middle = first + half; if (comp(value, *middle)) { len = half; } else { first = middle + 1; len = len - half - 1; } } return first; } template ForwardIter upper_bound(ForwardIter first, ForwardIter last, const T& value, Compared comp) { return mystl::ubound_dispatch(first, last, value, iterator_category(first), comp); } /*****************************************************************************************/ // binary_search // 二分查找，如果在[first, last)内有等同于 value 的元素，返回 true，否则返回 false /*****************************************************************************************/ template bool binary_search(ForwardIter first, ForwardIter last, const T& value) { auto i = mystl::lower_bound(first, last, value); return i != last && !(value < *i); } // 重载版本使用函数对象 comp 代替比较操作 template bool binary_search(ForwardIter first, ForwardIter last, const T& value, Compared comp) { auto i = mystl::lower_bound(first, last, value); return i != last && !comp(value, *i); } /*****************************************************************************************/ // equal_range // 查找[first,last)区间中与 value 相等的元素所形成的区间，返回一对迭代器指向区间首尾 // 第一个迭代器指向第一个不小于 value 的元素，第二个迭代器指向第一个大于 value 的元素 /*****************************************************************************************/ // erange_dispatch 的 forward_iterator_tag 版本 template mystl::pair erange_dispatch(ForwardIter first, ForwardIter last, const T& value, forward_iterator_tag) { auto len = mystl::distance(first, last); auto half = len; ForwardIter middle, left, right; while (len > 0) { half = len >> 1; middle = first; mystl::advance(middle, half); if (*middle < value) { first = middle; ++first; len = len - half - 1; } else if (value < *middle) { len = half; } else { left = mystl::lower_bound(first, last, value); mystl::advance(first, len); right = mystl::upper_bound(++middle, first, value); return mystl::pair(left, right); } } return mystl::pair(last, last); } // erange_dispatch 的 random_access_iterator_tag 版本 template mystl::pair erange_dispatch(RandomIter first, RandomIter last, const T& value, random_access_iterator_tag) { auto len = last - first; auto half = len; RandomIter middle, left, right; while (len > 0) { half = len >> 1; middle = first + half; if (*middle < value) { first = middle + 1; len = len - half - 1; } else if (value < *middle) { len = half; } else { left = mystl::lower_bound(first, middle, value); right = mystl::upper_bound(++middle, first + len, value); return mystl::pair(left, right); } } return mystl::pair(last, last); } template mystl::pair equal_range(ForwardIter first, ForwardIter last, const T& value) { return mystl::erange_dispatch(first, last, value, iterator_category(first)); } // 重载版本使用函数对象 comp 代替比较操作 // erange_dispatch 的 forward iterator 版本 template mystl::pair erange_dispatch(ForwardIter first, ForwardIter last, const T& value, forward_iterator_tag, Compared comp) { auto len = mystl::distance(first, last); auto half = len; ForwardIter middle, left, right; while (len > 0) { half = len >> 1; middle = first; mystl::advance(middle, half); if (comp(*middle, value)) { first = middle; ++first; len = len - half - 1; } else if (comp(value, *middle)) { len = half; } else { left = mystl::lower_bound(first, last, value, comp); mystl::advance(first, len); right = mystl::upper_bound(++middle, first, value, comp); return mystl::pair(left, right); } } return mystl::pair(last, last); } // erange_dispatch 的 random access iterator 版本 template mystl::pair erange_dispatch(RandomIter first, RandomIter last, const T& value, random_access_iterator_tag, Compared comp) { auto len = last - first; auto half = len; RandomIter middle, left, right; while (len > 0) { half = len >> 1; middle = first + half; if (comp(*middle, value)) { first = middle + 1; len = len - half - 1; } else if (comp(value, *middle)) { len = half; } else { left = mystl::lower_bound(first, middle, value, comp); right = mystl::upper_bound(++middle, first + len, value, comp); return mystl::pair(left, right); } } return mystl::pair(last, last); } template mystl::pair equal_range(ForwardIter first, ForwardIter last, const T& value, Compared comp) { return mystl::erange_dispatch(first, last, value, iterator_category(first), comp); } /*****************************************************************************************/ // generate // 将函数对象 gen 的运算结果对[first, last)内的每个元素赋值 /*****************************************************************************************/ template void generate(ForwardIter first, ForwardIter last, Generator gen) { for (; first != last; ++first) { *first = gen(); } } /*****************************************************************************************/ // generate_n // 用函数对象 gen 连续对 n 个元素赋值 /*****************************************************************************************/ template void generate_n(ForwardIter first, Size n, Generator gen) { for (; n > 0; --n, ++first) { *first = gen(); } } /*****************************************************************************************/ // includes // 判断序列一S1 是否包含序列二S2 /*****************************************************************************************/ template bool includes(InputIter1 first1, InputIter1 last1, InputIter2 first2, InputIter2 last2) { while (first1 != last1 && first2 != last2) { if (*first2 < *first1) { return false; } else if (*first1 < *first2) { ++first1; } else { ++first1, ++first2; } } return first2 == last2; } // 重载版本使用函数对象 comp 代替比较操作 template bool includes(InputIter1 first1, InputIter1 last1, InputIter2 first2, InputIter2 last2, Compared comp) { while (first1 != last1 && first2 != last2) { if (comp(*first2, *first1)) { return false; } else if (comp(*first1, *first2)) { ++first1; } else { ++first1, ++first2; } } return first2 == last2; } /*****************************************************************************************/ // is_heap // 检查[first, last)内的元素是否为一个堆，如果是，则返回 true /*****************************************************************************************/ template bool is_heap(RandomIter first, RandomIter last) { auto n = mystl::distance(first, last); auto parent = 0; for (auto child = 1; child < n; ++child) { if (first[parent] < first[child]) return false; if ((child & 1) == 0) ++parent; } return true; } // 重载版本使用函数对象 comp 代替比较操作 template bool is_heap(RandomIter first, RandomIter last, Compared comp) { auto n = mystl::distance(first, last); auto parent = 0; for (auto child = 1; child < n; ++child) { if (comp(first[parent], first[child])) return false; if ((child & 1) == 0) ++parent; } return true; } /*****************************************************************************************/ // is_sorted // 检查[first, last)内的元素是否升序，如果是升序，则返回 true /*****************************************************************************************/ template bool is_sorted(ForwardIter first, ForwardIter last) { if (first == last) return true; auto next = first; ++next; for (; next != last; first = next, ++next) { if (*next < *first) return false; } return true; } // 重载版本使用函数对象 comp 代替比较操作 template bool is_sorted(ForwardIter first, ForwardIter last, Compared comp) { if (first == last) return true; auto next = first; ++next; for (; next != last; first = next, ++next) { if (comp(*next, *first)) return false; } return true; } /*****************************************************************************************/ // median // 找出三个值的中间值 /*****************************************************************************************/ template const T& median(const T& left, const T& mid, const T& right) { if (left < mid) if (mid < right) // left < mid < right return mid; else if (left < right) // left < right <= mid return right; else // right <= left < mid return left; else if (left < right) // mid <= left < right return left; else if (mid < right) // mid < right <= left return right; else // right <= mid <= left return mid; } // 重载版本使用函数对象 comp 代替比较操作 template const T& median(const T& left, const T& mid, const T& right, Compared comp) { if (comp(left, mid)) if (comp(mid, right)) return mid; else if (comp(left, right)) return right; else return left; else if (comp(left, right)) return left; else if (comp(mid, right)) return right; else return mid; } /*****************************************************************************************/ // max_element // 返回一个迭代器，指向序列中最大的元素 /*****************************************************************************************/ template ForwardIter max_element(ForwardIter first, ForwardIter last) { if (first == last) return first; auto result = first; while (++first != last) { if (*result < *first) result = first; } return result; } // 重载版本使用函数对象 comp 代替比较操作 template ForwardIter max_element(ForwardIter first, ForwardIter last, Compared comp) { if (first == last) return first; auto result = first; while (++first != last) { if (comp(*result, *first)) result = first; } return result; } /*****************************************************************************************/ // min_element // 返回一个迭代器，指向序列中最小的元素 /*****************************************************************************************/ template ForwardIter min_elememt(ForwardIter first, ForwardIter last) { if (first == last) return first; auto result = first; while (++first != last) { if (*first < *result) result = first; } return result; } // 重载版本使用函数对象 comp 代替比较操作 template ForwardIter min_elememt(ForwardIter first, ForwardIter last, Compared comp) { if (first == last) return first; auto result = first; while (++first != last) { if (comp(*first, *result)) result = first; } return result; } /*****************************************************************************************/ // swap_ranges // 将[first1, last1)从 first2 开始，交换相同个数元素 // 交换的区间长度必须相同，两个序列不能互相重叠，返回一个迭代器指向序列二最后一个被交换元素的下一位置 /*****************************************************************************************/ template ForwardIter2 swap_ranges(ForwardIter1 first1, ForwardIter1 last1, ForwardIter2 first2) { for (; first1 != last1; ++first1, ++first2) { mystl::iter_swap(first1, first2); } return first2; } /*****************************************************************************************/ // transform // 第一个版本以函数对象 unary_op 作用于[first, last)中的每个元素并将结果保存至 result 中 // 第二个版本以函数对象 binary_op 作用于两个序列[first1, last1)、[first2, last2)的相同位置 /*****************************************************************************************/ template OutputIter transform(InputIter first, InputIter last, OutputIter result, UnaryOperation unary_op) { for (; first != last; ++first, ++result) { *result = unary_op(*first); } return result; } template OutputIter transform(InputIter1 first1, InputIter1 last1, InputIter2 first2, OutputIter result, BinaryOperation binary_op) { for (; first1 != last1; ++first1, ++first2, ++result) { *result = binary_op(*first1, *first2); } return result; } /*****************************************************************************************/ // remove_copy // 移除区间内与指定 value 相等的元素，并将结果复制到以 result 标示起始位置的容器上 /*****************************************************************************************/ template OutputIter remove_copy(InputIter first, InputIter last, OutputIter result, const T& value) { for (; first != last; ++first) { if (*first != value) { *result++ = *first; } } return result; } /*****************************************************************************************/ // remove // 移除所有与指定 value 相等的元素 // 并不从容器中删除这些元素，所以 remove 和 remove_if 不适用于 array /*****************************************************************************************/ template ForwardIter remove(ForwardIter first, ForwardIter last, const T& value) { first = mystl::find(first, last, value); // 利用 find 找出第一个匹配的地方 auto next = first; return first == last ? first : mystl::remove_copy(++next, last, first, value); } /*****************************************************************************************/ // remove_copy_if // 移除区间内所有令一元操作 unary_pred 为 true 的元素，并将结果复制到以 result 为起始位置的容器上 /*****************************************************************************************/ template OutputIter remove_copy_if(InputIter first, InputIter last, OutputIter result, UnaryPredicate unary_pred) { for (; first != last; ++first) { if (!unary_pred(*first)) { *result = *first; ++result; } } return result; } /*****************************************************************************************/ // remove_if // 移除区间内所有令一元操作 unary_pred 为 true 的元素 /*****************************************************************************************/ template ForwardIter remove_if(ForwardIter first, ForwardIter last, UnaryPredicate unary_pred) { first = mystl::find_if(first, last, unary_pred); // 利用 find_if 找出第一个匹配的地方 auto next = first; return first == last ? first : mystl::remove_copy_if(++next, last, first, unary_pred); } /*****************************************************************************************/ // replace // 将区间内所有的 old_value 都以 new_value 替代 /*****************************************************************************************/ template void replace(ForwardIter first, ForwardIter last, const T& old_value, const T& new_value) { for (; first != last; ++first) { if (*first == old_value) *first = new_value; } } /*****************************************************************************************/ // replace_copy // 行为与 replace 类似，不同的是将结果复制到 result 所指的容器中，原序列没有改变 /*****************************************************************************************/ template OutputIter replace_copy(InputIter first, InputIter last, OutputIter result, const T& old_value, const T& new_value) { for (; first != last; ++first, ++result) { *result = *first == old_value ? new_value : *first; } return result; } /*****************************************************************************************/ // replace_copy_if // 行为与 replace_if 类似，不同的是将结果复制到 result 所指的容器中，原序列没有改变 /*****************************************************************************************/ template OutputIter replace_copy_if(InputIter first, InputIter last, OutputIter result, UnaryPredicate unary_pred, const T& new_value) { for (; first != last; ++first, ++result) { *result = unary_pred(*first) ? new_value : *first; } return result; } /*****************************************************************************************/ // replace_if // 将区间内所有令一元操作 unary_pred 为 true 的元素都用 new_value 替代 /*****************************************************************************************/ template void replace_if(ForwardIter first, ForwardIter last, UnaryPredicate unary_pred, const T& new_value) { for (; first != last; ++first) { if (unary_pred(*first)) *first = new_value; } } /*****************************************************************************************/ // reverse // 将[first, last)区间内的元素反转 /*****************************************************************************************/ // reverse_dispatch 的 bidirectional_iterator_tag 版本 template void reverse_dispatch(BidirectionalIter first, BidirectionalIter last, bidirectional_iterator_tag) { while (true) { if (first == last || first == --last) return; mystl::iter_swap(first++, last); } } // reverse_dispatch 的 random_access_iterator_tag 版本 template void reverse_dispatch(RandomIter first, RandomIter last, random_access_iterator_tag) { while (first < last) mystl::iter_swap(first++, --last); } template void reverse(BidirectionalIter first, BidirectionalIter last) { mystl::reverse_dispatch(first, last, iterator_category(first)); } /*****************************************************************************************/ // reverse_copy // 行为与 reverse 类似，不同的是将结果复制到 result 所指容器中 /*****************************************************************************************/ template OutputIter reverse_copy(BidirectionalIter first, BidirectionalIter last, OutputIter result) { while (first != last) { --last; *result = *last; ++result; } return result; } /*****************************************************************************************/ // random_shuffle // 将[first, last)内的元素次序随机重排 // 重载版本使用一个产生随机数的函数对象 rand /*****************************************************************************************/ template void random_shuffle(RandomIter first, RandomIter last) { if (first == last) return; srand((unsigned)time(0)); for (auto i = first + 1; i != last; ++i) { mystl::iter_swap(i, first + (rand() % (i - first + 1))); } } // 重载版本使用一个产生随机数的函数对象 rand template void random_shuffle(RandomIter first, RandomIter last, RandomNumberGenerator& rand) { if (first == last) return; auto len = mystl::distance(first, last); for (auto i = first + 1; i != last; ++i) { mystl::iter_swap(i, first + (rand(i - first + 1) % len)); } } /*****************************************************************************************/ // rotate // 将[first, middle)内的元素和 [middle, last)内的元素互换，可以交换两个长度不同的区间 // 返回交换后 middle 的位置 /*****************************************************************************************/ // rotate_dispatch 的 forward_iterator_tag 版本 template ForwardIter rotate_dispatch(ForwardIter first, ForwardIter middle, ForwardIter last, forward_iterator_tag) { auto first2 = middle; do { mystl::swap(*first++, *first2++); if (first == middle) middle = first2; } while (first2 != last); // 后半段移到前面 auto new_middle = first; // 迭代器返回的位置 first2 = middle; while (first2 != last) { // 调整剩余元素 mystl::swap(*first++, *first2++); if (first == middle) { middle = first2; } else if (first2 == last) { first2 = middle; } } return new_middle; } // rotate_dispatch 的 bidirectional_iterator_tag 版本 template BidirectionalIter rotate_dispatch(BidirectionalIter first, BidirectionalIter middle, BidirectionalIter last, bidirectional_iterator_tag) { mystl::reverse_dispatch(first, middle, bidirectional_iterator_tag()); mystl::reverse_dispatch(middle, last, bidirectional_iterator_tag()); while (first != middle && middle != last) mystl::swap(*first++, *--last); if (first == middle) { mystl::reverse_dispatch(middle, last, bidirectional_iterator_tag()); return last; } else { mystl::reverse_dispatch(first, middle, bidirectional_iterator_tag()); return first; } } // 求最大公因子 template EuclideanRingElement rgcd(EuclideanRingElement m, EuclideanRingElement n) { while (n != 0) { auto t = m % n; m = n; n = t; } return m; } // rotate_dispatch 的 random_access_iterator_tag 版本 template RandomIter rotate_dispatch(RandomIter first, RandomIter middle, RandomIter last, random_access_iterator_tag) { // 因为是 random access iterator，我们可以确定每个元素的位置 auto n = last - first; auto l = middle - first; auto r = n - l; auto result = first + (last - middle); if (l == r) { mystl::swap_ranges(first, middle, middle); return result; } auto cycle_times = rgcd(n, l); for (auto i = 0; i < cycle_times; ++i) { auto tmp = *first; auto p = first; if (l < r) { for (auto j = 0; j < r / cycle_times; ++j) { if (p > first + r) { *p = *(p - r); p -= r; } *p = *(p + l); p += l; } } else { for (auto j = 0; j < l / cycle_times - 1; ++j) { if (p < last - l) { *p = *(p + l); p += l; } *p = *(p - r); p -= r; } } *p = tmp; ++first; } return result; } template ForwardIter rotate(ForwardIter first, ForwardIter middle, ForwardIter last) { if (first == middle) return last; if (middle == last) return first; return mystl::rotate_dispatch(first, middle, last, iterator_category(first)); } /*****************************************************************************************/ // rotate_copy // 行为与 rotate 类似，不同的是将结果复制到 result 所指的容器中 /*****************************************************************************************/ template ForwardIter rotate_copy(ForwardIter first, ForwardIter middle, ForwardIter last, OutputIter result) { return mystl::copy(first, middle, mystl::copy(middle, last, result)); } /*****************************************************************************************/ // is_permutation // 判断[first1,last1)是否为[first2, last2)的排列组合 /*****************************************************************************************/ template bool is_permutation_aux(ForwardIter1 first1, ForwardIter1 last1, ForwardIter2 first2, ForwardIter2 last2, BinaryPred pred) { constexpr bool is_ra_it = mystl::is_random_access_iterator::value && mystl::is_random_access_iterator::value; if (is_ra_it) { auto len1 = last1 - first1; auto len2 = last2 - first2; if (len1 != len2) return false; } // 先找出相同的前缀段 for (; first1 != last1 && first2 != last2; ++first1, (void) ++first2) { if (!pred(*first1, *first2)) break; } if (is_ra_it) { if (first1 == last1) return true; } else { auto len1 = mystl::distance(first1, last1); auto len2 = mystl::distance(first2, last2); if (len1 == 0 && len2 == 0) return true; if (len1 != len2) return false; } // 判断剩余部分 for (auto i = first1; i != last1; ++i) { bool is_repeated = false; for (auto j = first1; j != i; ++j) { if (pred(*j, *i)) { is_repeated = true; break; } } if (!is_repeated) { // 计算 *i 在 [first2, last2) 的数目 auto c2 = 0; for (auto j = first2; j != last2; ++j) { if (pred(*i, *j)) ++c2; } if (c2 == 0) return false; // 计算 *i 在 [first1, last1) 的数目 auto c1 = 1; auto j = i; for (++j; j != last1; ++j) { if (pred(*i, *j)) ++c1; } if (c1 != c2) return false; } } return true; } template bool is_permutation(ForwardIter1 first1, ForwardIter1 last1, ForwardIter2 first2, ForwardIter2 last2, BinaryPred pred) { return is_permutation_aux(first1, last1, first2, last2, pred); } template bool is_permutation(ForwardIter1 first1, ForwardIter1 last1, ForwardIter2 first2, ForwardIter2 last2) { typedef typename iterator_traits::value_type v1; typedef typename iterator_traits::value_type v2; static_assert(std::is_same::value, "the type should be same in mystl::is_permutation"); return is_permutation_aux(first1, last1, first2, last2, mystl::equal_to()); } /*****************************************************************************************/ // next_permutation // 取得[first, last)所标示序列的下一个排列组合，如果没有下一个排序组合，返回 false，否则返回 true /*****************************************************************************************/ template bool next_permutation(BidirectionalIter first, BidirectionalIter last) { auto i = last; if (first == last || first == --i) return false; for (;;) { auto ii = i; if (*--i < *ii) { // 找到第一对小于关系的元素 auto j = last; while (!(*i < *--j)) {} mystl::iter_swap(i, j); // 交换 i，j 所指元素 mystl::reverse(ii, last); // 将 ii 之后的所有元素反转 return true; } if (i == first) { mystl::reverse(first, last); return false; } } } // 重载版本使用函数对象 comp 代替比较操作 template bool next_permutation(BidirectionalIter first, BidirectionalIter last, Compared comp) { auto i = last; if (first == last || first == --i) return false; for (;;) { auto ii = i; if (comp(*--i, *ii)) { auto j = last; while (!comp(*i, *--j)) {} mystl::iter_swap(i, j); // 交换 i，j 所指元素 mystl::reverse(ii, last); // 将 ii 之后的所有元素反转 return true; } if (i == first) { mystl::reverse(first, last); return false; } } } /*****************************************************************************************/ // prev_permutation // 取得[first, last)所标示序列的上一个排列组合，如果没有上一个排序组合，返回 false，否则返回 true /*****************************************************************************************/ template bool prev_permutation(BidirectionalIter first, BidirectionalIter last) { auto i = last; if (first == last || first == --i) return false; for (;;) { auto ii = i; if (*ii < *--i) { // 找到第一对大于关系的元素 auto j = last; while (!(*--j < *i)) {} mystl::iter_swap(i, j); // 交换i，j mystl::reverse(ii, last); // 将 ii 之后的所有元素反转 return true; } if (i == first) { mystl::reverse(first, last); return false; } } } // 重载版本使用函数对象 comp 代替比较操作 template bool prev_permutation(BidirectionalIter first, BidirectionalIter last, Compared comp) { auto i = last; if (first == last || first == --i) return false; for (;;) { auto ii = i; if (comp(*ii, *--i)) { auto j = last; while (!comp(*--j, *i)) {} mystl::iter_swap(i, j); // 交换i，j mystl::reverse(ii, last); // 将 ii 之后的所有元素反转 return true; } if (i == first) { mystl::reverse(first, last); return false; } } } /*****************************************************************************************/ // merge // 将两个经过排序的集合 S1 和 S2 合并起来置于另一段空间，返回一个迭代器指向最后一个元素的下一位置 /*****************************************************************************************/ template OutputIter merge(InputIter1 first1, InputIter1 last1, InputIter2 first2, InputIter2 last2, OutputIter result) { while (first1 != last1 && first2 != last2) { if (*first2 < *first1) { *result = *first2; ++first2; } else { *result = *first1; ++first1; } ++result; } return mystl::copy(first2, last2, mystl::copy(first1, last1, result)); } // 重载版本使用函数对象 comp 代替比较操作 template OutputIter merge(InputIter1 first1, InputIter1 last1, InputIter2 first2, InputIter2 last2, OutputIter result, Compared comp) { while (first1 != last1 && first2 != last2) { if (comp(*first2, *first1)) { *result = *first2; ++first2; } else { *result = *first1; ++first1; } ++result; } return mystl::copy(first2, last2, mystl::copy(first1, last1, result)); } /*****************************************************************************************/ // inplace_merge // 把连接在一起的两个有序序列结合成单一序列并保持有序 /*****************************************************************************************/ // 没有缓冲区的情况下合并 template void merge_without_buffer(BidirectionalIter first, BidirectionalIter middle, BidirectionalIter last, Distance len1, Distance len2) { if (len1 == 0 || len2 == 0) return; if (len1 + len2 == 2) { if (*middle < *first) mystl::iter_swap(first, middle); return; } auto first_cut = first; auto second_cut = middle; Distance len11 = 0; Distance len22 = 0; if (len1 > len2) { // 序列一较长，找到序列一的中点 len11 = len1 >> 1; mystl::advance(first_cut, len11); second_cut = mystl::lower_bound(middle, last, *first_cut); len22 = mystl::distance(middle, second_cut); } else { // 序列二较长，找到序列二的中点 len22 = len2 >> 1; mystl::advance(second_cut, len22); first_cut = mystl::upper_bound(first, middle, *second_cut); len11 = mystl::distance(first, first_cut); } auto new_middle = mystl::rotate(first_cut, middle, second_cut); mystl::merge_without_buffer(first, first_cut, new_middle, len11, len22); mystl::merge_without_buffer(new_middle, second_cut, last, len1 - len11, len2 - len22); } template BidirectionalIter1 merge_backward(BidirectionalIter1 first1, BidirectionalIter1 last1, BidirectionalIter2 first2, BidirectionalIter2 last2, BidirectionalIter1 result) { if (first1 == last1) return mystl::copy_backward(first2, last2, result); if (first2 == last2) return mystl::copy_backward(first1, last1, result); --last1; --last2; while (true) { if (*last2 < *last1) { *--result = *last1; if (first1 == last1) return mystl::copy_backward(first2, ++last2, result); --last1; } else { *--result = *last2; if (first2 == last2) return mystl::copy_backward(first1, ++last1, result); --last2; } } } template BidirectionalIter1 rotate_adaptive(BidirectionalIter1 first, BidirectionalIter1 middle, BidirectionalIter1 last, Distance len1, Distance len2, BidirectionalIter2 buffer, Distance buffer_size) { BidirectionalIter2 buffer_end; if (len1 > len2 && len2 <= buffer_size) { buffer_end = mystl::copy(middle, last, buffer); mystl::copy_backward(first, middle, last); return mystl::copy(buffer, buffer_end, first); } else if (len1 <= buffer_size) { buffer_end = mystl::copy(first, middle, buffer); mystl::copy(middle, last, first); return mystl::copy_backward(buffer, buffer_end, last); } else { return mystl::rotate(first, middle, last); } } // 有缓冲区的情况下合并 template void merge_adaptive(BidirectionalIter first, BidirectionalIter middle, BidirectionalIter last, Distance len1, Distance len2, Pointer buffer, Distance buffer_size) { // 区间长度足够放进缓冲区 if (len1 <= len2 && len1 <= buffer_size) { Pointer buffer_end = mystl::copy(first, middle, buffer); mystl::merge(buffer, buffer_end, middle, last, first); } else if (len2 <= buffer_size) { Pointer buffer_end = mystl::copy(middle, last, buffer); mystl::merge_backward(first, middle, buffer, buffer_end, last); } else { // 区间长度太长，分割递归处理 auto first_cut = first; auto second_cut = middle; Distance len11 = 0; Distance len22 = 0; if (len1 > len2) { len11 = len1 >> 1; mystl::advance(first_cut, len11); second_cut = mystl::lower_bound(middle, last, *first_cut); len22 = mystl::distance(middle, second_cut); } else { len22 = len2 >> 1; mystl::advance(second_cut, len22); first_cut = mystl::upper_bound(first, middle, *second_cut); len11 = mystl::distance(first, first_cut); } auto new_middle = mystl::rotate_adaptive(first_cut, middle, second_cut, len1 - len11, len22, buffer, buffer_size); mystl::merge_adaptive(first, first_cut, new_middle, len11, len22, buffer, buffer_size); mystl::merge_adaptive(new_middle, second_cut, last, len1 - len11, len2 - len22, buffer, buffer_size); } } template void inplace_merge_aux(BidirectionalIter first, BidirectionalIter middle, BidirectionalIter last, T*) { auto len1 = mystl::distance(first, middle); auto len2 = mystl::distance(middle, last); temporary_buffer buf(first, last); if (!buf.begin()) { mystl::merge_without_buffer(first, middle, last, len1, len2); } else { mystl::merge_adaptive(first, middle, last, len1, len2, buf.begin(), buf.size()); } } template void inplace_merge(BidirectionalIter first, BidirectionalIter middle, BidirectionalIter last) { if (first == middle || middle == last) return; mystl::inplace_merge_aux(first, middle, last, value_type(first)); } // 重载版本使用函数对象 comp 代替比较操作 // 没有缓冲区的情况下合并 template void merge_without_buffer(BidirectionalIter first, BidirectionalIter middle, BidirectionalIter last, Distance len1, Distance len2, Compared comp) { if (len1 == 0 || len2 == 0) return; if (len1 + len2 == 2) { if (comp(*middle, *first)) mystl::iter_swap(first, middle); return; } auto first_cut = first; auto second_cut = middle; Distance len11 = 0; Distance len22 = 0; if (len1 > len2) { len11 = len1 >> 1; mystl::advance(first_cut, len11); second_cut = mystl::lower_bound(middle, last, *first_cut, comp); len22 = mystl::distance(middle, second_cut); } else { len22 = len2 >> 1; mystl::advance(second_cut, len22); first_cut = mystl::upper_bound(first, middle, *second_cut, comp); len11 = mystl::distance(first, first_cut); } auto new_middle = mystl::rotate(first_cut, middle, second_cut); mystl::merge_without_buffer(first, first_cut, new_middle, len11, len22, comp); mystl::merge_without_buffer(new_middle, second_cut, last, len1 - len11, len2 - len22, comp); } template BidirectionalIter1 merge_backward(BidirectionalIter1 first1, BidirectionalIter1 last1, BidirectionalIter2 first2, BidirectionalIter2 last2, BidirectionalIter1 result, Compared comp) { if (first1 == last1) return mystl::copy_backward(first2, last2, result); if (first2 == last2) return mystl::copy_backward(first1, last1, result); --last1; --last2; while (true) { if (comp(*last2, *last1)) { *--result = *last1; if (first1 == last1) return mystl::copy_backward(first2, ++last2, result); --last1; } else { *--result = *last2; if (first2 == last2) return mystl::copy_backward(first1, ++last1, result); --last2; } } } // 有缓冲区的情况下合并 template void merge_adaptive(BidirectionalIter first, BidirectionalIter middle, BidirectionalIter last, Distance len1, Distance len2, Pointer buffer, Distance buffer_size, Compared comp) { // 区间长度足够放进缓冲区 if (len1 <= len2 && len1 <= buffer_size) { Pointer buffer_end = mystl::copy(first, middle, buffer); mystl::merge(buffer, buffer_end, middle, last, first, comp); } else if (len2 <= buffer_size) { Pointer buffer_end = mystl::copy(middle, last, buffer); mystl::merge_backward(first, middle, buffer, buffer_end, last, comp); } else { // 区间长度太长，分割递归处理 auto first_cut = first; auto second_cut = middle; Distance len11 = 0; Distance len22 = 0; if (len1 > len2) { len11 = len1 >> 1; mystl::advance(first_cut, len11); second_cut = mystl::lower_bound(middle, last, *first_cut, comp); len22 = mystl::distance(middle, second_cut); } else { len22 = len2 >> 1; mystl::advance(second_cut, len22); first_cut = mystl::upper_bound(first, middle, *second_cut, comp); len11 = mystl::distance(first, first_cut); } auto new_middle = mystl::rotate_adaptive(first_cut, middle, second_cut, len1 - len11, len22, buffer, buffer_size); mystl::merge_adaptive(first, first_cut, new_middle, len11, len22, buffer, buffer_size, comp); mystl::merge_adaptive(new_middle, second_cut, last, len1 - len11, len2 - len22, buffer, buffer_size, comp); } } template void inplace_merge_aux(BidirectionalIter first, BidirectionalIter middle, BidirectionalIter last, T*, Compared comp) { auto len1 = mystl::distance(first, middle); auto len2 = mystl::distance(middle, last); temporary_buffer buf(first, last); if (!buf.begin()) { mystl::merge_without_buffer(first, middle, last, len1, len2, comp); } else { mystl::merge_adaptive(first, middle, last, len1, len2, buf.begin(), buf.size(), comp); } } template void inplace_merge(BidirectionalIter first, BidirectionalIter middle, BidirectionalIter last, Compared comp) { if (first == middle || middle == last) return; mystl::inplace_merge_aux(first, middle, last, value_type(first), comp); } /*****************************************************************************************/ // partial_sort // 对整个序列做部分排序，保证较小的 N 个元素以递增顺序置于[first, first + N)中 /*****************************************************************************************/ template void partial_sort(RandomIter first, RandomIter middle, RandomIter last) { mystl::make_heap(first, middle); for (auto i = middle; i < last; ++i) { if (*i < *first) { mystl::pop_heap_aux(first, middle, i, *i, distance_type(first)); } } mystl::sort_heap(first, middle); } // 重载版本使用函数对象 comp 代替比较操作 template void partial_sort(RandomIter first, RandomIter middle, RandomIter last, Compared comp) { mystl::make_heap(first, middle, comp); for (auto i = middle; i < last; ++i) { if (comp(*i, *first)) { mystl::pop_heap_aux(first, middle, i, *i, distance_type(first), comp); } } mystl::sort_heap(first, middle, comp); } /*****************************************************************************************/ // partial_sort_copy // 行为与 partial_sort 类似，不同的是把排序结果复制到 result 容器中 /*****************************************************************************************/ template RandomIter psort_copy_aux(InputIter first, InputIter last, RandomIter result_first, RandomIter result_last, Distance*) { if (result_first == result_last) return result_last; auto result_iter = result_first; while (first != last && result_iter != result_last) { *result_iter = *first; ++result_iter; ++first; } mystl::make_heap(result_first, result_iter); while (first != last) { if (*first < *result_first) { mystl::adjust_heap(result_first, static_cast(0), result_iter - result_first, *first); } ++first; } mystl::sort_heap(result_first, result_iter); return result_iter; } template RandomIter partial_sort_copy(InputIter first, InputIter last, RandomIter result_first, RandomIter result_last) { return mystl::psort_copy_aux(first, last, result_first, result_last, distance_type(result_first)); } // 重载版本使用函数对象 comp 代替比较操作 template RandomIter psort_copy_aux(InputIter first, InputIter last, RandomIter result_first, RandomIter result_last, Distance*, Compared comp) { if (result_first == result_last) return result_last; auto result_iter = result_first; while (first != last && result_iter != result_last) { *result_iter = *first; ++result_iter; ++first; } mystl::make_heap(result_first, result_iter, comp); while (first != last) { if (comp(*first, *result_first)) { mystl::adjust_heap(result_first, static_cast(0), result_iter - result_first, *first, comp); } ++first; } mystl::sort_heap(result_first, result_iter, comp); return result_iter; } template RandomIter partial_sort_copy(InputIter first, InputIter last, RandomIter result_first, RandomIter result_last, Compared comp) { return mystl::psort_copy_aux(first, last, result_first, result_last, distance_type(result_first), comp); } /*****************************************************************************************/ // partition // 对区间内的元素重排，被一元条件运算判定为 true 的元素会放到区间的前段 // 该函数不保证元素的原始相对位置 /*****************************************************************************************/ template BidirectionalIter partition(BidirectionalIter first, BidirectionalIter last, UnaryPredicate unary_pred) { while (true) { while (first != last && unary_pred(*first)) { ++first; } if (first == last) break; --last; while (first != last && !unary_pred(*last)) { --last; } if (first == last) break; mystl::iter_swap(first, last); ++first; } return first; } /*****************************************************************************************/ // partition_copy // 行为与 partition 类似，不同的是，将被一元操作符判定为 true 的放到 result_true 的输出区间 // 其余放到 result_false 的输出区间，并返回一个 mystl::pair 指向这两个区间的尾部 /*****************************************************************************************/ template mystl::pair partition_copy(InputIter first, InputIter last, OutputIter1 result_true, OutputIter2 result_false, UnaryPredicate unary_pred) { for (; first != last; ++first) { if (unary_pred(*first)) { *result_true++ = *first; } else { *result_false++ = *first; } } return mystl::pair(result_true, result_false); } /*****************************************************************************************/ // sort // 将[first, last)内的元素以递增的方式排序 /*****************************************************************************************/ constexpr static size_t kSmallSectionSize = 128; // 小型区间的大小，在这个大小内采用插入排序 // 用于控制分割恶化的情况 template Size slg2(Size n) { // 找出 lgk <= n 的 k 的最大值 Size k = 0; for (; n > 1; n >>= 1) ++k; return k; } // 分割函数 unchecked_partition template RandomIter unchecked_partition(RandomIter first, RandomIter last, const T& pivot) { while (true) { while (*first < pivot) ++first; --last; while (pivot < *last) --last; if (!(first < last)) return first; mystl::iter_swap(first, last); ++first; } } // 内省式排序，先进行 quick sort，当分割行为有恶化倾向时，改用 heap sort template void intro_sort(RandomIter first, RandomIter last, Size depth_limit) { while (static_cast(last - first) > kSmallSectionSize) { if (depth_limit == 0) { // 到达最大分割深度限制 mystl::partial_sort(first, last, last); // 改用 heap_sort return; } --depth_limit; auto mid = mystl::median(*(first), *(first + (last - first) / 2), *(last - 1)); auto cut = mystl::unchecked_partition(first, last, mid); mystl::intro_sort(cut, last, depth_limit); last = cut; } } // 插入排序辅助函数 unchecked_linear_insert template void unchecked_linear_insert(RandomIter last, const T& value) { auto next = last; --next; while (value < *next) { *last = *next; last = next; --next; } *last = value; } // 插入排序函数 unchecked_insertion_sort template void unchecked_insertion_sort(RandomIter first, RandomIter last) { for (auto i = first; i != last; ++i) { mystl::unchecked_linear_insert(i, *i); } } // 插入排序函数 insertion_sort template void insertion_sort(RandomIter first, RandomIter last) { if (first == last) return; for (auto i = first + 1; i != last; ++i) { auto value = *i; if (value < *first) { mystl::copy_backward(first, i, i + 1); *first = value; } else { mystl::unchecked_linear_insert(i, value); } } } // 最终插入排序函数 final_insertion_sort template void final_insertion_sort(RandomIter first, RandomIter last) { if (static_cast(last - first) > kSmallSectionSize) { mystl::insertion_sort(first, first + kSmallSectionSize); mystl::unchecked_insertion_sort(first + kSmallSectionSize, last); } else { mystl::insertion_sort(first, last); } } template void sort(RandomIter first, RandomIter last) { if (first != last) { // 内省式排序，将区间分为一个个小区间，然后对整体进行插入排序 mystl::intro_sort(first, last, slg2(last - first) * 2); mystl::final_insertion_sort(first, last); } } // 重载版本使用函数对象 comp 代替比较操作 // 分割函数 unchecked_partition template RandomIter unchecked_partition(RandomIter first, RandomIter last, const T& pivot, Compared comp) { while (true) { while (comp(*first, pivot)) ++first; --last; while (comp(pivot, *last)) --last; if (!(first < last)) return first; mystl::iter_swap(first, last); ++first; } } // 内省式排序，先进行 quick sort，当分割行为有恶化倾向时，改用 heap sort template void intro_sort(RandomIter first, RandomIter last, Size depth_limit, Compared comp) { while (static_cast(last - first) > kSmallSectionSize) { if (depth_limit == 0) { // 到达最大分割深度限制 mystl::partial_sort(first, last, last, comp); // 改用 heap_sort return; } --depth_limit; auto mid = mystl::median(*(first), *(first + (last - first) / 2), *(last - 1)); auto cut = mystl::unchecked_partition(first, last, mid, comp); mystl::intro_sort(cut, last, depth_limit, comp); last = cut; } } // 插入排序辅助函数 unchecked_linear_insert template void unchecked_linear_insert(RandomIter last, const T& value, Compared comp) { auto next = last; --next; while (comp(value, *next)) { // 从尾部开始寻找第一个可插入位置 *last = *next; last = next; --next; } *last = value; } // 插入排序函数 unchecked_insertion_sort template void unchecked_insertion_sort(RandomIter first, RandomIter last, Compared comp) { for (auto i = first; i != last; ++i) { mystl::unchecked_linear_insert(i, *i, comp); } } // 插入排序函数 insertion_sort template void insertion_sort(RandomIter first, RandomIter last, Compared comp) { if (first == last) return; for (auto i = first + 1; i != last; ++i) { auto value = *i; if (comp(value, *first)) { mystl::copy_backward(first, i, i + 1); *first = value; } else { mystl::unchecked_linear_insert(i, value, comp); } } } // 最终插入排序函数 final_insertion_sort template void final_insertion_sort(RandomIter first, RandomIter last, Compared comp) { if (static_cast(last - first) > kSmallSectionSize) { mystl::insertion_sort(first, first + kSmallSectionSize, comp); mystl::unchecked_insertion_sort(first + kSmallSectionSize, last, comp); } else { mystl::insertion_sort(first, last, comp); } } template void sort(RandomIter first, RandomIter last, Compared comp) { if (first != last) { // 内省式排序，将区间分为一个个小区间，然后对整体进行插入排序 mystl::intro_sort(first, last, slg2(last - first) * 2, comp); mystl::final_insertion_sort(first, last, comp); } } /*****************************************************************************************/ // nth_element // 对序列重排，使得所有小于第 n 个元素的元素出现在它的前面，大于它的出现在它的后面 /*****************************************************************************************/ template void nth_element(RandomIter first, RandomIter nth, RandomIter last) { if (nth == last) return; while (last - first > 3) { auto cut = mystl::unchecked_partition(first, last, mystl::median(*first, *(first + (last - first) / 2), *(last - 1))); if (cut <= nth) // 如果 nth 位于右段 first = cut; // 对右段进行分割 else last = cut; // 对左段进行分割 } mystl::insertion_sort(first, last); } // 重载版本使用函数对象 comp 代替比较操作 template void nth_element(RandomIter first, RandomIter nth, RandomIter last, Compared comp) { if (nth == last) return; while (last - first > 3) { auto cut = mystl::unchecked_partition(first, last, mystl::median(*first, *(first + (last - first) / 2), *(last - 1)), comp); if (cut <= nth) // 如果 nth 位于右段 first = cut; // 对右段进行分割 else last = cut; // 对左段进行分割 } mystl::insertion_sort(first, last, comp); } /*****************************************************************************************/ // unique_copy // 从[first, last)中将元素复制到 result 上，序列必须有序，如果有重复的元素，只会复制一次 /*****************************************************************************************/ // unique_copy_dispatch 的 forward_iterator_tag 版本 template ForwardIter unique_copy_dispatch(InputIter first, InputIter last, ForwardIter result, forward_iterator_tag) { *result = *first; while (++first != last) { if (*result != *first) *++result = *first; } return ++result; } // unique_copy_dispatch 的 output_iterator_tag 版本 // 由于 output iterator 只能进行只读操作，所以不能有 *result != *first 这样的判断 template OutputIter unique_copy_dispatch(InputIter first, InputIter last, OutputIter result, output_iterator_tag) { auto value = *first; *result = value; while (++first != last) { if (value != *first) { value = *first; *++result = value; } } return ++result; } template OutputIter unique_copy(InputIter first, InputIter last, OutputIter result) { if (first == last) return result; return mystl::unique_copy_dispatch(first, last, result, iterator_category(result)); } // 重载版本使用函数对象 comp 代替比较操作 // unique_copy_dispatch 的 forward_iterator_tag 版本 template ForwardIter unique_copy_dispatch(InputIter first, InputIter last, ForwardIter result, forward_iterator_tag, Compared comp) { *result = *first; while (++first != last) { if (!comp(*result, *first)) *++result = *first; } return ++result; } // unique_copy_dispatch 的 output_iterator_tag 版本 // 由于 output iterator 只能进行只读操作，所以不能有 *result != *first 这样的判断 template OutputIter unique_copy_dispatch(InputIter first, InputIter last, OutputIter result, output_iterator_tag, Compared comp) { auto value = *first; *result = value; while (++first != last) { if (!comp(value, *first)) { value = *first; *++result = value; } } return ++result; } template OutputIter unique_copy(InputIter first, InputIter last, OutputIter result, Compared comp) { if (first == last) return result; return mystl::unique_copy_dispatch(first, last, result, iterator_category(result), comp); } /*****************************************************************************************/ // unique // 移除[first, last)内重复的元素，序列必须有序，和 remove 类似，它也不能真正的删除重复元素 /*****************************************************************************************/ template ForwardIter unique(ForwardIter first, ForwardIter last) { first = mystl::adjacent_find(first, last); return mystl::unique_copy(first, last, first); } // 重载版本使用函数对象 comp 代替比较操作 template ForwardIter unique(ForwardIter first, ForwardIter last, Compared comp) { first = mystl::adjacent_find(first, last, comp); return mystl::unique_copy(first, last, first, comp); } } // namespace mystl #ifdef _MSC_VER #pragma warning(pop) #endif #endif // !MYTINYSTL_ALGO_H_ ================================================ FILE: MyTinySTL/algobase.h ================================================ #ifndef MYTINYSTL_ALGOBASE_H_ #define MYTINYSTL_ALGOBASE_H_ // 这个头文件包含了 mystl 的基本算法 #include #include "iterator.h" #include "util.h" namespace mystl { #ifdef max #pragma message("#undefing marco max") #undef max #endif // max #ifdef min #pragma message("#undefing marco min") #undef min #endif // min /*****************************************************************************************/ // max // 取二者中的较大值，语义相等时保证返回第一个参数 /*****************************************************************************************/ template const T& max(const T& lhs, const T& rhs) { return lhs < rhs ? rhs : lhs; } // 重载版本使用函数对象 comp 代替比较操作 template const T& max(const T& lhs, const T& rhs, Compare comp) { return comp(lhs, rhs) ? rhs : lhs; } /*****************************************************************************************/ // min // 取二者中的较小值，语义相等时保证返回第一个参数 /*****************************************************************************************/ template const T& min(const T& lhs, const T& rhs) { return rhs < lhs ? rhs : lhs; } // 重载版本使用函数对象 comp 代替比较操作 template const T& min(const T& lhs, const T& rhs, Compare comp) { return comp(rhs, lhs) ? rhs : lhs; } /*****************************************************************************************/ // iter_swap // 将两个迭代器所指对象对调 /*****************************************************************************************/ template void iter_swap(FIter1 lhs, FIter2 rhs) { mystl::swap(*lhs, *rhs); } /*****************************************************************************************/ // copy // 把 [first, last)区间内的元素拷贝到 [result, result + (last - first))内 /*****************************************************************************************/ // input_iterator_tag 版本 template OutputIter unchecked_copy_cat(InputIter first, InputIter last, OutputIter result, mystl::input_iterator_tag) { for (; first != last; ++first, ++result) { *result = *first; } return result; } // ramdom_access_iterator_tag 版本 template OutputIter unchecked_copy_cat(RandomIter first, RandomIter last, OutputIter result, mystl::random_access_iterator_tag) { for (auto n = last - first; n > 0; --n, ++first, ++result) { *result = *first; } return result; } template OutputIter unchecked_copy(InputIter first, InputIter last, OutputIter result) { return unchecked_copy_cat(first, last, result, iterator_category(first)); } // 为 trivially_copy_assignable 类型提供特化版本 template typename std::enable_if< std::is_same::type, Up>::value && std::is_trivially_copy_assignable::value, Up*>::type unchecked_copy(Tp* first, Tp* last, Up* result) { const auto n = static_cast(last - first); if (n != 0) std::memmove(result, first, n * sizeof(Up)); return result + n; } template OutputIter copy(InputIter first, InputIter last, OutputIter result) { return unchecked_copy(first, last, result); } /*****************************************************************************************/ // copy_backward // 将 [first, last)区间内的元素拷贝到 [result - (last - first), result)内 /*****************************************************************************************/ // unchecked_copy_backward_cat 的 bidirectional_iterator_tag 版本 template BidirectionalIter2 unchecked_copy_backward_cat(BidirectionalIter1 first, BidirectionalIter1 last, BidirectionalIter2 result, mystl::bidirectional_iterator_tag) { while (first != last) *--result = *--last; return result; } // unchecked_copy_backward_cat 的 random_access_iterator_tag 版本 template BidirectionalIter2 unchecked_copy_backward_cat(RandomIter1 first, RandomIter1 last, BidirectionalIter2 result, mystl::random_access_iterator_tag) { for (auto n = last - first; n > 0; --n) *--result = *--last; return result; } template BidirectionalIter2 unchecked_copy_backward(BidirectionalIter1 first, BidirectionalIter1 last, BidirectionalIter2 result) { return unchecked_copy_backward_cat(first, last, result, iterator_category(first)); } // 为 trivially_copy_assignable 类型提供特化版本 template typename std::enable_if< std::is_same::type, Up>::value && std::is_trivially_copy_assignable::value, Up*>::type unchecked_copy_backward(Tp* first, Tp* last, Up* result) { const auto n = static_cast(last - first); if (n != 0) { result -= n; std::memmove(result, first, n * sizeof(Up)); } return result; } template BidirectionalIter2 copy_backward(BidirectionalIter1 first, BidirectionalIter1 last, BidirectionalIter2 result) { return unchecked_copy_backward(first, last, result); } /*****************************************************************************************/ // copy_if // 把[first, last)内满足一元操作 unary_pred 的元素拷贝到以 result 为起始的位置上 /*****************************************************************************************/ template OutputIter copy_if(InputIter first, InputIter last, OutputIter result, UnaryPredicate unary_pred) { for (; first != last; ++first) { if (unary_pred(*first)) *result++ = *first; } return result; } /*****************************************************************************************/ // copy_n // 把 [first, first + n)区间上的元素拷贝到 [result, result + n)上 // 返回一个 pair 分别指向拷贝结束的尾部 /*****************************************************************************************/ template mystl::pair unchecked_copy_n(InputIter first, Size n, OutputIter result, mystl::input_iterator_tag) { for (; n > 0; --n, ++first, ++result) { *result = *first; } return mystl::pair(first, result); } template mystl::pair unchecked_copy_n(RandomIter first, Size n, OutputIter result, mystl::random_access_iterator_tag) { auto last = first + n; return mystl::pair(last, mystl::copy(first, last, result)); } template mystl::pair copy_n(InputIter first, Size n, OutputIter result) { return unchecked_copy_n(first, n, result, iterator_category(first)); } /*****************************************************************************************/ // move // 把 [first, last)区间内的元素移动到 [result, result + (last - first))内 /*****************************************************************************************/ // input_iterator_tag 版本 template OutputIter unchecked_move_cat(InputIter first, InputIter last, OutputIter result, mystl::input_iterator_tag) { for (; first != last; ++first, ++result) { *result = mystl::move(*first); } return result; } // ramdom_access_iterator_tag 版本 template OutputIter unchecked_move_cat(RandomIter first, RandomIter last, OutputIter result, mystl::random_access_iterator_tag) { for (auto n = last - first; n > 0; --n, ++first, ++result) { *result = mystl::move(*first); } return result; } template OutputIter unchecked_move(InputIter first, InputIter last, OutputIter result) { return unchecked_move_cat(first, last, result, iterator_category(first)); } // 为 trivially_copy_assignable 类型提供特化版本 template typename std::enable_if< std::is_same::type, Up>::value && std::is_trivially_move_assignable::value, Up*>::type unchecked_move(Tp* first, Tp* last, Up* result) { const size_t n = static_cast(last - first); if (n != 0) std::memmove(result, first, n * sizeof(Up)); return result + n; } template OutputIter move(InputIter first, InputIter last, OutputIter result) { return unchecked_move(first, last, result); } /*****************************************************************************************/ // move_backward // 将 [first, last)区间内的元素移动到 [result - (last - first), result)内 /*****************************************************************************************/ // bidirectional_iterator_tag 版本 template BidirectionalIter2 unchecked_move_backward_cat(BidirectionalIter1 first, BidirectionalIter1 last, BidirectionalIter2 result, mystl::bidirectional_iterator_tag) { while (first != last) *--result = mystl::move(*--last); return result; } // random_access_iterator_tag 版本 template RandomIter2 unchecked_move_backward_cat(RandomIter1 first, RandomIter1 last, RandomIter2 result, mystl::random_access_iterator_tag) { for (auto n = last - first; n > 0; --n) *--result = mystl::move(*--last); return result; } template BidirectionalIter2 unchecked_move_backward(BidirectionalIter1 first, BidirectionalIter1 last, BidirectionalIter2 result) { return unchecked_move_backward_cat(first, last, result, iterator_category(first)); } // 为 trivially_copy_assignable 类型提供特化版本 template typename std::enable_if< std::is_same::type, Up>::value && std::is_trivially_move_assignable::value, Up*>::type unchecked_move_backward(Tp* first, Tp* last, Up* result) { const size_t n = static_cast(last - first); if (n != 0) { result -= n; std::memmove(result, first, n * sizeof(Up)); } return result; } template BidirectionalIter2 move_backward(BidirectionalIter1 first, BidirectionalIter1 last, BidirectionalIter2 result) { return unchecked_move_backward(first, last, result); } /*****************************************************************************************/ // equal // 比较第一序列在 [first, last)区间上的元素值是否和第二序列相等 /*****************************************************************************************/ template bool equal(InputIter1 first1, InputIter1 last1, InputIter2 first2) { for (; first1 != last1; ++first1, ++first2) { if (*first1 != *first2) return false; } return true; } // 重载版本使用函数对象 comp 代替比较操作 template bool equal(InputIter1 first1, InputIter1 last1, InputIter2 first2, Compared comp) { for (; first1 != last1; ++first1, ++first2) { if (!comp(*first1, *first2)) return false; } return true; } /*****************************************************************************************/ // fill_n // 从 first 位置开始填充 n 个值 /*****************************************************************************************/ template OutputIter unchecked_fill_n(OutputIter first, Size n, const T& value) { for (; n > 0; --n, ++first) { *first = value; } return first; } // 为 one-byte 类型提供特化版本 template typename std::enable_if< std::is_integral::value && sizeof(Tp) == 1 && !std::is_same::value && std::is_integral::value && sizeof(Up) == 1, Tp*>::type unchecked_fill_n(Tp* first, Size n, Up value) { if (n > 0) { std::memset(first, (unsigned char)value, (size_t)(n)); } return first + n; } template OutputIter fill_n(OutputIter first, Size n, const T& value) { return unchecked_fill_n(first, n, value); } /*****************************************************************************************/ // fill // 为 [first, last)区间内的所有元素填充新值 /*****************************************************************************************/ template void fill_cat(ForwardIter first, ForwardIter last, const T& value, mystl::forward_iterator_tag) { for (; first != last; ++first) { *first = value; } } template void fill_cat(RandomIter first, RandomIter last, const T& value, mystl::random_access_iterator_tag) { fill_n(first, last - first, value); } template void fill(ForwardIter first, ForwardIter last, const T& value) { fill_cat(first, last, value, iterator_category(first)); } /*****************************************************************************************/ // lexicographical_compare // 以字典序排列对两个序列进行比较，当在某个位置发现第一组不相等元素时，有下列几种情况： // (1)如果第一序列的元素较小，返回 true ，否则返回 false // (2)如果到达 last1 而尚未到达 last2 返回 true // (3)如果到达 last2 而尚未到达 last1 返回 false // (4)如果同时到达 last1 和 last2 返回 false /*****************************************************************************************/ template bool lexicographical_compare(InputIter1 first1, InputIter1 last1, InputIter2 first2, InputIter2 last2) { for (; first1 != last1 && first2 != last2; ++first1, ++first2) { if (*first1 < *first2) return true; if (*first2 < *first1) return false; } return first1 == last1 && first2 != last2; } // 重载版本使用函数对象 comp 代替比较操作 template bool lexicographical_compare(InputIter1 first1, InputIter1 last1, InputIter2 first2, InputIter2 last2, Compred comp) { for (; first1 != last1 && first2 != last2; ++first1, ++first2) { if (comp(*first1, *first2)) return true; if (comp(*first2, *first1)) return false; } return first1 == last1 && first2 != last2; } // 针对 const unsigned char* 的特化版本 bool lexicographical_compare(const unsigned char* first1, const unsigned char* last1, const unsigned char* first2, const unsigned char* last2) { const auto len1 = last1 - first1; const auto len2 = last2 - first2; // 先比较相同长度的部分 const auto result = std::memcmp(first1, first2, mystl::min(len1, len2)); // 若相等，长度较长的比较大 return result != 0 ? result < 0 : len1 < len2; } /*****************************************************************************************/ // mismatch // 平行比较两个序列，找到第一处失配的元素，返回一对迭代器，分别指向两个序列中失配的元素 /*****************************************************************************************/ template mystl::pair mismatch(InputIter1 first1, InputIter1 last1, InputIter2 first2) { while (first1 != last1 && *first1 == *first2) { ++first1; ++first2; } return mystl::pair(first1, first2); } // 重载版本使用函数对象 comp 代替比较操作 template mystl::pair mismatch(InputIter1 first1, InputIter1 last1, InputIter2 first2, Compred comp) { while (first1 != last1 && comp(*first1, *first2)) { ++first1; ++first2; } return mystl::pair(first1, first2); } } // namespace mystl #endif // !MYTINYSTL_ALGOBASE_H_ ================================================ FILE: MyTinySTL/algorithm.h ================================================ #ifndef MYTINYSTL_ALGORITHM_H_ #define MYTINYSTL_ALGORITHM_H_ // 这个头文件包含了 mystl 的所有算法，包括基本算法，数值算法，heap 算法，set 算法和其他算法 #include "algobase.h" #include "algo.h" #include "set_algo.h" #include "heap_algo.h" #include "numeric.h" namespace mystl { } // namespace mystl #endif // !MYTINYSTL_ALGORITHM_H_ ================================================ FILE: MyTinySTL/alloc.h ================================================ #ifndef MYTINYSTL_ALLOC_H_ #define MYTINYSTL_ALLOC_H_ // 这个头文件包含一个类 alloc，用于分配和回收内存，以内存池的方式实现 // // 从 v2.0.0 版本开始，将不再使用内存池，这个文件将被弃用，但暂时保留 // // 注意！！！ // 我知道这个文件里很多实现是错的，这是很久很久前写的了，后面已经不用这个东西了， // 所以我也没再维护，有诸多问题，已经有人在issue中都提了，free_list的修改， // 指针作为参数时没实际修改到原指针，等等。相信会看这么仔细的，大部分都是 // 初学C++的朋友，大佬都不会看这些玩具了，所以其中的错误，就留给对内存池实现 // 感兴趣的朋友去修改啦！ #include #include #include namespace mystl { // 共用体: FreeList // 采用链表的方式管理内存碎片，分配与回收小内存（<=4K）区块 union FreeList { union FreeList* next; // 指向下一个区块 char data[1]; // 储存本块内存的首地址 }; // 不同内存范围的上调大小 enum { EAlign128 = 8, EAlign256 = 16, EAlign512 = 32, EAlign1024 = 64, EAlign2048 = 128, EAlign4096 = 256 }; // 小对象的内存大小 enum { ESmallObjectBytes = 4096 }; // free lists 个数 enum { EFreeListsNumber = 56 }; // 空间配置类 alloc // 如果内存较大，超过 4096 bytes，直接调用 std::malloc, std::free // 当内存较小时，以内存池管理，每次配置一大块内存，并维护对应的自由链表 class alloc { private: static char* start_free; // 内存池起始位置 static char* end_free; // 内存池结束位置 static size_t heap_size; // 申请 heap 空间附加值大小 static FreeList* free_list[EFreeListsNumber]; // 自由链表 public: static void* allocate(size_t n); static void deallocate(void* p, size_t n); static void* reallocate(void* p, size_t old_size, size_t new_size); private: static size_t M_align(size_t bytes); static size_t M_round_up(size_t bytes); static size_t M_freelist_index(size_t bytes); static void* M_refill(size_t n); static char* M_chunk_alloc(size_t size, size_t &nobj); }; // 静态成员变量初始化 char* alloc::start_free = nullptr; char* alloc::end_free = nullptr; size_t alloc::heap_size = 0; FreeList* alloc::free_list[EFreeListsNumber] = { nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr, nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr, nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr, nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr, nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr, nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr, nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr }; // 分配大小为 n 的空间， n > 0 inline void* alloc::allocate(size_t n) { FreeList* my_free_list; FreeList* result; if (n > static_cast(ESmallObjectBytes)) return std::malloc(n); my_free_list = free_list[M_freelist_index(n)]; result = my_free_list; if (result == nullptr) { void* r = M_refill(M_round_up(n)); return r; } my_free_list = result->next; return result; } // 释放 p 指向的大小为 n 的空间, p 不能为 0 inline void alloc::deallocate(void* p, size_t n) { if (n > static_cast(ESmallObjectBytes)) { std::free(p); return; } FreeList* q = reinterpret_cast(p); FreeList* my_free_list; my_free_list = free_list[M_freelist_index(n)]; q->next = my_free_list; my_free_list = q; } // 重新分配空间，接受三个参数，参数一为指向新空间的指针，参数二为原来空间的大小，参数三为申请空间的大小 inline void* alloc::reallocate(void* p, size_t old_size, size_t new_size) { deallocate(p, old_size); p = allocate(new_size); return p; } // bytes 对应上调大小 inline size_t alloc::M_align(size_t bytes) { if (bytes <= 512) { return bytes <= 256 ? bytes <= 128 ? EAlign128 : EAlign256 : EAlign512; } return bytes <= 2048 ? bytes <= 1024 ? EAlign1024 : EAlign2048 : EAlign4096; } // 将 bytes 上调至对应区间大小 inline size_t alloc::M_round_up(size_t bytes) { return ((bytes + M_align(bytes) - 1) & ~(M_align(bytes) - 1)); } // 根据区块大小，选择第 n 个 free lists inline size_t alloc::M_freelist_index(size_t bytes) { if (bytes <= 512) { return bytes <= 256 ? bytes <= 128 ? ((bytes + EAlign128 - 1) / EAlign128 - 1) : (15 + (bytes + EAlign256 - 129) / EAlign256) : (23 + (bytes + EAlign512 - 257) / EAlign512); } return bytes <= 2048 ? bytes <= 1024 ? (31 + (bytes + EAlign1024 - 513) / EAlign1024) : (39 + (bytes + EAlign2048 - 1025) / EAlign2048) : (47 + (bytes + EAlign4096 - 2049) / EAlign4096); } // 重新填充 free list void* alloc::M_refill(size_t n) { size_t nblock = 10; char* c = M_chunk_alloc(n, nblock); FreeList* my_free_list; FreeList* result, *cur, *next; // 如果只有一个区块，就把这个区块返回给调用者，free list 没有增加新节点 if (nblock == 1) return c; // 否则把一个区块给调用者，剩下的纳入 free list 作为新节点 my_free_list = free_list[M_freelist_index(n)]; result = (FreeList*)c; my_free_list = next = (FreeList*)(c + n); for (size_t i = 1; ; ++i) { cur = next; next = (FreeList*)((char*)next + n); if (nblock - 1 == i) { cur->next = nullptr; break; } else { cur->next = next; } } return result; } // 从内存池中取空间给 free list 使用，条件不允许时，会调整 nblock char* alloc::M_chunk_alloc(size_t size, size_t& nblock) { char* result; size_t need_bytes = size * nblock; size_t pool_bytes = end_free - start_free; // 如果内存池剩余大小完全满足需求量，返回它 if (pool_bytes >= need_bytes) { result = start_free; start_free += need_bytes; return result; } // 如果内存池剩余大小不能完全满足需求量，但至少可以分配一个或一个以上的区块，就返回它 else if (pool_bytes >= size) { nblock = pool_bytes / size; need_bytes = size * nblock; result = start_free; start_free += need_bytes; return result; } // 如果内存池剩余大小连一个区块都无法满足 else { if (pool_bytes > 0) { // 如果内存池还有剩余，把剩余的空间加入到 free list 中 FreeList* my_free_list = free_list[M_freelist_index(pool_bytes)]; ((FreeList*)start_free)->next = my_free_list; my_free_list = (FreeList*)start_free; } // 申请 heap 空间 size_t bytes_to_get = (need_bytes << 1) + M_round_up(heap_size >> 4); start_free = (char*)std::malloc(bytes_to_get); if (!start_free) { // heap 空间也不够 FreeList* my_free_list, *p; // 试着查找有无未用区块，且区块足够大的 free list for (size_t i = size; i <= ESmallObjectBytes; i += M_align(i)) { my_free_list = free_list[M_freelist_index(i)]; p = my_free_list; if (p) { my_free_list = p->next; start_free = (char*)p; end_free = start_free + i; return M_chunk_alloc(size, nblock); } } std::printf("out of memory"); end_free = nullptr; throw std::bad_alloc(); } end_free = start_free + bytes_to_get; heap_size += bytes_to_get; return M_chunk_alloc(size, nblock); } } } // namespace mystl #endif // !MYTINYSTL_ALLOC_H_ ================================================ FILE: MyTinySTL/allocator.h ================================================ #ifndef MYTINYSTL_ALLOCATOR_H_ #define MYTINYSTL_ALLOCATOR_H_ // 这个头文件包含一个模板类 allocator，用于管理内存的分配、释放，对象的构造、析构 #include "construct.h" #include "util.h" namespace mystl { // 模板类：allocator // 模板函数代表数据类型 template class allocator { public: typedef T value_type; typedef T* pointer; typedef const T* const_pointer; typedef T& reference; typedef const T& const_reference; typedef size_t size_type; typedef ptrdiff_t difference_type; public: static T* allocate(); static T* allocate(size_type n); static void deallocate(T* ptr); static void deallocate(T* ptr, size_type n); static void construct(T* ptr); static void construct(T* ptr, const T& value); static void construct(T* ptr, T&& value); template static void construct(T* ptr, Args&& ...args); static void destroy(T* ptr); static void destroy(T* first, T* last); }; template T* allocator::allocate() { return static_cast(::operator new(sizeof(T))); } template T* allocator::allocate(size_type n) { if (n == 0) return nullptr; return static_cast(::operator new(n * sizeof(T))); } template void allocator::deallocate(T* ptr) { if (ptr == nullptr) return; ::operator delete(ptr); } template void allocator::deallocate(T* ptr, size_type /*size*/) { if (ptr == nullptr) return; ::operator delete(ptr); } template void allocator::construct(T* ptr) { mystl::construct(ptr); } template void allocator::construct(T* ptr, const T& value) { mystl::construct(ptr, value); } template void allocator::construct(T* ptr, T&& value) { mystl::construct(ptr, mystl::move(value)); } template template void allocator::construct(T* ptr, Args&& ...args) { mystl::construct(ptr, mystl::forward(args)...); } template void allocator::destroy(T* ptr) { mystl::destroy(ptr); } template void allocator::destroy(T* first, T* last) { mystl::destroy(first, last); } } // namespace mystl #endif // !MYTINYSTL_ALLOCATOR_H_ ================================================ FILE: MyTinySTL/astring.h ================================================ #ifndef MYTINYSTL_ASTRING_H_ #define MYTINYSTL_ASTRING_H_ // 定义了 string, wstring, u16string, u32string 类型 #include "basic_string.h" namespace mystl { using string = mystl::basic_string; using wstring = mystl::basic_string; using u16string = mystl::basic_string; using u32string = mystl::basic_string; } #endif // !MYTINYSTL_ASTRING_H_ ================================================ FILE: MyTinySTL/basic_string.h ================================================ #ifndef MYTINYSTL_BASIC_STRING_H_ #define MYTINYSTL_BASIC_STRING_H_ // 这个头文件包含一个模板类 basic_string // 用于表示字符串类型 #include #include "iterator.h" #include "memory.h" #include "functional.h" #include "exceptdef.h" namespace mystl { // char_traits template struct char_traits { typedef CharType char_type; static size_t length(const char_type* str) { size_t len = 0; for (; *str != char_type(0); ++str) ++len; return len; } static int compare(const char_type* s1, const char_type* s2, size_t n) { for (; n != 0; --n, ++s1, ++s2) { if (*s1 < *s2) return -1; if (*s2 < *s1) return 1; } return 0; } static char_type* copy(char_type* dst, const char_type* src, size_t n) { MYSTL_DEBUG(src + n <= dst || dst + n <= src); char_type* r = dst; for (; n != 0; --n, ++dst, ++src) *dst = *src; return r; } static char_type* move(char_type* dst, const char_type* src, size_t n) { char_type* r = dst; if (dst < src) { for (; n != 0; --n, ++dst, ++src) *dst = *src; } else if (src < dst) { dst += n; src += n; for (; n != 0; --n) *--dst = *--src; } return r; } static char_type* fill(char_type* dst, char_type ch, size_t count) { char_type* r = dst; for (; count > 0; --count, ++dst) *dst = ch; return r; } }; // Partialized. char_traits template <> struct char_traits { typedef char char_type; static size_t length(const char_type* str) noexcept { return std::strlen(str); } static int compare(const char_type* s1, const char_type* s2, size_t n) noexcept { return std::memcmp(s1, s2, n); } static char_type* copy(char_type* dst, const char_type* src, size_t n) noexcept { MYSTL_DEBUG(src + n <= dst || dst + n <= src); return static_cast(std::memcpy(dst, src, n)); } static char_type* move(char_type* dst, const char_type* src, size_t n) noexcept { return static_cast(std::memmove(dst, src, n)); } static char_type* fill(char_type* dst, char_type ch, size_t count) noexcept { return static_cast(std::memset(dst, ch, count)); } }; // Partialized. char_traits template <> struct char_traits { typedef wchar_t char_type; static size_t length(const char_type* str) noexcept { return std::wcslen(str); } static int compare(const char_type* s1, const char_type* s2, size_t n) noexcept { return std::wmemcmp(s1, s2, n); } static char_type* copy(char_type* dst, const char_type* src, size_t n) noexcept { MYSTL_DEBUG(src + n <= dst || dst + n <= src); return static_cast(std::wmemcpy(dst, src, n)); } static char_type* move(char_type* dst, const char_type* src, size_t n) noexcept { return static_cast(std::wmemmove(dst, src, n)); } static char_type* fill(char_type* dst, char_type ch, size_t count) noexcept { return static_cast(std::wmemset(dst, ch, count)); } }; // Partialized. char_traits template <> struct char_traits { typedef char16_t char_type; static size_t length(const char_type* str) noexcept { size_t len = 0; for (; *str != char_type(0); ++str) ++len; return len; } static int compare(const char_type* s1, const char_type* s2, size_t n) noexcept { for (; n != 0; --n, ++s1, ++s2) { if (*s1 < *s2) return -1; if (*s2 < *s1) return 1; } return 0; } static char_type* copy(char_type* dst, const char_type* src, size_t n) noexcept { MYSTL_DEBUG(src + n <= dst || dst + n <= src); char_type* r = dst; for (; n != 0; --n, ++dst, ++src) *dst = *src; return r; } static char_type* move(char_type* dst, const char_type* src, size_t n) noexcept { char_type* r = dst; if (dst < src) { for (; n != 0; --n, ++dst, ++src) *dst = *src; } else if (src < dst) { dst += n; src += n; for (; n != 0; --n) *--dst = *--src; } return r; } static char_type* fill(char_type* dst, char_type ch, size_t count) noexcept { char_type* r = dst; for (; count > 0; --count, ++dst) *dst = ch; return r; } }; // Partialized. char_traits template <> struct char_traits { typedef char32_t char_type; static size_t length(const char_type* str) noexcept { size_t len = 0; for (; *str != char_type(0); ++str) ++len; return len; } static int compare(const char_type* s1, const char_type* s2, size_t n) noexcept { for (; n != 0; --n, ++s1, ++s2) { if (*s1 < *s2) return -1; if (*s2 < *s1) return 1; } return 0; } static char_type* copy(char_type* dst, const char_type* src, size_t n) noexcept { MYSTL_DEBUG(src + n <= dst || dst + n <= src); char_type* r = dst; for (; n != 0; --n, ++dst, ++src) *dst = *src; return r; } static char_type* move(char_type* dst, const char_type* src, size_t n) noexcept { char_type* r = dst; if (dst < src) { for (; n != 0; --n, ++dst, ++src) *dst = *src; } else if (src < dst) { dst += n; src += n; for (; n != 0; --n) *--dst = *--src; } return r; } static char_type* fill(char_type* dst, char_type ch, size_t count) noexcept { char_type* r = dst; for (; count > 0; --count, ++dst) *dst = ch; return r; } }; // 初始化 basic_string 尝试分配的最小 buffer 大小，可能被忽略 #define STRING_INIT_SIZE 32 // 模板类 basic_string // 参数一代表字符类型，参数二代表萃取字符类型的方式，缺省使用 mystl::char_traits template > class basic_string { public: typedef CharTraits traits_type; typedef CharTraits char_traits; typedef mystl::allocator allocator_type; typedef mystl::allocator data_allocator; typedef typename allocator_type::value_type value_type; typedef typename allocator_type::pointer pointer; typedef typename allocator_type::const_pointer const_pointer; typedef typename allocator_type::reference reference; typedef typename allocator_type::const_reference const_reference; typedef typename allocator_type::size_type size_type; typedef typename allocator_type::difference_type difference_type; typedef value_type* iterator; typedef const value_type* const_iterator; typedef mystl::reverse_iterator reverse_iterator; typedef mystl::reverse_iterator const_reverse_iterator; allocator_type get_allocator() { return allocator_type(); } static_assert(std::is_pod::value, "Character type of basic_string must be a POD"); static_assert(std::is_same::value, "CharType must be same as traits_type::char_type"); public: // 末尾位置的值，例: // if (str.find('a') != string::npos) { /* do something */ } static constexpr size_type npos = static_cast(-1); private: iterator buffer_; // 储存字符串的起始位置 size_type size_; // 大小 size_type cap_; // 容量 public: // 构造、复制、移动、析构函数 basic_string() noexcept { try_init(); } basic_string(size_type n, value_type ch) :buffer_(nullptr), size_(0), cap_(0) { fill_init(n, ch); } basic_string(const basic_string& other, size_type pos) :buffer_(nullptr), size_(0), cap_(0) { init_from(other.buffer_, pos, other.size_ - pos); } basic_string(const basic_string& other, size_type pos, size_type count) :buffer_(nullptr), size_(0), cap_(0) { init_from(other.buffer_, pos, count); } basic_string(const_pointer str) :buffer_(nullptr), size_(0), cap_(0) { init_from(str, 0, char_traits::length(str)); } basic_string(const_pointer str, size_type count) :buffer_(nullptr), size_(0), cap_(0) { init_from(str, 0, count); } template ::value, int>::type = 0> basic_string(Iter first, Iter last) { copy_init(first, last, iterator_category(first)); } basic_string(const basic_string& rhs) :buffer_(nullptr), size_(0), cap_(0) { init_from(rhs.buffer_, 0, rhs.size_); } basic_string(basic_string&& rhs) noexcept :buffer_(rhs.buffer_), size_(rhs.size_), cap_(rhs.cap_) { rhs.buffer_ = nullptr; rhs.size_ = 0; rhs.cap_ = 0; } basic_string& operator=(const basic_string& rhs); basic_string& operator=(basic_string&& rhs) noexcept; basic_string& operator=(const_pointer str); basic_string& operator=(value_type ch); ~basic_string() { destroy_buffer(); } public: // 迭代器相关操作 iterator begin() noexcept { return buffer_; } const_iterator begin() const noexcept { return buffer_; } iterator end() noexcept { return buffer_ + size_; } const_iterator end() const noexcept { return buffer_ + size_; } reverse_iterator rbegin() noexcept { return reverse_iterator(end()); } const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); } reverse_iterator rend() noexcept { return reverse_iterator(begin()); } const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); } const_iterator cbegin() const noexcept { return begin(); } const_iterator cend() const noexcept { return end(); } const_reverse_iterator crbegin() const noexcept { return rbegin(); } const_reverse_iterator crend() const noexcept { return rend(); } // 容量相关操作 bool empty() const noexcept { return size_ == 0; } size_type size() const noexcept { return size_; } size_type length() const noexcept { return size_; } size_type capacity() const noexcept { return cap_; } size_type max_size() const noexcept { return static_cast(-1); } void reserve(size_type n); void shrink_to_fit(); // 访问元素相关操作 reference operator[](size_type n) { MYSTL_DEBUG(n <= size_); if (n == size_) *(buffer_ + n) = value_type(); return *(buffer_ + n); } const_reference operator[](size_type n) const { MYSTL_DEBUG(n <= size_); if (n == size_) *(buffer_ + n) = value_type(); return *(buffer_ + n); } reference at(size_type n) { THROW_OUT_OF_RANGE_IF(n >= size_, "basic_string::at()" "subscript out of range"); return (*this)[n]; } const_reference at(size_type n) const { THROW_OUT_OF_RANGE_IF(n >= size_, "basic_string::at()" "subscript out of range"); return (*this)[n]; } reference front() { MYSTL_DEBUG(!empty()); return *begin(); } const_reference front() const { MYSTL_DEBUG(!empty()); return *begin(); } reference back() { MYSTL_DEBUG(!empty()); return *(end() - 1); } const_reference back() const { MYSTL_DEBUG(!empty()); return *(end() - 1); } const_pointer data() const noexcept { return to_raw_pointer(); } const_pointer c_str() const noexcept { return to_raw_pointer(); } // 添加删除相关操作 // insert iterator insert(const_iterator pos, value_type ch); iterator insert(const_iterator pos, size_type count, value_type ch); template iterator insert(const_iterator pos, Iter first, Iter last); // push_back / pop_back void push_back(value_type ch) { append(1, ch); } void pop_back() { MYSTL_DEBUG(!empty()); --size_; } // append basic_string& append(size_type count, value_type ch); basic_string& append(const basic_string& str) { return append(str, 0, str.size_); } basic_string& append(const basic_string& str, size_type pos) { return append(str, pos, str.size_ - pos); } basic_string& append(const basic_string& str, size_type pos, size_type count); basic_string& append(const_pointer s) { return append(s, char_traits::length(s)); } basic_string& append(const_pointer s, size_type count); template ::value, int>::type = 0> basic_string& append(Iter first, Iter last) { return append_range(first, last); } // erase /clear iterator erase(const_iterator pos); iterator erase(const_iterator first, const_iterator last); // resize void resize(size_type count) { resize(count, value_type()); } void resize(size_type count, value_type ch); void clear() noexcept { size_ = 0; } // basic_string 相关操作 // compare int compare(const basic_string& other) const; int compare(size_type pos1, size_type count1, const basic_string& other) const; int compare(size_type pos1, size_type count1, const basic_string& other, size_type pos2, size_type count2 = npos) const; int compare(const_pointer s) const; int compare(size_type pos1, size_type count1, const_pointer s) const; int compare(size_type pos1, size_type count1, const_pointer s, size_type count2) const; // substr basic_string substr(size_type index, size_type count = npos) { count = mystl::min(count, size_ - index); return basic_string(buffer_ + index, buffer_ + index + count); } // replace basic_string& replace(size_type pos, size_type count, const basic_string& str) { THROW_OUT_OF_RANGE_IF(pos > size_, "basic_string::replace's pos out of range"); return replace_cstr(buffer_ + pos, count, str.buffer_, str.size_); } basic_string& replace(const_iterator first, const_iterator last, const basic_string& str) { MYSTL_DEBUG(begin() <= first && last <= end() && first <= last); return replace_cstr(first, static_cast(last - first), str.buffer_, str.size_); } basic_string& replace(size_type pos, size_type count, const_pointer str) { THROW_OUT_OF_RANGE_IF(pos > size_, "basic_string::replace's pos out of range"); return replace_cstr(buffer_ + pos, count, str, char_traits::length(str)); } basic_string& replace(const_iterator first, const_iterator last, const_pointer str) { MYSTL_DEBUG(begin() <= first && last <= end() && first <= last); return replace_cstr(first, static_cast(last - first), str, char_traits::length(str)); } basic_string& replace(size_type pos, size_type count, const_pointer str, size_type count2) { THROW_OUT_OF_RANGE_IF(pos > size_, "basic_string::replace's pos out of range"); return replace_cstr(buffer_ + pos, count, str, count2); } basic_string& replace(const_iterator first, const_iterator last, const_pointer str, size_type count) { MYSTL_DEBUG(begin() <= first && last <= end() && first <= last); return replace_cstr(first, static_cast(last - first), str, count); } basic_string& replace(size_type pos, size_type count, size_type count2, value_type ch) { THROW_OUT_OF_RANGE_IF(pos > size_, "basic_string::replace's pos out of range"); return replace_fill(buffer_ + pos, count, count2, ch); } basic_string& replace(const_iterator first, const_iterator last, size_type count, value_type ch) { MYSTL_DEBUG(begin() <= first && last <= end() && first <= last); return replace_fill(first, static_cast(last - first), count, ch); } basic_string& replace(size_type pos1, size_type count1, const basic_string& str, size_type pos2, size_type count2 = npos) { THROW_OUT_OF_RANGE_IF(pos1 > size_ || pos2 > str.size_, "basic_string::replace's pos out of range"); return replace_cstr(buffer_ + pos1, count1, str.buffer_ + pos2, count2); } template ::value, int>::type = 0> basic_string& replace(const_iterator first, const_iterator last, Iter first2, Iter last2) { MYSTL_DEBUG(begin() <= first && last <= end() && first <= last); return replace_copy(first, last, first2, last2); } // reverse void reverse() noexcept; // swap void swap(basic_string& rhs) noexcept; // 查找相关操作 // find size_type find(value_type ch, size_type pos = 0) const noexcept; size_type find(const_pointer str, size_type pos = 0) const noexcept; size_type find(const_pointer str, size_type pos, size_type count) const noexcept; size_type find(const basic_string& str, size_type pos = 0) const noexcept; // rfind size_type rfind(value_type ch, size_type pos = npos) const noexcept; size_type rfind(const_pointer str, size_type pos = npos) const noexcept; size_type rfind(const_pointer str, size_type pos, size_type count) const noexcept; size_type rfind(const basic_string& str, size_type pos = npos) const noexcept; // find_first_of size_type find_first_of(value_type ch, size_type pos = 0) const noexcept; size_type find_first_of(const_pointer s, size_type pos = 0) const noexcept; size_type find_first_of(const_pointer s, size_type pos, size_type count) const noexcept; size_type find_first_of(const basic_string& str, size_type pos = 0) const noexcept; // find_first_not_of size_type find_first_not_of(value_type ch, size_type pos = 0) const noexcept; size_type find_first_not_of(const_pointer s, size_type pos = 0) const noexcept; size_type find_first_not_of(const_pointer s, size_type pos, size_type count) const noexcept; size_type find_first_not_of(const basic_string& str, size_type pos = 0) const noexcept; // find_last_of size_type find_last_of(value_type ch, size_type pos = 0) const noexcept; size_type find_last_of(const_pointer s, size_type pos = 0) const noexcept; size_type find_last_of(const_pointer s, size_type pos, size_type count) const noexcept; size_type find_last_of(const basic_string& str, size_type pos = 0) const noexcept; // find_last_not_of size_type find_last_not_of(value_type ch, size_type pos = 0) const noexcept; size_type find_last_not_of(const_pointer s, size_type pos = 0) const noexcept; size_type find_last_not_of(const_pointer s, size_type pos, size_type count) const noexcept; size_type find_last_not_of(const basic_string& str, size_type pos = 0) const noexcept; // count size_type count(value_type ch, size_type pos = 0) const noexcept; public: // 重载 operator+= basic_string& operator+=(const basic_string& str) { return append(str); } basic_string& operator+=(value_type ch) { return append(1, ch); } basic_string& operator+=(const_pointer str) { return append(str, str + char_traits::length(str)); } // 重载 operator >> / operatror << friend std::istream& operator >> (std::istream& is, basic_string& str) { value_type* buf = new value_type[4096]; is >> buf; basic_string tmp(buf); str = std::move(tmp); delete[]buf; return is; } friend std::ostream& operator << (std::ostream& os, const basic_string& str) { for (size_type i = 0; i < str.size_; ++i) os << *(str.buffer_ + i); return os; } private: // helper functions // init / destroy void try_init() noexcept; void fill_init(size_type n, value_type ch); template void copy_init(Iter first, Iter last, mystl::input_iterator_tag); template void copy_init(Iter first, Iter last, mystl::forward_iterator_tag); void init_from(const_pointer src, size_type pos, size_type n); void destroy_buffer(); // get raw pointer const_pointer to_raw_pointer() const; // shrink_to_fit void reinsert(size_type size); // append template basic_string& append_range(Iter first, Iter last); // compare int compare_cstr(const_pointer s1, size_type n1, const_pointer s2, size_type n2) const; // replace basic_string& replace_cstr(const_iterator first, size_type count1, const_pointer str, size_type count2); basic_string& replace_fill(const_iterator first, size_type count1, size_type count2, value_type ch); template basic_string& replace_copy(const_iterator first, const_iterator last, Iter first2, Iter last2); // reallocate void reallocate(size_type need); iterator reallocate_and_fill(iterator pos, size_type n, value_type ch); iterator reallocate_and_copy(iterator pos, const_iterator first, const_iterator last); }; /*****************************************************************************************/ // 复制赋值操作符 template basic_string& basic_string:: operator=(const basic_string& rhs) { if (this != &rhs) { basic_string tmp(rhs); swap(tmp); } return *this; } // 移动赋值操作符 template basic_string& basic_string:: operator=(basic_string&& rhs) noexcept { destroy_buffer(); buffer_ = rhs.buffer_; size_ = rhs.size_; cap_ = rhs.cap_; rhs.buffer_ = nullptr; rhs.size_ = 0; rhs.cap_ = 0; return *this; } // 用一个字符串赋值 template basic_string& basic_string:: operator=(const_pointer str) { const size_type len = char_traits::length(str); if (cap_ < len) { auto new_buffer = data_allocator::allocate(len + 1); data_allocator::deallocate(buffer_); buffer_ = new_buffer; cap_ = len + 1; } char_traits::copy(buffer_, str, len); size_ = len; return *this; } // 用一个字符赋值 template basic_string& basic_string:: operator=(value_type ch) { if (cap_ < 1) { auto new_buffer = data_allocator::allocate(2); data_allocator::deallocate(buffer_); buffer_ = new_buffer; cap_ = 2; } *buffer_ = ch; size_ = 1; return *this; } // 预留储存空间 template void basic_string:: reserve(size_type n) { if (cap_ < n) { THROW_LENGTH_ERROR_IF(n > max_size(), "n can not larger than max_size()" "in basic_string::reserve(n)"); auto new_buffer = data_allocator::allocate(n); char_traits::move(new_buffer, buffer_, size_); buffer_ = new_buffer; cap_ = n; } } // 减少不用的空间 template void basic_string:: shrink_to_fit() { if (size_ != cap_) { reinsert(size_); } } // 在 pos 处插入一个元素 template typename basic_string::iterator basic_string:: insert(const_iterator pos, value_type ch) { iterator r = const_cast(pos); if (size_ == cap_) { return reallocate_and_fill(r, 1, ch); } char_traits::move(r + 1, r, end() - r); ++size_; *r = ch; return r; } // 在 pos 处插入 n 个元素 template typename basic_string::iterator basic_string:: insert(const_iterator pos, size_type count, value_type ch) { iterator r = const_cast(pos); if (count == 0) return r; if (cap_ - size_ < count) { return reallocate_and_fill(r, count, ch); } if (pos == end()) { char_traits::fill(end(), ch, count); size_ += count; return r; } char_traits::move(r + count, r, count); char_traits::fill(r, ch, count); size_ += count; return r; } // 在 pos 处插入 [first, last) 内的元素 template template typename basic_string::iterator basic_string:: insert(const_iterator pos, Iter first, Iter last) { iterator r = const_cast(pos); const size_type len = mystl::distance(first, last); if (len == 0) return r; if (cap_ - size_ < len) { return reallocate_and_copy(r, first, last); } if (pos == end()) { mystl::uninitialized_copy(first, last, end()); size_ += len; return r; } char_traits::move(r + len, r, len); mystl::uninitialized_copy(first, last, r); size_ += len; return r; } // 在末尾添加 count 个 ch template basic_string& basic_string:: append(size_type count, value_type ch) { THROW_LENGTH_ERROR_IF(size_ > max_size() - count, "basic_string's size too big"); if (cap_ - size_ < count) { reallocate(count); } char_traits::fill(buffer_ + size_, ch, count); size_ += count; return *this; } // 在末尾添加 [str[pos] str[pos+count]) 一段 template basic_string& basic_string:: append(const basic_string& str, size_type pos, size_type count) { THROW_LENGTH_ERROR_IF(size_ > max_size() - count, "basic_string's size too big"); if (count == 0) return *this; if (cap_ - size_ < count) { reallocate(count); } char_traits::copy(buffer_ + size_, str.buffer_ + pos, count); size_ += count; return *this; } // 在末尾添加 [s, s+count) 一段 template basic_string& basic_string:: append(const_pointer s, size_type count) { THROW_LENGTH_ERROR_IF(size_ > max_size() - count, "basic_string's size too big"); if (cap_ - size_ < count) { reallocate(count); } char_traits::copy(buffer_ + size_, s, count); size_ += count; return *this; } // 删除 pos 处的元素 template typename basic_string::iterator basic_string:: erase(const_iterator pos) { MYSTL_DEBUG(pos != end()); iterator r = const_cast(pos); char_traits::move(r, pos + 1, end() - pos - 1); --size_; return r; } // 删除 [first, last) 的元素 template typename basic_string::iterator basic_string:: erase(const_iterator first, const_iterator last) { if (first == begin() && last == end()) { clear(); return end(); } const size_type n = end() - last; iterator r = const_cast(first); char_traits::move(r, last, n); size_ -= (last - first); return r; } // 重置容器大小 template void basic_string:: resize(size_type count, value_type ch) { if (count < size_) { erase(buffer_ + count, buffer_ + size_); } else { append(count - size_, ch); } } // 比较两个 basic_string，小于返回 -1，大于返回 1，等于返回 0 template int basic_string:: compare(const basic_string& other) const { return compare_cstr(buffer_, size_, other.buffer_, other.size_); } // 从 pos1 下标开始的 count1 个字符跟另一个 basic_string 比较 template int basic_string:: compare(size_type pos1, size_type count1, const basic_string& other) const { auto n1 = mystl::min(count1, size_ - pos1); return compare_cstr(buffer_ + pos1, n1, other.buffer_, other.size_); } // 从 pos1 下标开始的 count1 个字符跟另一个 basic_string 下标 pos2 开始的 count2 个字符比较 template int basic_string:: compare(size_type pos1, size_type count1, const basic_string& other, size_type pos2, size_type count2) const { auto n1 = mystl::min(count1, size_ - pos1); auto n2 = mystl::min(count2, other.size_ - pos2); return compare_cstr(buffer_, n1, other.buffer_, n2); } // 跟一个字符串比较 template int basic_string:: compare(const_pointer s) const { auto n2 = char_traits::length(s); return compare_cstr(buffer_, size_, s, n2); } // 从下标 pos1 开始的 count1 个字符跟另一个字符串比较 template int basic_string:: compare(size_type pos1, size_type count1, const_pointer s) const { auto n1 = mystl::min(count1, size_ - pos1); auto n2 = char_traits::length(s); return compare_cstr(buffer_, n1, s, n2); } // 从下标 pos1 开始的 count1 个字符跟另一个字符串的前 count2 个字符比较 template int basic_string:: compare(size_type pos1, size_type count1, const_pointer s, size_type count2) const { auto n1 = mystl::min(count1, size_ - pos1); return compare_cstr(buffer_, n1, s, count2); } // 反转 basic_string template void basic_string:: reverse() noexcept { for (auto i = begin(), j = end(); i < j;) { mystl::iter_swap(i++, --j); } } // 交换两个 basic_string template void basic_string:: swap(basic_string& rhs) noexcept { if (this != &rhs) { mystl::swap(buffer_, rhs.buffer_); mystl::swap(size_, rhs.size_); mystl::swap(cap_, rhs.cap_); } } // 从下标 pos 开始查找字符为 ch 的元素，若找到返回其下标，否则返回 npos template typename basic_string::size_type basic_string:: find(value_type ch, size_type pos) const noexcept { for (auto i = pos; i < size_; ++i) { if (*(buffer_ + i) == ch) return i; } return npos; } // 从下标 pos 开始查找字符串 str，若找到返回起始位置的下标，否则返回 npos template typename basic_string::size_type basic_string:: find(const_pointer str, size_type pos) const noexcept { const auto len = char_traits::length(str); if (len == 0) return pos; if (size_ - pos < len) return npos; const auto left = size_ - len; for (auto i = pos; i <= left; ++i) { if (*(buffer_ + i) == *str) { size_type j = 1; for (; j < len; ++j) { if (*(buffer_ + i + j) != *(str + j)) break; } if (j == len) return i; } } return npos; } // 从下标 pos 开始查找字符串 str 的前 count 个字符，若找到返回起始位置的下标，否则返回 npos template typename basic_string::size_type basic_string:: find(const_pointer str, size_type pos, size_type count) const noexcept { if (count == 0) return pos; if (size_ - pos < count) return npos; const auto left = size_ - count; for (auto i = pos; i <= left; ++i) { if (*(buffer_ + i) == *str) { size_type j = 1; for (; j < count; ++j) { if (*(buffer_ + i + j) != *(str + j)) break; } if (j == count) return i; } } return npos; } // 从下标 pos 开始查找字符串 str，若找到返回起始位置的下标，否则返回 npos template typename basic_string::size_type basic_string:: find(const basic_string& str, size_type pos) const noexcept { const size_type count = str.size_; if (count == 0) return pos; if (size_ - pos < count) return npos; const auto left = size_ - count; for (auto i = pos; i <= left; ++i) { if (*(buffer_ + i) == str.front()) { size_type j = 1; for (; j < count; ++j) { if (*(buffer_ + i + j) != str[j]) break; } if (j == count) return i; } } return npos; } // 从下标 pos 开始反向查找值为 ch 的元素，与 find 类似 template typename basic_string::size_type basic_string:: rfind(value_type ch, size_type pos) const noexcept { if (pos >= size_) pos = size_ - 1; for (auto i = pos; i != 0; --i) { if (*(buffer_ + i) == ch) return i; } return front() == ch ? 0 : npos; } // 从下标 pos 开始反向查找字符串 str，与 find 类似 template typename basic_string::size_type basic_string:: rfind(const_pointer str, size_type pos) const noexcept { if (pos >= size_) pos = size_ - 1; const size_type len = char_traits::length(str); switch (len) { case 0: return pos; case 1: { for (auto i = pos; i != 0; --i) { if (*(buffer_ + i) == *str) return i; } return front() == *str ? 0 : npos; } default: { // len >= 2 for (auto i = pos; i >= len - 1; --i) { if (*(buffer_ + i) == *(str + len - 1)) { size_type j = 1; for (; j < len; ++j) { if (*(buffer_ + i - j) != *(str + len - j - 1)) break; } if (j == len) return i - len + 1; } } break; } } return npos; } // 从下标 pos 开始反向查找字符串 str 前 count 个字符，与 find 类似 template typename basic_string::size_type basic_string:: rfind(const_pointer str, size_type pos, size_type count) const noexcept { if (count == 0) return pos; if (pos >= size_) pos = size_ - 1; if (pos < count - 1) return npos; for (auto i = pos; i >= count - 1; --i) { if (*(buffer_ + i) == *(str + count - 1)) { size_type j = 1; for (; j < count; ++j) { if (*(buffer_ + i - j) != *(str + count - j - 1)) break; } if (j == count) return i - count + 1; } } return npos; } // 从下标 pos 开始反向查找字符串 str，与 find 类似 template typename basic_string::size_type basic_string:: rfind(const basic_string& str, size_type pos) const noexcept { const size_type count = str.size_; if (pos >= size_) pos = size_ - 1; if (count == 0) return pos; if (pos < count - 1) return npos; for (auto i = pos; i >= count - 1; --i) { if (*(buffer_ + i) == str[count - 1]) { size_type j = 1; for (; j < count; ++j) { if (*(buffer_ + i - j) != str[count - j - 1]) break; } if (j == count) return i - count + 1; } } return npos; } // 从下标 pos 开始查找 ch 出现的第一个位置 template typename basic_string::size_type basic_string:: find_first_of(value_type ch, size_type pos) const noexcept { for (auto i = pos; i < size_; ++i) { if (*(buffer_ + i) == ch) return i; } return npos; } // 从下标 pos 开始查找字符串 s 其中的一个字符出现的第一个位置 template typename basic_string::size_type basic_string:: find_first_of(const_pointer s, size_type pos) const noexcept { const size_type len = char_traits::length(s); for (auto i = pos; i < size_; ++i) { value_type ch = *(buffer_ + i); for (size_type j = 0; j < len; ++j) { if (ch == *(s + j)) return i; } } return npos; } // 从下标 pos 开始查找字符串 s template typename basic_string::size_type basic_string:: find_first_of(const_pointer s, size_type pos, size_type count) const noexcept { for (auto i = pos; i < size_; ++i) { value_type ch = *(buffer_ + i); for (size_type j = 0; j < count; ++j) { if (ch == *(s + j)) return i; } } return npos; } // 从下标 pos 开始查找字符串 str 其中一个字符出现的第一个位置 template typename basic_string::size_type basic_string:: find_first_of(const basic_string& str, size_type pos) const noexcept { for (auto i = pos; i < size_; ++i) { value_type ch = *(buffer_ + i); for (size_type j = 0; j < str.size_; ++j) { if (ch == str[j]) return i; } } return npos; } // 从下标 pos 开始查找与 ch 不相等的第一个位置 template typename basic_string::size_type basic_string:: find_first_not_of(value_type ch, size_type pos) const noexcept { for (auto i = pos; i < size_; ++i) { if (*(buffer_ + i) != ch) return i; } return npos; } // 从下标 pos 开始查找与字符串 s 其中一个字符不相等的第一个位置 template typename basic_string::size_type basic_string:: find_first_not_of(const_pointer s, size_type pos) const noexcept { const size_type len = char_traits::length(s); for (auto i = pos; i < size_; ++i) { value_type ch = *(buffer_ + i); for (size_type j = 0; j < len; ++j) { if (ch != *(s + j)) return i; } } return npos; } // 从下标 pos 开始查找与字符串 s 前 count 个字符中不相等的第一个位置 template typename basic_string::size_type basic_string:: find_first_not_of(const_pointer s, size_type pos, size_type count) const noexcept { for (auto i = pos; i < size_; ++i) { value_type ch = *(buffer_ + i); for (size_type j = 0; j < count; ++j) { if (ch != *(s + j)) return i; } } return npos; } // 从下标 pos 开始查找与字符串 str 的字符中不相等的第一个位置 template typename basic_string::size_type basic_string:: find_first_not_of(const basic_string& str, size_type pos) const noexcept { for (auto i = pos; i < size_; ++i) { value_type ch = *(buffer_ + i); for (size_type j = 0; j < str.size_; ++j) { if (ch != str[j]) return i; } } return npos; } // 从下标 pos 开始查找与 ch 相等的最后一个位置 template typename basic_string::size_type basic_string:: find_last_of(value_type ch, size_type pos) const noexcept { for (auto i = size_ - 1; i >= pos; --i) { if (*(buffer_ + i) == ch) return i; } return npos; } // 从下标 pos 开始查找与字符串 s 其中一个字符相等的最后一个位置 template typename basic_string::size_type basic_string:: find_last_of(const_pointer s, size_type pos) const noexcept { const size_type len = char_traits::length(s); for (auto i = size_ - 1; i >= pos; --i) { value_type ch = *(buffer_ + i); for (size_type j = 0; j < len; ++j) { if (ch == *(s + j)) return i; } } return npos; } // 从下标 pos 开始查找与字符串 s 前 count 个字符中相等的最后一个位置 template typename basic_string::size_type basic_string:: find_last_of(const_pointer s, size_type pos, size_type count) const noexcept { for (auto i = size_ - 1; i >= pos; --i) { value_type ch = *(buffer_ + i); for (size_type j = 0; j < count; ++j) { if (ch == *(s + j)) return i; } } return npos; } // 从下标 pos 开始查找与字符串 str 字符中相等的最后一个位置 template typename basic_string::size_type basic_string:: find_last_of(const basic_string& str, size_type pos) const noexcept { for (auto i = size_ - 1; i >= pos; --i) { value_type ch = *(buffer_ + i); for (size_type j = 0; j < str.size_; ++j) { if (ch == str[j]) return i; } } return npos; } // 从下标 pos 开始查找与 ch 字符不相等的最后一个位置 template typename basic_string::size_type basic_string:: find_last_not_of(value_type ch, size_type pos) const noexcept { for (auto i = size_ - 1; i >= pos; --i) { if (*(buffer_ + i) != ch) return i; } return npos; } // 从下标 pos 开始查找与字符串 s 的字符中不相等的最后一个位置 template typename basic_string::size_type basic_string:: find_last_not_of(const_pointer s, size_type pos) const noexcept { const size_type len = char_traits::length(s); for (auto i = size_ - 1; i >= pos; --i) { value_type ch = *(buffer_ + i); for (size_type j = 0; j < len; ++j) { if (ch != *(s + j)) return i; } } return npos; } // 从下标 pos 开始查找与字符串 s 前 count 个字符中不相等的最后一个位置 template typename basic_string::size_type basic_string:: find_last_not_of(const_pointer s, size_type pos, size_type count) const noexcept { for (auto i = size_ - 1; i >= pos; --i) { value_type ch = *(buffer_ + i); for (size_type j = 0; j < count; ++j) { if (ch != *(s + j)) return i; } } return npos; } // 从下标 pos 开始查找与字符串 str 字符中不相等的最后一个位置 template typename basic_string::size_type basic_string:: find_last_not_of(const basic_string& str, size_type pos) const noexcept { for (auto i = size_ - 1; i >= pos; --i) { value_type ch = *(buffer_ + i); for (size_type j = 0; j < str.size_; ++j) { if (ch != str[j]) return i; } } return npos; } // 返回从下标 pos 开始字符为 ch 的元素出现的次数 template typename basic_string::size_type basic_string:: count(value_type ch, size_type pos) const noexcept { size_type n = 0; for (auto i = pos; i < size_; ++i) { if (*(buffer_ + i) == ch) ++n; } return n; } /*****************************************************************************************/ // helper function // 尝试初始化一段 buffer，若分配失败则忽略，不会抛出异常 template void basic_string:: try_init() noexcept { try { buffer_ = data_allocator::allocate(static_cast(STRING_INIT_SIZE)); size_ = 0; cap_ = 0; } catch (...) { buffer_ = nullptr; size_ = 0; cap_ = 0; // no throw } } // fill_init 函数 template void basic_string:: fill_init(size_type n, value_type ch) { const auto init_size = mystl::max(static_cast(STRING_INIT_SIZE), n + 1); buffer_ = data_allocator::allocate(init_size); char_traits::fill(buffer_, ch, n); size_ = n; cap_ = init_size; } // copy_init 函数 template template void basic_string:: copy_init(Iter first, Iter last, mystl::input_iterator_tag) { size_type n = mystl::distance(first, last); const auto init_size = mystl::max(static_cast(STRING_INIT_SIZE), n + 1); try { buffer_ = data_allocator::allocate(init_size); size_ = n; cap_ = init_size; } catch (...) { buffer_ = nullptr; size_ = 0; cap_ = 0; throw; } for (; n > 0; --n, ++first) append(*first); } template template void basic_string:: copy_init(Iter first, Iter last, mystl::forward_iterator_tag) { const size_type n = mystl::distance(first, last); const auto init_size = mystl::max(static_cast(STRING_INIT_SIZE), n + 1); try { buffer_ = data_allocator::allocate(init_size); size_ = n; cap_ = init_size; mystl::uninitialized_copy(first, last, buffer_); } catch (...) { buffer_ = nullptr; size_ = 0; cap_ = 0; throw; } } // init_from 函数 template void basic_string:: init_from(const_pointer src, size_type pos, size_type count) { const auto init_size = mystl::max(static_cast(STRING_INIT_SIZE), count + 1); buffer_ = data_allocator::allocate(init_size); char_traits::copy(buffer_, src + pos, count); size_ = count; cap_ = init_size; } // destroy_buffer 函数 template void basic_string:: destroy_buffer() { if (buffer_ != nullptr) { data_allocator::deallocate(buffer_, cap_); buffer_ = nullptr; size_ = 0; cap_ = 0; } } // to_raw_pointer 函数 template typename basic_string::const_pointer basic_string:: to_raw_pointer() const { *(buffer_ + size_) = value_type(); return buffer_; } // reinsert 函数 template void basic_string:: reinsert(size_type size) { auto new_buffer = data_allocator::allocate(size); try { char_traits::move(new_buffer, buffer_, size); } catch (...) { data_allocator::deallocate(new_buffer); } buffer_ = new_buffer; size_ = size; cap_ = size; } // append_range，末尾追加一段 [first, last) 内的字符 template template basic_string& basic_string:: append_range(Iter first, Iter last) { const size_type n = mystl::distance(first, last); THROW_LENGTH_ERROR_IF(size_ > max_size() - n, "basic_string's size too big"); if (cap_ - size_ < n) { reallocate(n); } mystl::uninitialized_copy_n(first, n, buffer_ + size_); size_ += n; return *this; } template int basic_string:: compare_cstr(const_pointer s1, size_type n1, const_pointer s2, size_type n2) const { auto rlen = mystl::min(n1, n2); auto res = char_traits::compare(s1, s2, rlen); if (res != 0) return res; if (n1 < n2) return -1; if (n1 > n2) return 1; return 0; } // 把 first 开始的 count1 个字符替换成 str 开始的 count2 个字符 template basic_string& basic_string:: replace_cstr(const_iterator first, size_type count1, const_pointer str, size_type count2) { if (static_cast(cend() - first) < count1) { count1 = cend() - first; } if (count1 < count2) { const size_type add = count2 - count1; THROW_LENGTH_ERROR_IF(size_ > max_size() - add, "basic_string's size too big"); if (size_ > cap_ - add) { reallocate(add); } pointer r = const_cast(first); char_traits::move(r + count2, first + count1, end() - (first + count1)); char_traits::copy(r, str, count2); size_ += add; } else { pointer r = const_cast(first); char_traits::move(r + count2, first + count1, end() - (first + count1)); char_traits::copy(r, str, count2); size_ -= (count1 - count2); } return *this; } // 把 first 开始的 count1 个字符替换成 count2 个 ch 字符 template basic_string& basic_string:: replace_fill(const_iterator first, size_type count1, size_type count2, value_type ch) { if (static_cast(cend() - first) < count1) { count1 = cend() - first; } if (count1 < count2) { const size_type add = count2 - count1; THROW_LENGTH_ERROR_IF(size_ > max_size() - add, "basic_string's size too big"); if (size_ > cap_ - add) { reallocate(add); } pointer r = const_cast(first); char_traits::move(r + count2, first + count1, end() - (first + count1)); char_traits::fill(r, ch, count2); size_ += add; } else { pointer r = const_cast(first); char_traits::move(r + count2, first + count1, end() - (first + count1)); char_traits::fill(r, ch, count2); size_ -= (count1 - count2); } return *this; } // 把 [first, last) 的字符替换成 [first2, last2) template template basic_string& basic_string:: replace_copy(const_iterator first, const_iterator last, Iter first2, Iter last2) { size_type len1 = last - first; size_type len2 = last2 - first2; if (len1 < len2) { const size_type add = len2 - len1; THROW_LENGTH_ERROR_IF(size_ > max_size() - add, "basic_string's size too big"); if (size_ > cap_ - add) { reallocate(add); } pointer r = const_cast(first); char_traits::move(r + len2, first + len1, end() - (first + len1)); char_traits::copy(r, first2, len2); size_ += add; } else { pointer r = const_cast(first); char_traits::move(r + len2, first + len1, end() - (first + len1)); char_traits::copy(r, first2, len2); size_ -= (len1 - len2); } return *this; } // reallocate 函数 template void basic_string:: reallocate(size_type need) { const auto new_cap = mystl::max(cap_ + need, cap_ + (cap_ >> 1)); auto new_buffer = data_allocator::allocate(new_cap); char_traits::move(new_buffer, buffer_, size_); data_allocator::deallocate(buffer_); buffer_ = new_buffer; cap_ = new_cap; } // reallocate_and_fill 函数 template typename basic_string::iterator basic_string:: reallocate_and_fill(iterator pos, size_type n, value_type ch) { const auto r = pos - buffer_; const auto old_cap = cap_; const auto new_cap = mystl::max(old_cap + n, old_cap + (old_cap >> 1)); auto new_buffer = data_allocator::allocate(new_cap); auto e1 = char_traits::move(new_buffer, buffer_, r) + r; auto e2 = char_traits::fill(e1, ch, n) + n; char_traits::move(e2, buffer_ + r, size_ - r); data_allocator::deallocate(buffer_, old_cap); buffer_ = new_buffer; size_ += n; cap_ = new_cap; return buffer_ + r; } // reallocate_and_copy 函数 template typename basic_string::iterator basic_string:: reallocate_and_copy(iterator pos, const_iterator first, const_iterator last) { const auto r = pos - buffer_; const auto old_cap = cap_; const size_type n = mystl::distance(first, last); const auto new_cap = mystl::max(old_cap + n, old_cap + (old_cap >> 1)); auto new_buffer = data_allocator::allocate(new_cap); auto e1 = char_traits::move(new_buffer, buffer_, r) + r; auto e2 = mystl::uninitialized_copy_n(first, n, e1) + n; char_traits::move(e2, buffer_ + r, size_ - r); data_allocator::deallocate(buffer_, old_cap); buffer_ = new_buffer; size_ += n; cap_ = new_cap; return buffer_ + r; } /*****************************************************************************************/ // 重载全局操作符 // 重载 operator+ template basic_string operator+(const basic_string& lhs, const basic_string& rhs) { basic_string tmp(lhs); tmp.append(rhs); return tmp; } template basic_string operator+(const CharType* lhs, const basic_string& rhs) { basic_string tmp(lhs); tmp.append(rhs); return tmp; } template basic_string operator+(CharType ch, const basic_string& rhs) { basic_string tmp(1, ch); tmp.append(rhs); return tmp; } template basic_string operator+(const basic_string& lhs, const CharType* rhs) { basic_string tmp(lhs); tmp.append(rhs); return tmp; } template basic_string operator+(const basic_string& lhs, CharType ch) { basic_string tmp(lhs); tmp.append(1, ch); return tmp; } template basic_string operator+(basic_string&& lhs, const basic_string& rhs) { basic_string tmp(mystl::move(lhs)); tmp.append(rhs); return tmp; } template basic_string operator+(const basic_string& lhs, basic_string&& rhs) { basic_string tmp(mystl::move(rhs)); tmp.insert(tmp.begin(), lhs.begin(), lhs.end()); return tmp; } template basic_string operator+(basic_string&& lhs, basic_string&& rhs) { basic_string tmp(mystl::move(lhs)); tmp.append(rhs); return tmp; } template basic_string operator+(const CharType* lhs, basic_string&& rhs) { basic_string tmp(mystl::move(rhs)); tmp.insert(tmp.begin(), lhs, lhs + char_traits::length(lhs)); return tmp; } template basic_string operator+(CharType ch, basic_string&& rhs) { basic_string tmp(mystl::move(rhs)); tmp.insert(tmp.begin(), ch); return tmp; } template basic_string operator+(basic_string&& lhs, const CharType* rhs) { basic_string tmp(mystl::move(lhs)); tmp.append(rhs); return tmp; } template basic_string operator+(basic_string&& lhs, CharType ch) { basic_string tmp(mystl::move(lhs)); tmp.append(1, ch); return tmp; } // 重载比较操作符 template bool operator==(const basic_string& lhs, const basic_string& rhs) { return lhs.size() == rhs.size() && lhs.compare(rhs) == 0; } template bool operator!=(const basic_string& lhs, const basic_string& rhs) { return lhs.size() != rhs.size() || lhs.compare(rhs) != 0; } template bool operator<(const basic_string& lhs, const basic_string& rhs) { return lhs.compare(rhs) < 0; } template bool operator<=(const basic_string& lhs, const basic_string& rhs) { return lhs.compare(rhs) <= 0; } template bool operator>(const basic_string& lhs, const basic_string& rhs) { return lhs.compare(rhs) > 0; } template bool operator>=(const basic_string& lhs, const basic_string& rhs) { return lhs.compare(rhs) >= 0; } // 重载 mystl 的 swap template void swap(basic_string& lhs, basic_string& rhs) noexcept { lhs.swap(rhs); } // 特化 mystl::hash template struct hash> { size_t operator()(const basic_string& str) { return bitwise_hash((const unsigned char*)str.c_str(), str.size() * sizeof(CharType)); } }; } // namespace mystl #endif // !MYTINYSTL_BASIC_STRING_H_ ================================================ FILE: MyTinySTL/construct.h ================================================ #ifndef MYTINYSTL_CONSTRUCT_H_ #define MYTINYSTL_CONSTRUCT_H_ // 这个头文件包含两个函数 construct，destroy // construct : 负责对象的构造 // destroy : 负责对象的析构 #include #include "type_traits.h" #include "iterator.h" #ifdef _MSC_VER #pragma warning(push) #pragma warning(disable : 4100) // unused parameter #endif // _MSC_VER namespace mystl { // construct 构造对象 template void construct(Ty* ptr) { ::new ((void*)ptr) Ty(); } template void construct(Ty1* ptr, const Ty2& value) { ::new ((void*)ptr) Ty1(value); } template void construct(Ty* ptr, Args&&... args) { ::new ((void*)ptr) Ty(mystl::forward(args)...); } // destroy 将对象析构 template void destroy_one(Ty*, std::true_type) {} template void destroy_one(Ty* pointer, std::false_type) { if (pointer != nullptr) { pointer->~Ty(); } } template void destroy_cat(ForwardIter , ForwardIter , std::true_type) {} template void destroy_cat(ForwardIter first, ForwardIter last, std::false_type) { for (; first != last; ++first) destroy(&*first); } template void destroy(Ty* pointer) { destroy_one(pointer, std::is_trivially_destructible{}); } template void destroy(ForwardIter first, ForwardIter last) { destroy_cat(first, last, std::is_trivially_destructible< typename iterator_traits::value_type>{}); } } // namespace mystl #ifdef _MSC_VER #pragma warning(pop) #endif // _MSC_VER #endif // !MYTINYSTL_CONSTRUCT_H_ ================================================ FILE: MyTinySTL/deque.h ================================================ #ifndef MYTINYSTL_DEQUE_H_ #define MYTINYSTL_DEQUE_H_ // 这个头文件包含了一个模板类 deque // deque: 双端队列 // notes: // // 异常保证： // mystl::deque 满足基本异常保证，部分函数无异常保证，并对以下等函数做强异常安全保证： // * emplace_front // * emplace_back // * emplace // * push_front // * push_back // * insert #include #include "iterator.h" #include "memory.h" #include "util.h" #include "exceptdef.h" namespace mystl { #ifdef max #pragma message("#undefing marco max") #undef max #endif // max #ifdef min #pragma message("#undefing marco min") #undef min #endif // min // deque map 初始化的大小 #ifndef DEQUE_MAP_INIT_SIZE #define DEQUE_MAP_INIT_SIZE 8 #endif template struct deque_buf_size { static constexpr size_t value = sizeof(T) < 256 ? 4096 / sizeof(T) : 16; }; // deque 的迭代器设计 template struct deque_iterator : public iterator { typedef deque_iterator iterator; typedef deque_iterator const_iterator; typedef deque_iterator self; typedef T value_type; typedef Ptr pointer; typedef Ref reference; typedef size_t size_type; typedef ptrdiff_t difference_type; typedef T* value_pointer; typedef T** map_pointer; static const size_type buffer_size = deque_buf_size::value; // 迭代器所含成员数据 value_pointer cur; // 指向所在缓冲区的当前元素 value_pointer first; // 指向所在缓冲区的头部 value_pointer last; // 指向所在缓冲区的尾部 map_pointer node; // 缓冲区所在节点 // 构造、复制、移动函数 deque_iterator() noexcept :cur(nullptr), first(nullptr), last(nullptr), node(nullptr) {} deque_iterator(value_pointer v, map_pointer n) :cur(v), first(*n), last(*n + buffer_size), node(n) {} deque_iterator(const iterator& rhs) :cur(rhs.cur), first(rhs.first), last(rhs.last), node(rhs.node) { } deque_iterator(iterator&& rhs) noexcept :cur(rhs.cur), first(rhs.first), last(rhs.last), node(rhs.node) { rhs.cur = nullptr; rhs.first = nullptr; rhs.last = nullptr; rhs.node = nullptr; } deque_iterator(const const_iterator& rhs) :cur(rhs.cur), first(rhs.first), last(rhs.last), node(rhs.node) { } self& operator=(const iterator& rhs) { if (this != &rhs) { cur = rhs.cur; first = rhs.first; last = rhs.last; node = rhs.node; } return *this; } // 转到另一个缓冲区 void set_node(map_pointer new_node) { node = new_node; first = *new_node; last = first + buffer_size; } // 重载运算符 reference operator*() const { return *cur; } pointer operator->() const { return cur; } difference_type operator-(const self& x) const { return static_cast(buffer_size) * (node - x.node) + (cur - first) - (x.cur - x.first); } self& operator++() { ++cur; if (cur == last) { // 如果到达缓冲区的尾 set_node(node + 1); cur = first; } return *this; } self operator++(int) { self tmp = *this; ++*this; return tmp; } self& operator--() { if (cur == first) { // 如果到达缓冲区的头 set_node(node - 1); cur = last; } --cur; return *this; } self operator--(int) { self tmp = *this; --*this; return tmp; } self& operator+=(difference_type n) { const auto offset = n + (cur - first); if (offset >= 0 && offset < static_cast(buffer_size)) { // 仍在当前缓冲区 cur += n; } else { // 要跳到其他的缓冲区 const auto node_offset = offset > 0 ? offset / static_cast(buffer_size) : -static_cast((-offset - 1) / buffer_size) - 1; set_node(node + node_offset); cur = first + (offset - node_offset * static_cast(buffer_size)); } return *this; } self operator+(difference_type n) const { self tmp = *this; return tmp += n; } self& operator-=(difference_type n) { return *this += -n; } self operator-(difference_type n) const { self tmp = *this; return tmp -= n; } reference operator[](difference_type n) const { return *(*this + n); } // 重载比较操作符 bool operator==(const self& rhs) const { return cur == rhs.cur; } bool operator< (const self& rhs) const { return node == rhs.node ? (cur < rhs.cur) : (node < rhs.node); } bool operator!=(const self& rhs) const { return !(*this == rhs); } bool operator> (const self& rhs) const { return rhs < *this; } bool operator<=(const self& rhs) const { return !(rhs < *this); } bool operator>=(const self& rhs) const { return !(*this < rhs); } }; // 模板类 deque // 模板参数代表数据类型 template class deque { public: // deque 的型别定义 typedef mystl::allocator allocator_type; typedef mystl::allocator data_allocator; typedef mystl::allocator map_allocator; typedef typename allocator_type::value_type value_type; typedef typename allocator_type::pointer pointer; typedef typename allocator_type::const_pointer const_pointer; typedef typename allocator_type::reference reference; typedef typename allocator_type::const_reference const_reference; typedef typename allocator_type::size_type size_type; typedef typename allocator_type::difference_type difference_type; typedef pointer* map_pointer; typedef const_pointer* const_map_pointer; typedef deque_iterator iterator; typedef deque_iterator const_iterator; typedef mystl::reverse_iterator reverse_iterator; typedef mystl::reverse_iterator const_reverse_iterator; allocator_type get_allocator() { return allocator_type(); } static const size_type buffer_size = deque_buf_size::value; private: // 用以下四个数据来表现一个 deque iterator begin_; // 指向第一个节点 iterator end_; // 指向最后一个结点 map_pointer map_; // 指向一块 map，map 中的每个元素都是一个指针，指向一个缓冲区 size_type map_size_; // map 内指针的数目 public: // 构造、复制、移动、析构函数 deque() { fill_init(0, value_type()); } explicit deque(size_type n) { fill_init(n, value_type()); } deque(size_type n, const value_type& value) { fill_init(n, value); } template ::value, int>::type = 0> deque(IIter first, IIter last) { copy_init(first, last, iterator_category(first)); } deque(std::initializer_list ilist) { copy_init(ilist.begin(), ilist.end(), mystl::forward_iterator_tag()); } deque(const deque& rhs) { copy_init(rhs.begin(), rhs.end(), mystl::forward_iterator_tag()); } deque(deque&& rhs) noexcept :begin_(mystl::move(rhs.begin_)), end_(mystl::move(rhs.end_)), map_(rhs.map_), map_size_(rhs.map_size_) { rhs.map_ = nullptr; rhs.map_size_ = 0; } deque& operator=(const deque& rhs); deque& operator=(deque&& rhs); deque& operator=(std::initializer_list ilist) { deque tmp(ilist); swap(tmp); return *this; } ~deque() { if (map_ != nullptr) { clear(); data_allocator::deallocate(*begin_.node, buffer_size); *begin_.node = nullptr; map_allocator::deallocate(map_, map_size_); map_ = nullptr; } } public: // 迭代器相关操作 iterator begin() noexcept { return begin_; } const_iterator begin() const noexcept { return begin_; } iterator end() noexcept { return end_; } const_iterator end() const noexcept { return end_; } reverse_iterator rbegin() noexcept { return reverse_iterator(end()); } const_reverse_iterator rbegin() const noexcept { return reverse_iterator(end()); } reverse_iterator rend() noexcept { return reverse_iterator(begin()); } const_reverse_iterator rend() const noexcept { return reverse_iterator(begin()); } const_iterator cbegin() const noexcept { return begin(); } const_iterator cend() const noexcept { return end(); } const_reverse_iterator crbegin() const noexcept { return rbegin(); } const_reverse_iterator crend() const noexcept { return rend(); } // 容量相关操作 bool empty() const noexcept { return begin() == end(); } size_type size() const noexcept { return end_ - begin_; } size_type max_size() const noexcept { return static_cast(-1); } void resize(size_type new_size) { resize(new_size, value_type()); } void resize(size_type new_size, const value_type& value); void shrink_to_fit() noexcept; // 访问元素相关操作 reference operator[](size_type n) { MYSTL_DEBUG(n < size()); return begin_[n]; } const_reference operator[](size_type n) const { MYSTL_DEBUG(n < size()); return begin_[n]; } reference at(size_type n) { THROW_OUT_OF_RANGE_IF(!(n < size()), "deque::at() subscript out of range"); return (*this)[n]; } const_reference at(size_type n) const { THROW_OUT_OF_RANGE_IF(!(n < size()), "deque::at() subscript out of range"); return (*this)[n]; } reference front() { MYSTL_DEBUG(!empty()); return *begin(); } const_reference front() const { MYSTL_DEBUG(!empty()); return *begin(); } reference back() { MYSTL_DEBUG(!empty()); return *(end() - 1); } const_reference back() const { MYSTL_DEBUG(!empty()); return *(end() - 1); } // 修改容器相关操作 // assign void assign(size_type n, const value_type& value) { fill_assign(n, value); } template ::value, int>::type = 0> void assign(IIter first, IIter last) { copy_assign(first, last, iterator_category(first)); } void assign(std::initializer_list ilist) { copy_assign(ilist.begin(), ilist.end(), mystl::forward_iterator_tag{}); } // emplace_front / emplace_back / emplace template void emplace_front(Args&& ...args); template void emplace_back(Args&& ...args); template iterator emplace(iterator pos, Args&& ...args); // push_front / push_back void push_front(const value_type& value); void push_back(const value_type& value); void push_front(value_type&& value) { emplace_front(mystl::move(value)); } void push_back(value_type&& value) { emplace_back(mystl::move(value)); } // pop_back / pop_front void pop_front(); void pop_back(); // insert iterator insert(iterator position, const value_type& value); iterator insert(iterator position, value_type&& value); void insert(iterator position, size_type n, const value_type& value); template ::value, int>::type = 0> void insert(iterator position, IIter first, IIter last) { insert_dispatch(position, first, last, iterator_category(first)); } // erase /clear iterator erase(iterator position); iterator erase(iterator first, iterator last); void clear(); // swap void swap(deque& rhs) noexcept; private: // helper functions // create node / destroy node map_pointer create_map(size_type size); void create_buffer(map_pointer nstart, map_pointer nfinish); void destroy_buffer(map_pointer nstart, map_pointer nfinish); // initialize void map_init(size_type nelem); void fill_init(size_type n, const value_type& value); template void copy_init(IIter, IIter, input_iterator_tag); template void copy_init(FIter, FIter, forward_iterator_tag); // assign void fill_assign(size_type n, const value_type& value); template void copy_assign(IIter first, IIter last, input_iterator_tag); template void copy_assign(FIter first, FIter last, forward_iterator_tag); // insert template iterator insert_aux(iterator position, Args&& ...args); void fill_insert(iterator position, size_type n, const value_type& x); template void copy_insert(iterator, FIter, FIter, size_type); template void insert_dispatch(iterator, IIter, IIter, input_iterator_tag); template void insert_dispatch(iterator, FIter, FIter, forward_iterator_tag); // reallocate void require_capacity(size_type n, bool front); void reallocate_map_at_front(size_type need); void reallocate_map_at_back(size_type need); }; /*****************************************************************************************/ // 复制赋值运算符 template deque& deque::operator=(const deque& rhs) { if (this != &rhs) { const auto len = size(); if (len >= rhs.size()) { erase(mystl::copy(rhs.begin_, rhs.end_, begin_), end_); } else { iterator mid = rhs.begin() + static_cast(len); mystl::copy(rhs.begin_, mid, begin_); insert(end_, mid, rhs.end_); } } return *this; } // 移动赋值运算符 template deque& deque::operator=(deque&& rhs) { clear(); begin_ = mystl::move(rhs.begin_); end_ = mystl::move(rhs.end_); map_ = rhs.map_; map_size_ = rhs.map_size_; rhs.map_ = nullptr; rhs.map_size_ = 0; return *this; } // 重置容器大小 template void deque::resize(size_type new_size, const value_type& value) { const auto len = size(); if (new_size < len) { erase(begin_ + new_size, end_); } else { insert(end_, new_size - len, value); } } // 减小容器容量 template void deque::shrink_to_fit() noexcept { // 至少会留下头部缓冲区 for (auto cur = map_; cur < begin_.node; ++cur) { data_allocator::deallocate(*cur, buffer_size); *cur = nullptr; } for (auto cur = end_.node + 1; cur < map_ + map_size_; ++cur) { data_allocator::deallocate(*cur, buffer_size); *cur = nullptr; } } // 在头部就地构建元素 template template void deque::emplace_front(Args&& ...args) { if (begin_.cur != begin_.first) { data_allocator::construct(begin_.cur - 1, mystl::forward(args)...); --begin_.cur; } else { require_capacity(1, true); try { --begin_; data_allocator::construct(begin_.cur, mystl::forward(args)...); } catch (...) { ++begin_; throw; } } } // 在尾部就地构建元素 template template void deque::emplace_back(Args&& ...args) { if (end_.cur != end_.last - 1) { data_allocator::construct(end_.cur, mystl::forward(args)...); ++end_.cur; } else { require_capacity(1, false); data_allocator::construct(end_.cur, mystl::forward(args)...); ++end_; } } // 在 pos 位置就地构建元素 template template typename deque::iterator deque::emplace(iterator pos, Args&& ...args) { if (pos.cur == begin_.cur) { emplace_front(mystl::forward(args)...); return begin_; } else if (pos.cur == end_.cur) { emplace_back(mystl::forward(args)...); return end_ - 1; } return insert_aux(pos, mystl::forward(args)...); } // 在头部插入元素 template void deque::push_front(const value_type& value) { if (begin_.cur != begin_.first) { data_allocator::construct(begin_.cur - 1, value); --begin_.cur; } else { require_capacity(1, true); try { --begin_; data_allocator::construct(begin_.cur, value); } catch (...) { ++begin_; throw; } } } // 在尾部插入元素 template void deque::push_back(const value_type& value) { if (end_.cur != end_.last - 1) { data_allocator::construct(end_.cur, value); ++end_.cur; } else { require_capacity(1, false); data_allocator::construct(end_.cur, value); ++end_; } } // 弹出头部元素 template void deque::pop_front() { MYSTL_DEBUG(!empty()); if (begin_.cur != begin_.last - 1) { data_allocator::destroy(begin_.cur); ++begin_.cur; } else { data_allocator::destroy(begin_.cur); ++begin_; destroy_buffer(begin_.node - 1, begin_.node - 1); } } // 弹出尾部元素 template void deque::pop_back() { MYSTL_DEBUG(!empty()); if (end_.cur != end_.first) { --end_.cur; data_allocator::destroy(end_.cur); } else { --end_; data_allocator::destroy(end_.cur); destroy_buffer(end_.node + 1, end_.node + 1); } } // 在 position 处插入元素 template typename deque::iterator deque::insert(iterator position, const value_type& value) { if (position.cur == begin_.cur) { push_front(value); return begin_; } else if (position.cur == end_.cur) { push_back(value); auto tmp = end_; --tmp; return tmp; } else { return insert_aux(position, value); } } template typename deque::iterator deque::insert(iterator position, value_type&& value) { if (position.cur == begin_.cur) { emplace_front(mystl::move(value)); return begin_; } else if (position.cur == end_.cur) { emplace_back(mystl::move(value)); auto tmp = end_; --tmp; return tmp; } else { return insert_aux(position, mystl::move(value)); } } // 在 position 位置插入 n 个元素 template void deque::insert(iterator position, size_type n, const value_type& value) { if (position.cur == begin_.cur) { require_capacity(n, true); auto new_begin = begin_ - n; mystl::uninitialized_fill_n(new_begin, n, value); begin_ = new_begin; } else if (position.cur == end_.cur) { require_capacity(n, false); auto new_end = end_ + n; mystl::uninitialized_fill_n(end_, n, value); end_ = new_end; } else { fill_insert(position, n, value); } } // 删除 position 处的元素 template typename deque::iterator deque::erase(iterator position) { auto next = position; ++next; const size_type elems_before = position - begin_; if (elems_before < (size() / 2)) { mystl::copy_backward(begin_, position, next); pop_front(); } else { mystl::copy(next, end_, position); pop_back(); } return begin_ + elems_before; } // 删除[first, last)上的元素 template typename deque::iterator deque::erase(iterator first, iterator last) { if (first == begin_ && last == end_) { clear(); return end_; } else { const size_type len = last - first; const size_type elems_before = first - begin_; if (elems_before < ((size() - len) / 2)) { mystl::copy_backward(begin_, first, last); auto new_begin = begin_ + len; data_allocator::destroy(begin_.cur, new_begin.cur); begin_ = new_begin; } else { mystl::copy(last, end_, first); auto new_end = end_ - len; data_allocator::destroy(new_end.cur, end_.cur); end_ = new_end; } return begin_ + elems_before; } } // 清空 deque template void deque::clear() { // clear 会保留头部的缓冲区 for (map_pointer cur = begin_.node + 1; cur < end_.node; ++cur) { data_allocator::destroy(*cur, *cur + buffer_size); } if (begin_.node != end_.node) { // 有两个以上的缓冲区 mystl::destroy(begin_.cur, begin_.last); mystl::destroy(end_.first, end_.cur); } else { mystl::destroy(begin_.cur, end_.cur); } shrink_to_fit(); end_ = begin_; } // 交换两个 deque template void deque::swap(deque& rhs) noexcept { if (this != &rhs) { mystl::swap(begin_, rhs.begin_); mystl::swap(end_, rhs.end_); mystl::swap(map_, rhs.map_); mystl::swap(map_size_, rhs.map_size_); } } /*****************************************************************************************/ // helper function template typename deque::map_pointer deque::create_map(size_type size) { map_pointer mp = nullptr; mp = map_allocator::allocate(size); for (size_type i = 0; i < size; ++i) *(mp + i) = nullptr; return mp; } // create_buffer 函数 template void deque:: create_buffer(map_pointer nstart, map_pointer nfinish) { map_pointer cur; try { for (cur = nstart; cur <= nfinish; ++cur) { *cur = data_allocator::allocate(buffer_size); } } catch (...) { while (cur != nstart) { --cur; data_allocator::deallocate(*cur, buffer_size); *cur = nullptr; } throw; } } // destroy_buffer 函数 template void deque:: destroy_buffer(map_pointer nstart, map_pointer nfinish) { for (map_pointer n = nstart; n <= nfinish; ++n) { data_allocator::deallocate(*n, buffer_size); *n = nullptr; } } // map_init 函数 template void deque:: map_init(size_type nElem) { const size_type nNode = nElem / buffer_size + 1; // 需要分配的缓冲区个数 map_size_ = mystl::max(static_cast(DEQUE_MAP_INIT_SIZE), nNode + 2); try { map_ = create_map(map_size_); } catch (...) { map_ = nullptr; map_size_ = 0; throw; } // 让 nstart 和 nfinish 都指向 map_ 最中央的区域，方便向头尾扩充 map_pointer nstart = map_ + (map_size_ - nNode) / 2; map_pointer nfinish = nstart + nNode - 1; try { create_buffer(nstart, nfinish); } catch (...) { map_allocator::deallocate(map_, map_size_); map_ = nullptr; map_size_ = 0; throw; } begin_.set_node(nstart); end_.set_node(nfinish); begin_.cur = begin_.first; end_.cur = end_.first + (nElem % buffer_size); } // fill_init 函数 template void deque:: fill_init(size_type n, const value_type& value) { map_init(n); if (n != 0) { for (auto cur = begin_.node; cur < end_.node; ++cur) { mystl::uninitialized_fill(*cur, *cur + buffer_size, value); } mystl::uninitialized_fill(end_.first, end_.cur, value); } } // copy_init 函数 template template void deque:: copy_init(IIter first, IIter last, input_iterator_tag) { const size_type n = mystl::distance(first, last); map_init(n); for (; first != last; ++first) emplace_back(*first); } template template void deque:: copy_init(FIter first, FIter last, forward_iterator_tag) { const size_type n = mystl::distance(first, last); map_init(n); for (auto cur = begin_.node; cur < end_.node; ++cur) { auto next = first; mystl::advance(next, buffer_size); mystl::uninitialized_copy(first, next, *cur); first = next; } mystl::uninitialized_copy(first, last, end_.first); } // fill_assign 函数 template void deque:: fill_assign(size_type n, const value_type& value) { if (n > size()) { mystl::fill(begin(), end(), value); insert(end(), n - size(), value); } else { erase(begin() + n, end()); mystl::fill(begin(), end(), value); } } // copy_assign 函数 template template void deque:: copy_assign(IIter first, IIter last, input_iterator_tag) { auto first1 = begin(); auto last1 = end(); for (; first != last && first1 != last1; ++first, ++first1) { *first1 = *first; } if (first1 != last1) { erase(first1, last1); } else { insert_dispatch(end_, first, last, input_iterator_tag{}); } } template template void deque:: copy_assign(FIter first, FIter last, forward_iterator_tag) { const size_type len1 = size(); const size_type len2 = mystl::distance(first, last); if (len1 < len2) { auto next = first; mystl::advance(next, len1); mystl::copy(first, next, begin_); insert_dispatch(end_, next, last, forward_iterator_tag{}); } else { erase(mystl::copy(first, last, begin_), end_); } } // insert_aux 函数 template template typename deque::iterator deque:: insert_aux(iterator position, Args&& ...args) { const size_type elems_before = position - begin_; value_type value_copy = value_type(mystl::forward(args)...); if (elems_before < (size() / 2)) { // 在前半段插入 emplace_front(front()); auto front1 = begin_; ++front1; auto front2 = front1; ++front2; position = begin_ + elems_before; auto pos = position; ++pos; mystl::copy(front2, pos, front1); } else { // 在后半段插入 emplace_back(back()); auto back1 = end_; --back1; auto back2 = back1; --back2; position = begin_ + elems_before; mystl::copy_backward(position, back2, back1); } *position = mystl::move(value_copy); return position; } // fill_insert 函数 template void deque:: fill_insert(iterator position, size_type n, const value_type& value) { const size_type elems_before = position - begin_; const size_type len = size(); auto value_copy = value; if (elems_before < (len / 2)) { require_capacity(n, true); // 原来的迭代器可能会失效 auto old_begin = begin_; auto new_begin = begin_ - n; position = begin_ + elems_before; try { if (elems_before >= n) { auto begin_n = begin_ + n; mystl::uninitialized_copy(begin_, begin_n, new_begin); begin_ = new_begin; mystl::copy(begin_n, position, old_begin); mystl::fill(position - n, position, value_copy); } else { mystl::uninitialized_fill( mystl::uninitialized_copy(begin_, position, new_begin), begin_, value_copy); begin_ = new_begin; mystl::fill(old_begin, position, value_copy); } } catch (...) { if (new_begin.node != begin_.node) destroy_buffer(new_begin.node, begin_.node - 1); throw; } } else { require_capacity(n, false); // 原来的迭代器可能会失效 auto old_end = end_; auto new_end = end_ + n; const size_type elems_after = len - elems_before; position = end_ - elems_after; try { if (elems_after > n) { auto end_n = end_ - n; mystl::uninitialized_copy(end_n, end_, end_); end_ = new_end; mystl::copy_backward(position, end_n, old_end); mystl::fill(position, position + n, value_copy); } else { mystl::uninitialized_fill(end_, position + n, value_copy); mystl::uninitialized_copy(position, end_, position + n); end_ = new_end; mystl::fill(position, old_end, value_copy); } } catch (...) { if(new_end.node != end_.node) destroy_buffer(end_.node + 1, new_end.node); throw; } } } // copy_insert template template void deque:: copy_insert(iterator position, FIter first, FIter last, size_type n) { const size_type elems_before = position - begin_; auto len = size(); if (elems_before < (len / 2)) { require_capacity(n, true); // 原来的迭代器可能会失效 auto old_begin = begin_; auto new_begin = begin_ - n; position = begin_ + elems_before; try { if (elems_before >= n) { auto begin_n = begin_ + n; mystl::uninitialized_copy(begin_, begin_n, new_begin); begin_ = new_begin; mystl::copy(begin_n, position, old_begin); mystl::copy(first, last, position - n); } else { auto mid = first; mystl::advance(mid, n - elems_before); mystl::uninitialized_copy(first, mid, mystl::uninitialized_copy(begin_, position, new_begin)); begin_ = new_begin; mystl::copy(mid, last, old_begin); } } catch (...) { if(new_begin.node != begin_.node) destroy_buffer(new_begin.node, begin_.node - 1); throw; } } else { require_capacity(n, false); // 原来的迭代器可能会失效 auto old_end = end_; auto new_end = end_ + n; const auto elems_after = len - elems_before; position = end_ - elems_after; try { if (elems_after > n) { auto end_n = end_ - n; mystl::uninitialized_copy(end_n, end_, end_); end_ = new_end; mystl::copy_backward(position, end_n, old_end); mystl::copy(first, last, position); } else { auto mid = first; mystl::advance(mid, elems_after); mystl::uninitialized_copy(position, end_, mystl::uninitialized_copy(mid, last, end_)); end_ = new_end; mystl::copy(first, mid, position); } } catch (...) { if(new_end.node != end_.node) destroy_buffer(end_.node + 1, new_end.node); throw; } } } // insert_dispatch 函数 template template void deque:: insert_dispatch(iterator position, IIter first, IIter last, input_iterator_tag) { if (last <= first) return; const size_type n = mystl::distance(first, last); const size_type elems_before = position - begin_; if (elems_before < (size() / 2)) { require_capacity(n, true); } else { require_capacity(n, false); } position = begin_ + elems_before; auto cur = --last; for (size_type i = 0; i < n; ++i, --cur) { insert(position, *cur); } } template template void deque:: insert_dispatch(iterator position, FIter first, FIter last, forward_iterator_tag) { if (last <= first) return; const size_type n = mystl::distance(first, last); if (position.cur == begin_.cur) { require_capacity(n, true); auto new_begin = begin_ - n; try { mystl::uninitialized_copy(first, last, new_begin); begin_ = new_begin; } catch (...) { if(new_begin.node != begin_.node) destroy_buffer(new_begin.node, begin_.node - 1); throw; } } else if (position.cur == end_.cur) { require_capacity(n, false); auto new_end = end_ + n; try { mystl::uninitialized_copy(first, last, end_); end_ = new_end; } catch (...) { if(new_end.node != end_.node) destroy_buffer(end_.node + 1, new_end.node); throw; } } else { copy_insert(position, first, last, n); } } // require_capacity 函数 template void deque::require_capacity(size_type n, bool front) { if (front && (static_cast(begin_.cur - begin_.first) < n)) { const size_type need_buffer = (n - (begin_.cur - begin_.first)) / buffer_size + 1; if (need_buffer > static_cast(begin_.node - map_)) { reallocate_map_at_front(need_buffer); return; } create_buffer(begin_.node - need_buffer, begin_.node - 1); } else if (!front && (static_cast(end_.last - end_.cur - 1) < n)) { const size_type need_buffer = (n - (end_.last - end_.cur - 1)) / buffer_size + 1; if (need_buffer > static_cast((map_ + map_size_) - end_.node - 1)) { reallocate_map_at_back(need_buffer); return; } create_buffer(end_.node + 1, end_.node + need_buffer); } } // reallocate_map_at_front 函数 template void deque::reallocate_map_at_front(size_type need_buffer) { const size_type new_map_size = mystl::max(map_size_ << 1, map_size_ + need_buffer + DEQUE_MAP_INIT_SIZE); map_pointer new_map = create_map(new_map_size); const size_type old_buffer = end_.node - begin_.node + 1; const size_type new_buffer = old_buffer + need_buffer; // 另新的 map 中的指针指向原来的 buffer，并开辟新的 buffer auto begin = new_map + (new_map_size - new_buffer) / 2; auto mid = begin + need_buffer; auto end = mid + old_buffer; create_buffer(begin, mid - 1); for (auto begin1 = mid, begin2 = begin_.node; begin1 != end; ++begin1, ++begin2) *begin1 = *begin2; // 更新数据 map_allocator::deallocate(map_, map_size_); map_ = new_map; map_size_ = new_map_size; begin_ = iterator(*mid + (begin_.cur - begin_.first), mid); end_ = iterator(*(end - 1) + (end_.cur - end_.first), end - 1); } // reallocate_map_at_back 函数 template void deque::reallocate_map_at_back(size_type need_buffer) { const size_type new_map_size = mystl::max(map_size_ << 1, map_size_ + need_buffer + DEQUE_MAP_INIT_SIZE); map_pointer new_map = create_map(new_map_size); const size_type old_buffer = end_.node - begin_.node + 1; const size_type new_buffer = old_buffer + need_buffer; // 另新的 map 中的指针指向原来的 buffer，并开辟新的 buffer auto begin = new_map + ((new_map_size - new_buffer) / 2); auto mid = begin + old_buffer; auto end = mid + need_buffer; for (auto begin1 = begin, begin2 = begin_.node; begin1 != mid; ++begin1, ++begin2) *begin1 = *begin2; create_buffer(mid, end - 1); // 更新数据 map_allocator::deallocate(map_, map_size_); map_ = new_map; map_size_ = new_map_size; begin_ = iterator(*begin + (begin_.cur - begin_.first), begin); end_ = iterator(*(mid - 1) + (end_.cur - end_.first), mid - 1); } // 重载比较操作符 template bool operator==(const deque& lhs, const deque& rhs) { return lhs.size() == rhs.size() && mystl::equal(lhs.begin(), lhs.end(), rhs.begin()); } template bool operator<(const deque& lhs, const deque& rhs) { return mystl::lexicographical_compare( lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); } template bool operator!=(const deque& lhs, const deque& rhs) { return !(lhs == rhs); } template bool operator>(const deque& lhs, const deque& rhs) { return rhs < lhs; } template bool operator<=(const deque& lhs, const deque& rhs) { return !(rhs < lhs); } template bool operator>=(const deque& lhs, const deque& rhs) { return !(lhs < rhs); } // 重载 mystl 的 swap template void swap(deque& lhs, deque& rhs) { lhs.swap(rhs); } } // namespace mystl #endif // !MYTINYSTL_DEQUE_H_ ================================================ FILE: MyTinySTL/exceptdef.h ================================================ #ifndef MYTINYSTL_EXCEPTDEF_H_ #define MYTINYSTL_EXCEPTDEF_H_ #include #include namespace mystl { #define MYSTL_DEBUG(expr) \ assert(expr) #define THROW_LENGTH_ERROR_IF(expr, what) \ if ((expr)) throw std::length_error(what) #define THROW_OUT_OF_RANGE_IF(expr, what) \ if ((expr)) throw std::out_of_range(what) #define THROW_RUNTIME_ERROR_IF(expr, what) \ if ((expr)) throw std::runtime_error(what) } // namepsace mystl #endif // !MYTINYSTL_EXCEPTDEF_H_ ================================================ FILE: MyTinySTL/functional.h ================================================ #ifndef MYTINYSTL_FUNCTIONAL_H_ #define MYTINYSTL_FUNCTIONAL_H_ // 这个头文件包含了 mystl 的函数对象与哈希函数 #include namespace mystl { // 定义一元函数的参数型别和返回值型别 template struct unarg_function { typedef Arg argument_type; typedef Result result_type; }; // 定义二元函数的参数型别的返回值型别 template struct binary_function { typedef Arg1 first_argument_type; typedef Arg2 second_argument_type; typedef Result result_type; }; // 函数对象：加法 template struct plus :public binary_function { T operator()(const T& x, const T& y) const { return x + y; } }; // 函数对象：减法 template struct minus :public binary_function { T operator()(const T& x, const T& y) const { return x - y; } }; // 函数对象：乘法 template struct multiplies :public binary_function { T operator()(const T& x, const T& y) const { return x * y; } }; // 函数对象：除法 template struct divides :public binary_function { T operator()(const T& x, const T& y) const { return x / y; } }; // 函数对象：模取 template struct modulus :public binary_function { T operator()(const T& x, const T& y) const { return x % y; } }; // 函数对象：否定 template struct negate :public unarg_function { T operator()(const T& x) const { return -x; } }; // 加法的证同元素 template T identity_element(plus) { return T(0); } // 乘法的证同元素 template T identity_element(multiplies) { return T(1); } // 函数对象：等于 template struct equal_to :public binary_function { bool operator()(const T& x, const T& y) const { return x == y; } }; // 函数对象：不等于 template struct not_equal_to :public binary_function { bool operator()(const T& x, const T& y) const { return x != y; } }; // 函数对象：大于 template struct greater :public binary_function { bool operator()(const T& x, const T& y) const { return x > y; } }; // 函数对象：小于 template struct less :public binary_function { bool operator()(const T& x, const T& y) const { return x < y; } }; // 函数对象：大于等于 template struct greater_equal :public binary_function { bool operator()(const T& x, const T& y) const { return x >= y; } }; // 函数对象：小于等于 template struct less_equal :public binary_function { bool operator()(const T& x, const T& y) const { return x <= y; } }; // 函数对象：逻辑与 template struct logical_and :public binary_function { bool operator()(const T& x, const T& y) const { return x && y; } }; // 函数对象：逻辑或 template struct logical_or :public binary_function { bool operator()(const T& x, const T& y) const { return x || y; } }; // 函数对象：逻辑非 template struct logical_not :public unarg_function { bool operator()(const T& x) const { return !x; } }; // 证同函数：不会改变元素，返回本身 template struct identity :public unarg_function { const T& operator()(const T& x) const { return x; } }; // 选择函数：接受一个 pair，返回第一个元素 template struct selectfirst :public unarg_function { const typename Pair::first_type& operator()(const Pair& x) const { return x.first; } }; // 选择函数：接受一个 pair，返回第二个元素 template struct selectsecond :public unarg_function { const typename Pair::second_type& operator()(const Pair& x) const { return x.second; } }; // 投射函数：返回第一参数 template struct projectfirst :public binary_function { Arg1 operator()(const Arg1& x, const Arg2&) const { return x; } }; // 投射函数：返回第二参数 template struct projectsecond :public binary_function { Arg2 operator()(const Arg1&, const Arg2& y) const { return y; } }; /*****************************************************************************************/ // 哈希函数对象 // 对于大部分类型，hash function 什么都不做 template struct hash {}; // 针对指针的偏特化版本 template struct hash { size_t operator()(T* p) const noexcept { return reinterpret_cast(p); } }; // 对于整型类型，只是返回原值 #define MYSTL_TRIVIAL_HASH_FCN(Type) \ template <> struct hash \ { \ size_t operator()(Type val) const noexcept \ { return static_cast(val); } \ }; MYSTL_TRIVIAL_HASH_FCN(bool) MYSTL_TRIVIAL_HASH_FCN(char) MYSTL_TRIVIAL_HASH_FCN(signed char) MYSTL_TRIVIAL_HASH_FCN(unsigned char) MYSTL_TRIVIAL_HASH_FCN(wchar_t) MYSTL_TRIVIAL_HASH_FCN(char16_t) MYSTL_TRIVIAL_HASH_FCN(char32_t) MYSTL_TRIVIAL_HASH_FCN(short) MYSTL_TRIVIAL_HASH_FCN(unsigned short) MYSTL_TRIVIAL_HASH_FCN(int) MYSTL_TRIVIAL_HASH_FCN(unsigned int) MYSTL_TRIVIAL_HASH_FCN(long) MYSTL_TRIVIAL_HASH_FCN(unsigned long) MYSTL_TRIVIAL_HASH_FCN(long long) MYSTL_TRIVIAL_HASH_FCN(unsigned long long) #undef MYSTL_TRIVIAL_HASH_FCN // 对于浮点数，逐位哈希 inline size_t bitwise_hash(const unsigned char* first, size_t count) { #if (_MSC_VER && _WIN64) || ((__GNUC__ || __clang__) &&__SIZEOF_POINTER__ == 8) const size_t fnv_offset = 14695981039346656037ull; const size_t fnv_prime = 1099511628211ull; #else const size_t fnv_offset = 2166136261u; const size_t fnv_prime = 16777619u; #endif size_t result = fnv_offset; for (size_t i = 0; i < count; ++i) { result ^= (size_t)first[i]; result *= fnv_prime; } return result; } template <> struct hash { size_t operator()(const float& val) { return val == 0.0f ? 0 : bitwise_hash((const unsigned char*)&val, sizeof(float)); } }; template <> struct hash { size_t operator()(const double& val) { return val == 0.0f ? 0 : bitwise_hash((const unsigned char*)&val, sizeof(double)); } }; template <> struct hash { size_t operator()(const long double& val) { return val == 0.0f ? 0 : bitwise_hash((const unsigned char*)&val, sizeof(long double)); } }; } // namespace mystl #endif // !MYTINYSTL_FUNCTIONAL_H_ ================================================ FILE: MyTinySTL/hashtable.h ================================================ #ifndef MYTINYSTL_HASHTABLE_H_ #define MYTINYSTL_HASHTABLE_H_ // 这个头文件包含了一个模板类 hashtable // hashtable : 哈希表，使用开链法处理冲突 #include #include "algo.h" #include "functional.h" #include "memory.h" #include "vector.h" #include "util.h" #include "exceptdef.h" namespace mystl { // hashtable 的节点定义 template struct hashtable_node { hashtable_node* next; // 指向下一个节点 T value; // 储存实值 hashtable_node() = default; hashtable_node(const T& n) :next(nullptr), value(n) {} hashtable_node(const hashtable_node& node) :next(node.next), value(node.value) {} hashtable_node(hashtable_node&& node) :next(node.next), value(mystl::move(node.value)) { node.next = nullptr; } }; // value traits template struct ht_value_traits_imp { typedef T key_type; typedef T mapped_type; typedef T value_type; template static const key_type& get_key(const Ty& value) { return value; } template static const value_type& get_value(const Ty& value) { return value; } }; template struct ht_value_traits_imp { typedef typename std::remove_cv::type key_type; typedef typename T::second_type mapped_type; typedef T value_type; template static const key_type& get_key(const Ty& value) { return value.first; } template static const value_type& get_value(const Ty& value) { return value; } }; template struct ht_value_traits { static constexpr bool is_map = mystl::is_pair::value; typedef ht_value_traits_imp value_traits_type; typedef typename value_traits_type::key_type key_type; typedef typename value_traits_type::mapped_type mapped_type; typedef typename value_traits_type::value_type value_type; template static const key_type& get_key(const Ty& value) { return value_traits_type::get_key(value); } template static const value_type& get_value(const Ty& value) { return value_traits_type::get_value(value); } }; // forward declaration template class hashtable; template struct ht_iterator; template struct ht_const_iterator; template struct ht_local_iterator; template struct ht_const_local_iterator; // ht_iterator template struct ht_iterator_base :public mystl::iterator { typedef mystl::hashtable hashtable; typedef ht_iterator_base base; typedef mystl::ht_iterator iterator; typedef mystl::ht_const_iterator const_iterator; typedef hashtable_node* node_ptr; typedef hashtable* contain_ptr; typedef const node_ptr const_node_ptr; typedef const contain_ptr const_contain_ptr; typedef size_t size_type; typedef ptrdiff_t difference_type; node_ptr node; // 迭代器当前所指节点 contain_ptr ht; // 保持与容器的连结 ht_iterator_base() = default; bool operator==(const base& rhs) const { return node == rhs.node; } bool operator!=(const base& rhs) const { return node != rhs.node; } }; template struct ht_iterator :public ht_iterator_base { typedef ht_iterator_base base; typedef typename base::hashtable hashtable; typedef typename base::iterator iterator; typedef typename base::const_iterator const_iterator; typedef typename base::node_ptr node_ptr; typedef typename base::contain_ptr contain_ptr; typedef ht_value_traits value_traits; typedef T value_type; typedef value_type* pointer; typedef value_type& reference; using base::node; using base::ht; ht_iterator() = default; ht_iterator(node_ptr n, contain_ptr t) { node = n; ht = t; } ht_iterator(const iterator& rhs) { node = rhs.node; ht = rhs.ht; } ht_iterator(const const_iterator& rhs) { node = rhs.node; ht = rhs.ht; } iterator& operator=(const iterator& rhs) { if (this != &rhs) { node = rhs.node; ht = rhs.ht; } return *this; } iterator& operator=(const const_iterator& rhs) { if (this != &rhs) { node = rhs.node; ht = rhs.ht; } return *this; } // 重载操作符 reference operator*() const { return node->value; } pointer operator->() const { return &(operator*()); } iterator& operator++() { MYSTL_DEBUG(node != nullptr); const node_ptr old = node; node = node->next; if (node == nullptr) { // 如果下一个位置为空，跳到下一个 bucket 的起始处 auto index = ht->hash(value_traits::get_key(old->value)); while (!node && ++index < ht->bucket_size_) node = ht->buckets_[index]; } return *this; } iterator operator++(int) { iterator tmp = *this; ++*this; return tmp; } }; template struct ht_const_iterator :public ht_iterator_base { typedef ht_iterator_base base; typedef typename base::hashtable hashtable; typedef typename base::iterator iterator; typedef typename base::const_iterator const_iterator; typedef typename base::const_node_ptr node_ptr; typedef typename base::const_contain_ptr contain_ptr; typedef ht_value_traits value_traits; typedef T value_type; typedef const value_type* pointer; typedef const value_type& reference; using base::node; using base::ht; ht_const_iterator() = default; ht_const_iterator(node_ptr n, contain_ptr t) { node = n; ht = t; } ht_const_iterator(const iterator& rhs) { node = rhs.node; ht = rhs.ht; } ht_const_iterator(const const_iterator& rhs) { node = rhs.node; ht = rhs.ht; } const_iterator& operator=(const iterator& rhs) { if (this != &rhs) { node = rhs.node; ht = rhs.ht; } return *this; } const_iterator& operator=(const const_iterator& rhs) { if (this != &rhs) { node = rhs.node; ht = rhs.ht; } return *this; } // 重载操作符 reference operator*() const { return node->value; } pointer operator->() const { return &(operator*()); } const_iterator& operator++() { MYSTL_DEBUG(node != nullptr); const node_ptr old = node; node = node->next; if (node == nullptr) { // 如果下一个位置为空，跳到下一个 bucket 的起始处 auto index = ht->hash(value_traits::get_key(old->value)); while (!node && ++index < ht->bucket_size_) { node = ht->buckets_[index]; } } return *this; } const_iterator operator++(int) { const_iterator tmp = *this; ++*this; return tmp; } }; // local iterator template struct ht_local_iterator :public mystl::iterator { typedef T value_type; typedef value_type* pointer; typedef value_type& reference; typedef size_t size_type; typedef ptrdiff_t difference_type; typedef hashtable_node* node_ptr; typedef ht_local_iterator self; typedef ht_local_iterator local_iterator; typedef ht_const_local_iterator const_local_iterator; node_ptr node; ht_local_iterator(node_ptr n) :node(n) { } ht_local_iterator(const local_iterator& rhs) :node(rhs.node) { } ht_local_iterator(const const_local_iterator& rhs) :node(rhs.node) { } reference operator*() const { return node->value; } pointer operator->() const { return &(operator*()); } self& operator++() { MYSTL_DEBUG(node != nullptr); node = node->next; return *this; } self operator++(int) { self tmp(*this); ++*this; return tmp; } bool operator==(const self& other) const { return node == other.node; } bool operator!=(const self& other) const { return node != other.node; } }; template struct ht_const_local_iterator :public mystl::iterator { typedef T value_type; typedef const value_type* pointer; typedef const value_type& reference; typedef size_t size_type; typedef ptrdiff_t difference_type; typedef const hashtable_node* node_ptr; typedef ht_const_local_iterator self; typedef ht_local_iterator local_iterator; typedef ht_const_local_iterator const_local_iterator; node_ptr node; ht_const_local_iterator(node_ptr n) :node(n) { } ht_const_local_iterator(const local_iterator& rhs) :node(rhs.node) { } ht_const_local_iterator(const const_local_iterator& rhs) :node(rhs.node) { } reference operator*() const { return node->value; } pointer operator->() const { return &(operator*()); } self& operator++() { MYSTL_DEBUG(node != nullptr); node = node->next; return *this; } self operator++(int) { self tmp(*this); ++*this; return tmp; } bool operator==(const self& other) const { return node == other.node; } bool operator!=(const self& other) const { return node != other.node; } }; // bucket 使用的大小 #if (_MSC_VER && _WIN64) || ((__GNUC__ || __clang__) &&__SIZEOF_POINTER__ == 8) #define SYSTEM_64 1 #else #define SYSTEM_32 1 #endif #ifdef SYSTEM_64 #define PRIME_NUM 99 // 1. start with p = 101 // 2. p = next_prime(p * 1.7) // 3. if p < (2 << 63), go to step 2, otherwise, go to step 4 // 4. end with p = prev_prime(2 << 63 - 1) static constexpr size_t ht_prime_list[] = { 101ull, 173ull, 263ull, 397ull, 599ull, 907ull, 1361ull, 2053ull, 3083ull, 4637ull, 6959ull, 10453ull, 15683ull, 23531ull, 35311ull, 52967ull, 79451ull, 119179ull, 178781ull, 268189ull, 402299ull, 603457ull, 905189ull, 1357787ull, 2036687ull, 3055043ull, 4582577ull, 6873871ull, 10310819ull, 15466229ull, 23199347ull, 34799021ull, 52198537ull, 78297827ull, 117446801ull, 176170229ull, 264255353ull, 396383041ull, 594574583ull, 891861923ull, 1337792887ull, 2006689337ull, 3010034021ull, 4515051137ull, 6772576709ull, 10158865069ull, 15238297621ull, 22857446471ull, 34286169707ull, 51429254599ull, 77143881917ull, 115715822899ull, 173573734363ull, 260360601547ull, 390540902329ull, 585811353559ull, 878717030339ull, 1318075545511ull, 1977113318311ull, 2965669977497ull, 4448504966249ull, 6672757449409ull, 10009136174239ull, 15013704261371ull, 22520556392057ull, 33780834588157ull, 50671251882247ull, 76006877823377ull, 114010316735089ull, 171015475102649ull, 256523212653977ull, 384784818980971ull, 577177228471507ull, 865765842707309ull, 1298648764060979ull, 1947973146091477ull, 2921959719137273ull, 4382939578705967ull, 6574409368058969ull, 9861614052088471ull, 14792421078132871ull, 22188631617199337ull, 33282947425799017ull, 49924421138698549ull, 74886631708047827ull, 112329947562071807ull, 168494921343107851ull, 252742382014661767ull, 379113573021992729ull, 568670359532989111ull, 853005539299483657ull, 1279508308949225477ull, 1919262463423838231ull, 2878893695135757317ull, 4318340542703636011ull, 6477510814055453699ull, 9716266221083181299ull, 14574399331624771603ull, 18446744073709551557ull }; #else #define PRIME_NUM 44 // 1. start with p = 101 // 2. p = next_prime(p * 1.7) // 3. if p < (2 << 31), go to step 2, otherwise, go to step 4 // 4. end with p = prev_prime(2 << 31 - 1) static constexpr size_t ht_prime_list[] = { 101u, 173u, 263u, 397u, 599u, 907u, 1361u, 2053u, 3083u, 4637u, 6959u, 10453u, 15683u, 23531u, 35311u, 52967u, 79451u, 119179u, 178781u, 268189u, 402299u, 603457u, 905189u, 1357787u, 2036687u, 3055043u, 4582577u, 6873871u, 10310819u, 15466229u, 23199347u, 34799021u, 52198537u, 78297827u, 117446801u, 176170229u, 264255353u, 396383041u, 594574583u, 891861923u, 1337792887u, 2006689337u, 3010034021u, 4294967291u, }; #endif // 找出最接近并大于等于 n 的那个质数 inline size_t ht_next_prime(size_t n) { const size_t* first = ht_prime_list; const size_t* last = ht_prime_list + PRIME_NUM; const size_t* pos = mystl::lower_bound(first, last, n); return pos == last ? *(last - 1) : *pos; } // 模板类 hashtable // 参数一代表数据类型，参数二代表哈希函数，参数三代表键值相等的比较函数 template class hashtable { friend struct mystl::ht_iterator; friend struct mystl::ht_const_iterator; public: // hashtable 的型别定义 typedef ht_value_traits value_traits; typedef typename value_traits::key_type key_type; typedef typename value_traits::mapped_type mapped_type; typedef typename value_traits::value_type value_type; typedef Hash hasher; typedef KeyEqual key_equal; typedef hashtable_node node_type; typedef node_type* node_ptr; typedef mystl::vector bucket_type; typedef mystl::allocator allocator_type; typedef mystl::allocator data_allocator; typedef mystl::allocator node_allocator; typedef typename allocator_type::pointer pointer; typedef typename allocator_type::const_pointer const_pointer; typedef typename allocator_type::reference reference; typedef typename allocator_type::const_reference const_reference; typedef typename allocator_type::size_type size_type; typedef typename allocator_type::difference_type difference_type; typedef mystl::ht_iterator iterator; typedef mystl::ht_const_iterator const_iterator; typedef mystl::ht_local_iterator local_iterator; typedef mystl::ht_const_local_iterator const_local_iterator; allocator_type get_allocator() const { return allocator_type(); } private: // 用以下六个参数来表现 hashtable bucket_type buckets_; size_type bucket_size_; size_type size_; float mlf_; hasher hash_; key_equal equal_; private: bool is_equal(const key_type& key1, const key_type& key2) { return equal_(key1, key2); } bool is_equal(const key_type& key1, const key_type& key2) const { return equal_(key1, key2); } const_iterator M_cit(node_ptr node) const noexcept { return const_iterator(node, const_cast(this)); } iterator M_begin() noexcept { for (size_type n = 0; n < bucket_size_; ++n) { if (buckets_[n]) // 找到第一个有节点的位置就返回 return iterator(buckets_[n], this); } return iterator(nullptr, this); } const_iterator M_begin() const noexcept { for (size_type n = 0; n < bucket_size_; ++n) { if (buckets_[n]) // 找到第一个有节点的位置就返回 return M_cit(buckets_[n]); } return M_cit(nullptr); } public: // 构造、复制、移动、析构函数 explicit hashtable(size_type bucket_count, const Hash& hash = Hash(), const KeyEqual& equal = KeyEqual()) :size_(0), mlf_(1.0f), hash_(hash), equal_(equal) { init(bucket_count); } template ::value, int>::type = 0> hashtable(Iter first, Iter last, size_type bucket_count, const Hash& hash = Hash(), const KeyEqual& equal = KeyEqual()) :size_(mystl::distance(first, last)), mlf_(1.0f), hash_(hash), equal_(equal) { init(mystl::max(bucket_count, static_cast(mystl::distance(first, last)))); } hashtable(const hashtable& rhs) :hash_(rhs.hash_), equal_(rhs.equal_) { copy_init(rhs); } hashtable(hashtable&& rhs) noexcept : bucket_size_(rhs.bucket_size_), size_(rhs.size_), mlf_(rhs.mlf_), hash_(rhs.hash_), equal_(rhs.equal_) { buckets_ = mystl::move(rhs.buckets_); rhs.bucket_size_ = 0; rhs.size_ = 0; rhs.mlf_ = 0.0f; } hashtable& operator=(const hashtable& rhs); hashtable& operator=(hashtable&& rhs) noexcept; ~hashtable() { clear(); } // 迭代器相关操作 iterator begin() noexcept { return M_begin(); } const_iterator begin() const noexcept { return M_begin(); } iterator end() noexcept { return iterator(nullptr, this); } const_iterator end() const noexcept { return M_cit(nullptr); } const_iterator cbegin() const noexcept { return begin(); } const_iterator cend() const noexcept { return end(); } // 容量相关操作 bool empty() const noexcept { return size_ == 0; } size_type size() const noexcept { return size_; } size_type max_size() const noexcept { return static_cast(-1); } // 修改容器相关操作 // emplace / empalce_hint template iterator emplace_multi(Args&& ...args); template pair emplace_unique(Args&& ...args); // [note]: hint 对于 hash_table 其实没有意义，因为即使提供了 hint，也要做一次 hash， // 来确保 hash_table 的性质，所以选择忽略它 template iterator emplace_multi_use_hint(const_iterator /*hint*/, Args&& ...args) { return emplace_multi(mystl::forward(args)...); } template iterator emplace_unique_use_hint(const_iterator /*hint*/, Args&& ...args) { return emplace_unique(mystl::forward(args)...).first; } // insert iterator insert_multi_noresize(const value_type& value); pair insert_unique_noresize(const value_type& value); iterator insert_multi(const value_type& value) { rehash_if_need(1); return insert_multi_noresize(value); } iterator insert_multi(value_type&& value) { return emplace_multi(mystl::move(value)); } pair insert_unique(const value_type& value) { rehash_if_need(1); return insert_unique_noresize(value); } pair insert_unique(value_type&& value) { return emplace_unique(mystl::move(value)); } // [note]: 同 emplace_hint iterator insert_multi_use_hint(const_iterator /*hint*/, const value_type& value) { return insert_multi(value); } iterator insert_multi_use_hint(const_iterator /*hint*/, value_type&& value) { return emplace_multi(mystl::move(value)); } iterator insert_unique_use_hint(const_iterator /*hint*/, const value_type& value) { return insert_unique(value).first; } iterator insert_unique_use_hint(const_iterator /*hint*/, value_type&& value) { return emplace_unique(mystl::move(value)); } template void insert_multi(InputIter first, InputIter last) { copy_insert_multi(first, last, iterator_category(first)); } template void insert_unique(InputIter first, InputIter last) { copy_insert_unique(first, last, iterator_category(first)); } // erase / clear void erase(const_iterator position); void erase(const_iterator first, const_iterator last); size_type erase_multi(const key_type& key); size_type erase_unique(const key_type& key); void clear(); void swap(hashtable& rhs) noexcept; // 查找相关操作 size_type count(const key_type& key) const; iterator find(const key_type& key); const_iterator find(const key_type& key) const; pair equal_range_multi(const key_type& key); pair equal_range_multi(const key_type& key) const; pair equal_range_unique(const key_type& key); pair equal_range_unique(const key_type& key) const; // bucket interface local_iterator begin(size_type n) noexcept { MYSTL_DEBUG(n < size_); return buckets_[n]; } const_local_iterator begin(size_type n) const noexcept { MYSTL_DEBUG(n < size_); return buckets_[n]; } const_local_iterator cbegin(size_type n) const noexcept { MYSTL_DEBUG(n < size_); return buckets_[n]; } local_iterator end(size_type n) noexcept { MYSTL_DEBUG(n < size_); return nullptr; } const_local_iterator end(size_type n) const noexcept { MYSTL_DEBUG(n < size_); return nullptr; } const_local_iterator cend(size_type n) const noexcept { MYSTL_DEBUG(n < size_); return nullptr; } size_type bucket_count() const noexcept { return bucket_size_; } size_type max_bucket_count() const noexcept { return ht_prime_list[PRIME_NUM - 1]; } size_type bucket_size(size_type n) const noexcept; size_type bucket(const key_type& key) const { return hash(key); } // hash policy float load_factor() const noexcept { return bucket_size_ != 0 ? (float)size_ / bucket_size_ : 0.0f; } float max_load_factor() const noexcept { return mlf_; } void max_load_factor(float ml) { THROW_OUT_OF_RANGE_IF(ml != ml || ml < 0, "invalid hash load factor"); mlf_ = ml; } void rehash(size_type count); void reserve(size_type count) { rehash(static_cast((float)count / max_load_factor() + 0.5f)); } hasher hash_fcn() const { return hash_; } key_equal key_eq() const { return equal_; } private: // hashtable 成员函数 // init void init(size_type n); void copy_init(const hashtable& ht); // node template node_ptr create_node(Args&& ...args); void destroy_node(node_ptr n); // hash size_type next_size(size_type n) const; size_type hash(const key_type& key, size_type n) const; size_type hash(const key_type& key) const; void rehash_if_need(size_type n); // insert template void copy_insert_multi(InputIter first, InputIter last, mystl::input_iterator_tag); template void copy_insert_multi(ForwardIter first, ForwardIter last, mystl::forward_iterator_tag); template void copy_insert_unique(InputIter first, InputIter last, mystl::input_iterator_tag); template void copy_insert_unique(ForwardIter first, ForwardIter last, mystl::forward_iterator_tag); // insert node pair insert_node_unique(node_ptr np); iterator insert_node_multi(node_ptr np); // bucket operator void replace_bucket(size_type bucket_count); void erase_bucket(size_type n, node_ptr first, node_ptr last); void erase_bucket(size_type n, node_ptr last); // comparision bool equal_to_multi(const hashtable& other); bool equal_to_unique(const hashtable& other); }; /*****************************************************************************************/ // 复制赋值运算符 template hashtable& hashtable:: operator=(const hashtable& rhs) { if (this != &rhs) { hashtable tmp(rhs); swap(tmp); } return *this; } // 移动赋值运算符 template hashtable& hashtable:: operator=(hashtable&& rhs) noexcept { hashtable tmp(mystl::move(rhs)); swap(tmp); return *this; } // 就地构造元素，键值允许重复 // 强异常安全保证 template template typename hashtable::iterator hashtable:: emplace_multi(Args&& ...args) { auto np = create_node(mystl::forward(args)...); try { if ((float)(size_ + 1) > (float)bucket_size_ * max_load_factor()) rehash(size_ + 1); } catch (...) { destroy_node(np); throw; } return insert_node_multi(np); } // 就地构造元素，键值允许重复 // 强异常安全保证 template template pair::iterator, bool> hashtable:: emplace_unique(Args&& ...args) { auto np = create_node(mystl::forward(args)...); try { if ((float)(size_ + 1) > (float)bucket_size_ * max_load_factor()) rehash(size_ + 1); } catch (...) { destroy_node(np); throw; } return insert_node_unique(np); } // 在不需要重建表格的情况下插入新节点，键值不允许重复 template pair::iterator, bool> hashtable:: insert_unique_noresize(const value_type& value) { const auto n = hash(value_traits::get_key(value)); auto first = buckets_[n]; for (auto cur = first; cur; cur = cur->next) { if (is_equal(value_traits::get_key(cur->value), value_traits::get_key(value))) return mystl::make_pair(iterator(cur, this), false); } // 让新节点成为链表的第一个节点 auto tmp = create_node(value); tmp->next = first; buckets_[n] = tmp; ++size_; return mystl::make_pair(iterator(tmp, this), true); } // 在不需要重建表格的情况下插入新节点，键值允许重复 template typename hashtable::iterator hashtable:: insert_multi_noresize(const value_type& value) { const auto n = hash(value_traits::get_key(value)); auto first = buckets_[n]; auto tmp = create_node(value); for (auto cur = first; cur; cur = cur->next) { if (is_equal(value_traits::get_key(cur->value), value_traits::get_key(value))) { // 如果链表中存在相同键值的节点就马上插入，然后返回 tmp->next = cur->next; cur->next = tmp; ++size_; return iterator(tmp, this); } } // 否则插入在链表头部 tmp->next = first; buckets_[n] = tmp; ++size_; return iterator(tmp, this); } // 删除迭代器所指的节点 template void hashtable:: erase(const_iterator position) { auto p = position.node; if (p) { const auto n = hash(value_traits::get_key(p->value)); auto cur = buckets_[n]; if (cur == p) { // p 位于链表头部 buckets_[n] = cur->next; destroy_node(cur); --size_; } else { auto next = cur->next; while (next) { if (next == p) { cur->next = next->next; destroy_node(next); --size_; break; } else { cur = next; next = cur->next; } } } } } // 删除[first, last)内的节点 template void hashtable:: erase(const_iterator first, const_iterator last) { if (first.node == last.node) return; auto first_bucket = first.node ? hash(value_traits::get_key(first.node->value)) : bucket_size_; auto last_bucket = last.node ? hash(value_traits::get_key(last.node->value)) : bucket_size_; if (first_bucket == last_bucket) { // 如果在 bucket 在同一个位置 erase_bucket(first_bucket, first.node, last.node); } else { erase_bucket(first_bucket, first.node, nullptr); for (auto n = first_bucket + 1; n < last_bucket; ++n) { if(buckets_[n] != nullptr) erase_bucket(n, nullptr); } if (last_bucket != bucket_size_) { erase_bucket(last_bucket, last.node); } } } // 删除键值为 key 的节点 template typename hashtable::size_type hashtable:: erase_multi(const key_type& key) { auto p = equal_range_multi(key); if (p.first.node != nullptr) { erase(p.first, p.second); return mystl::distance(p.first, p.second); } return 0; } template typename hashtable::size_type hashtable:: erase_unique(const key_type& key) { const auto n = hash(key); auto first = buckets_[n]; if (first) { if (is_equal(value_traits::get_key(first->value), key)) { buckets_[n] = first->next; destroy_node(first); --size_; return 1; } else { auto next = first->next; while (next) { if (is_equal(value_traits::get_key(next->value), key)) { first->next = next->next; destroy_node(next); --size_; return 1; } first = next; next = first->next; } } } return 0; } // 清空 hashtable template void hashtable:: clear() { if (size_ != 0) { for (size_type i = 0; i < bucket_size_; ++i) { node_ptr cur = buckets_[i]; while (cur != nullptr) { node_ptr next = cur->next; destroy_node(cur); cur = next; } buckets_[i] = nullptr; } size_ = 0; } } // 在某个 bucket 节点的个数 template typename hashtable::size_type hashtable:: bucket_size(size_type n) const noexcept { size_type result = 0; for (auto cur = buckets_[n]; cur; cur = cur->next) { ++result; } return result; } // 重新对元素进行一遍哈希，插入到新的位置 template void hashtable:: rehash(size_type count) { auto n = ht_next_prime(count); if (n > bucket_size_) { replace_bucket(n); } else { if ((float)size_ / (float)n < max_load_factor() - 0.25f && (float)n < (float)bucket_size_ * 0.75) // worth rehash { replace_bucket(n); } } } // 查找键值为 key 的节点，返回其迭代器 template typename hashtable::iterator hashtable:: find(const key_type& key) { const auto n = hash(key); node_ptr first = buckets_[n]; for (; first && !is_equal(value_traits::get_key(first->value), key); first = first->next) {} return iterator(first, this); } template typename hashtable::const_iterator hashtable:: find(const key_type& key) const { const auto n = hash(key); node_ptr first = buckets_[n]; for (; first && !is_equal(value_traits::get_key(first->value), key); first = first->next) {} return M_cit(first); } // 查找键值为 key 出现的次数 template typename hashtable::size_type hashtable:: count(const key_type& key) const { const auto n = hash(key); size_type result = 0; for (node_ptr cur = buckets_[n]; cur; cur = cur->next) { if (is_equal(value_traits::get_key(cur->value), key)) ++result; } return result; } // 查找与键值 key 相等的区间，返回一个 pair，指向相等区间的首尾 template pair::iterator, typename hashtable::iterator> hashtable:: equal_range_multi(const key_type& key) { const auto n = hash(key); for (node_ptr first = buckets_[n]; first; first = first->next) { if (is_equal(value_traits::get_key(first->value), key)) { // 如果出现相等的键值 for (node_ptr second = first->next; second; second = second->next) { if (!is_equal(value_traits::get_key(second->value), key)) return mystl::make_pair(iterator(first, this), iterator(second, this)); } for (auto m = n + 1; m < bucket_size_; ++m) { // 整个链表都相等，查找下一个链表出现的位置 if (buckets_[m]) return mystl::make_pair(iterator(first, this), iterator(buckets_[m], this)); } return mystl::make_pair(iterator(first, this), end()); } } return mystl::make_pair(end(), end()); } template pair::const_iterator, typename hashtable::const_iterator> hashtable:: equal_range_multi(const key_type& key) const { const auto n = hash(key); for (node_ptr first = buckets_[n]; first; first = first->next) { if (is_equal(value_traits::get_key(first->value), key)) { for (node_ptr second = first->next; second; second = second->next) { if (!is_equal(value_traits::get_key(second->value), key)) return mystl::make_pair(M_cit(first), M_cit(second)); } for (auto m = n + 1; m < bucket_size_; ++m) { // 整个链表都相等，查找下一个链表出现的位置 if (buckets_[m]) return mystl::make_pair(M_cit(first), M_cit(buckets_[m])); } return mystl::make_pair(M_cit(first), cend()); } } return mystl::make_pair(cend(), cend()); } template pair::iterator, typename hashtable::iterator> hashtable:: equal_range_unique(const key_type& key) { const auto n = hash(key); for (node_ptr first = buckets_[n]; first; first = first->next) { if (is_equal(value_traits::get_key(first->value), key)) { if (first->next) return mystl::make_pair(iterator(first, this), iterator(first->next, this)); for (auto m = n + 1; m < bucket_size_; ++m) { // 整个链表都相等，查找下一个链表出现的位置 if (buckets_[m]) return mystl::make_pair(iterator(first, this), iterator(buckets_[m], this)); } return mystl::make_pair(iterator(first, this), end()); } } return mystl::make_pair(end(), end()); } template pair::const_iterator, typename hashtable::const_iterator> hashtable:: equal_range_unique(const key_type& key) const { const auto n = hash(key); for (node_ptr first = buckets_[n]; first; first = first->next) { if (is_equal(value_traits::get_key(first->value), key)) { if (first->next) return mystl::make_pair(M_cit(first), M_cit(first->next)); for (auto m = n + 1; m < bucket_size_; ++m) { // 整个链表都相等，查找下一个链表出现的位置 if (buckets_[m]) return mystl::make_pair(M_cit(first), M_cit(buckets_[m])); } return mystl::make_pair(M_cit(first), cend()); } } return mystl::make_pair(cend(), cend()); } // 交换 hashtable template void hashtable:: swap(hashtable& rhs) noexcept { if (this != &rhs) { buckets_.swap(rhs.buckets_); mystl::swap(bucket_size_, rhs.bucket_size_); mystl::swap(size_, rhs.size_); mystl::swap(mlf_, rhs.mlf_); mystl::swap(hash_, rhs.hash_); mystl::swap(equal_, rhs.equal_); } } /****************************************************************************************/ // helper function // init 函数 template void hashtable:: init(size_type n) { const auto bucket_nums = next_size(n); try { buckets_.reserve(bucket_nums); buckets_.assign(bucket_nums, nullptr); } catch (...) { bucket_size_ = 0; size_ = 0; throw; } bucket_size_ = buckets_.size(); } // copy_init 函数 template void hashtable:: copy_init(const hashtable& ht) { bucket_size_ = 0; buckets_.reserve(ht.bucket_size_); buckets_.assign(ht.bucket_size_, nullptr); try { for (size_type i = 0; i < ht.bucket_size_; ++i) { node_ptr cur = ht.buckets_[i]; if (cur) { // 如果某 bucket 存在链表 auto copy = create_node(cur->value); buckets_[i] = copy; for (auto next = cur->next; next; cur = next, next = cur->next) { //复制链表 copy->next = create_node(next->value); copy = copy->next; } copy->next = nullptr; } } bucket_size_ = ht.bucket_size_; mlf_ = ht.mlf_; size_ = ht.size_; } catch (...) { clear(); } } // create_node 函数 template template typename hashtable::node_ptr hashtable:: create_node(Args&& ...args) { node_ptr tmp = node_allocator::allocate(1); try { data_allocator::construct(mystl::address_of(tmp->value), mystl::forward(args)...); tmp->next = nullptr; } catch (...) { node_allocator::deallocate(tmp); throw; } return tmp; } // destroy_node 函数 template void hashtable:: destroy_node(node_ptr node) { data_allocator::destroy(mystl::address_of(node->value)); node_allocator::deallocate(node); node = nullptr; } // next_size 函数 template typename hashtable::size_type hashtable::next_size(size_type n) const { return ht_next_prime(n); } // hash 函数 template typename hashtable::size_type hashtable:: hash(const key_type& key, size_type n) const { return hash_(key) % n; } template typename hashtable::size_type hashtable:: hash(const key_type& key) const { return hash_(key) % bucket_size_; } // rehash_if_need 函数 template void hashtable:: rehash_if_need(size_type n) { if (static_cast(size_ + n) > (float)bucket_size_ * max_load_factor()) rehash(size_ + n); } // copy_insert template template void hashtable:: copy_insert_multi(InputIter first, InputIter last, mystl::input_iterator_tag) { rehash_if_need(mystl::distance(first, last)); for (; first != last; ++first) insert_multi_noresize(*first); } template template void hashtable:: copy_insert_multi(ForwardIter first, ForwardIter last, mystl::forward_iterator_tag) { size_type n = mystl::distance(first, last); rehash_if_need(n); for (; n > 0; --n, ++first) insert_multi_noresize(*first); } template template void hashtable:: copy_insert_unique(InputIter first, InputIter last, mystl::input_iterator_tag) { rehash_if_need(mystl::distance(first, last)); for (; first != last; ++first) insert_unique_noresize(*first); } template template void hashtable:: copy_insert_unique(ForwardIter first, ForwardIter last, mystl::forward_iterator_tag) { size_type n = mystl::distance(first, last); rehash_if_need(n); for (; n > 0; --n, ++first) insert_unique_noresize(*first); } // insert_node 函数 template typename hashtable::iterator hashtable:: insert_node_multi(node_ptr np) { const auto n = hash(value_traits::get_key(np->value)); auto cur = buckets_[n]; if (cur == nullptr) { buckets_[n] = np; ++size_; return iterator(np, this); } for (; cur; cur = cur->next) { if (is_equal(value_traits::get_key(cur->value), value_traits::get_key(np->value))) { np->next = cur->next; cur->next = np; ++size_; return iterator(np, this); } } np->next = buckets_[n]; buckets_[n] = np; ++size_; return iterator(np, this); } // insert_node_unique 函数 template pair::iterator, bool> hashtable:: insert_node_unique(node_ptr np) { const auto n = hash(value_traits::get_key(np->value)); auto cur = buckets_[n]; if (cur == nullptr) { buckets_[n] = np; ++size_; return mystl::make_pair(iterator(np, this), true); } for (; cur; cur = cur->next) { if (is_equal(value_traits::get_key(cur->value), value_traits::get_key(np->value))) { return mystl::make_pair(iterator(cur, this), false); } } np->next = buckets_[n]; buckets_[n] = np; ++size_; return mystl::make_pair(iterator(np, this), true); } // replace_bucket 函数 template void hashtable:: replace_bucket(size_type bucket_count) { bucket_type bucket(bucket_count); if (size_ != 0) { for (size_type i = 0; i < bucket_size_; ++i) { for (auto first = buckets_[i]; first; first = first->next) { auto tmp = create_node(first->value); const auto n = hash(value_traits::get_key(first->value), bucket_count); auto f = bucket[n]; bool is_inserted = false; for (auto cur = f; cur; cur = cur->next) { if (is_equal(value_traits::get_key(cur->value), value_traits::get_key(first->value))) { tmp->next = cur->next; cur->next = tmp; is_inserted = true; break; } } if (!is_inserted) { tmp->next = f; bucket[n] = tmp; } } } } buckets_.swap(bucket); bucket_size_ = buckets_.size(); } // erase_bucket 函数 // 在第 n 个 bucket 内，删除 [first, last) 的节点 template void hashtable:: erase_bucket(size_type n, node_ptr first, node_ptr last) { auto cur = buckets_[n]; if (cur == first) { erase_bucket(n, last); } else { node_ptr next = cur->next; for (; next != first; cur = next, next = cur->next) {} while (next != last) { cur->next = next->next; destroy_node(next); next = cur->next; --size_; } } } // erase_bucket 函数 // 在第 n 个 bucket 内，删除 [buckets_[n], last) 的节点 template void hashtable:: erase_bucket(size_type n, node_ptr last) { auto cur = buckets_[n]; while (cur != last) { auto next = cur->next; destroy_node(cur); cur = next; --size_; } buckets_[n] = last; } // equal_to 函数 template bool hashtable::equal_to_multi(const hashtable& other) { if (size_ != other.size_) return false; for (auto f = begin(), l = end(); f != l;) { auto p1 = equal_range_multi(value_traits::get_key(*f)); auto p2 = other.equal_range_multi(value_traits::get_key(*f)); if (mystl::distance(p1.first, p1.last) != mystl::distance(p2.first, p2.last) || !mystl::is_permutation(p1.first, p2.last, p2.first, p2.last)) return false; f = p1.last; } return true; } template bool hashtable::equal_to_unique(const hashtable& other) { if (size_ != other.size_) return false; for (auto f = begin(), l = end(); f != l; ++f) { auto res = other.find(value_traits::get_key(*f)); if (res.node == nullptr || *res != *f) return false; } return true; } // 重载 mystl 的 swap template void swap(hashtable& lhs, hashtable& rhs) noexcept { lhs.swap(rhs); } } // namespace mystl #endif // !MYTINYSTL_HASHTABLE_H_ ================================================ FILE: MyTinySTL/heap_algo.h ================================================ #ifndef MYTINYSTL_HEAP_ALGO_H_ #define MYTINYSTL_HEAP_ALGO_H_ // 这个头文件包含 heap 的四个算法 : push_heap, pop_heap, sort_heap, make_heap #include "iterator.h" namespace mystl { /*****************************************************************************************/ // push_heap // 该函数接受两个迭代器，表示一个 heap 容器的首尾，并且新元素已经插入到底部容器的最尾端，调整 heap /*****************************************************************************************/ template void push_heap_aux(RandomIter first, Distance holeIndex, Distance topIndex, T value) { auto parent = (holeIndex - 1) / 2; while (holeIndex > topIndex && *(first + parent) < value) { // 使用 operator<，所以 heap 为 max-heap *(first + holeIndex) = *(first + parent); holeIndex = parent; parent = (holeIndex - 1) / 2; } *(first + holeIndex) = value; } template void push_heap_d(RandomIter first, RandomIter last, Distance*) { mystl::push_heap_aux(first, (last - first) - 1, static_cast(0), *(last - 1)); } template void push_heap(RandomIter first, RandomIter last) { // 新元素应该已置于底部容器的最尾端 mystl::push_heap_d(first, last, distance_type(first)); } // 重载版本使用函数对象 comp 代替比较操作 template void push_heap_aux(RandomIter first, Distance holeIndex, Distance topIndex, T value, Compared comp) { auto parent = (holeIndex - 1) / 2; while (holeIndex > topIndex && comp(*(first + parent), value)) { *(first + holeIndex) = *(first + parent); holeIndex = parent; parent = (holeIndex - 1) / 2; } *(first + holeIndex) = value; } template void push_heap_d(RandomIter first, RandomIter last, Distance*, Compared comp) { mystl::push_heap_aux(first, (last - first) - 1, static_cast(0), *(last - 1), comp); } template void push_heap(RandomIter first, RandomIter last, Compared comp) { mystl::push_heap_d(first, last, distance_type(first), comp); } /*****************************************************************************************/ // pop_heap // 该函数接受两个迭代器，表示 heap 容器的首尾，将 heap 的根节点取出放到容器尾部，调整 heap /*****************************************************************************************/ template void adjust_heap(RandomIter first, Distance holeIndex, Distance len, T value) { // 先进行下溯(percolate down)过程 auto topIndex = holeIndex; auto rchild = 2 * holeIndex + 2; while (rchild < len) { if (*(first + rchild) < *(first + rchild - 1)) --rchild; *(first + holeIndex) = *(first + rchild); holeIndex = rchild; rchild = 2 * (rchild + 1); } if (rchild == len) { // 如果没有右子节点 *(first + holeIndex) = *(first + (rchild - 1)); holeIndex = rchild - 1; } // 再执行一次上溯(percolate up)过程 mystl::push_heap_aux(first, holeIndex, topIndex, value); } template void pop_heap_aux(RandomIter first, RandomIter last, RandomIter result, T value, Distance*) { // 先将首值调至尾节点，然后调整[first, last - 1)使之重新成为一个 max-heap *result = *first; mystl::adjust_heap(first, static_cast(0), last - first, value); } template void pop_heap(RandomIter first, RandomIter last) { mystl::pop_heap_aux(first, last - 1, last - 1, *(last - 1), distance_type(first)); } // 重载版本使用函数对象 comp 代替比较操作 template void adjust_heap(RandomIter first, Distance holeIndex, Distance len, T value, Compared comp) { // 先进行下溯(percolate down)过程 auto topIndex = holeIndex; auto rchild = 2 * holeIndex + 2; while (rchild < len) { if (comp(*(first + rchild), *(first + rchild - 1))) --rchild; *(first + holeIndex) = *(first + rchild); holeIndex = rchild; rchild = 2 * (rchild + 1); } if (rchild == len) { *(first + holeIndex) = *(first + (rchild - 1)); holeIndex = rchild - 1; } // 再执行一次上溯(percolate up)过程 mystl::push_heap_aux(first, holeIndex, topIndex, value, comp); } template void pop_heap_aux(RandomIter first, RandomIter last, RandomIter result, T value, Distance*, Compared comp) { *result = *first; // 先将尾指设置成首值，即尾指为欲求结果 mystl::adjust_heap(first, static_cast(0), last - first, value, comp); } template void pop_heap(RandomIter first, RandomIter last, Compared comp) { mystl::pop_heap_aux(first, last - 1, last - 1, *(last - 1), distance_type(first), comp); } /*****************************************************************************************/ // sort_heap // 该函数接受两个迭代器，表示 heap 容器的首尾，不断执行 pop_heap 操作，直到首尾最多相差1 /*****************************************************************************************/ template void sort_heap(RandomIter first, RandomIter last) { // 每执行一次 pop_heap，最大的元素都被放到尾部，直到容器最多只有一个元素，完成排序 while (last - first > 1) { mystl::pop_heap(first, last--); } } // 重载版本使用函数对象 comp 代替比较操作 template void sort_heap(RandomIter first, RandomIter last, Compared comp) { while (last - first > 1) { mystl::pop_heap(first, last--, comp); } } /*****************************************************************************************/ // make_heap // 该函数接受两个迭代器，表示 heap 容器的首尾，把容器内的数据变为一个 heap /*****************************************************************************************/ template void make_heap_aux(RandomIter first, RandomIter last, Distance*) { if (last - first < 2) return; auto len = last - first; auto holeIndex = (len - 2) / 2; while (true) { // 重排以 holeIndex 为首的子树 mystl::adjust_heap(first, holeIndex, len, *(first + holeIndex)); if (holeIndex == 0) return; holeIndex--; } } template void make_heap(RandomIter first, RandomIter last) { mystl::make_heap_aux(first, last, distance_type(first));; } // 重载版本使用函数对象 comp 代替比较操作 template void make_heap_aux(RandomIter first, RandomIter last, Distance*, Compared comp) { if (last - first < 2) return; auto len = last - first; auto holeIndex = (len - 2) / 2; while (true) { // 重排以 holeIndex 为首的子树 mystl::adjust_heap(first, holeIndex, len, *(first + holeIndex), comp); if (holeIndex == 0) return; holeIndex--; } } template void make_heap(RandomIter first, RandomIter last, Compared comp) { mystl::make_heap_aux(first, last, distance_type(first), comp); } } // namespace mystl #endif // !MYTINYSTL_HEAP_ALGO_H_ ================================================ FILE: MyTinySTL/iterator.h ================================================ #ifndef MYTINYSTL_ITERATOR_H_ #define MYTINYSTL_ITERATOR_H_ // 这个头文件用于迭代器设计，包含了一些模板结构体与全局函数， #include #include "type_traits.h" namespace mystl { // 五种迭代器类型 struct input_iterator_tag {}; struct output_iterator_tag {}; struct forward_iterator_tag : public input_iterator_tag {}; struct bidirectional_iterator_tag : public forward_iterator_tag {}; struct random_access_iterator_tag : public bidirectional_iterator_tag {}; // iterator 模板 template struct iterator { typedef Category iterator_category; typedef T value_type; typedef Pointer pointer; typedef Reference reference; typedef Distance difference_type; }; // iterator traits template struct has_iterator_cat { private: struct two { char a; char b; }; template static two test(...); template static char test(typename U::iterator_category* = 0); public: static const bool value = sizeof(test(0)) == sizeof(char); }; template struct iterator_traits_impl {}; template struct iterator_traits_impl { typedef typename Iterator::iterator_category iterator_category; typedef typename Iterator::value_type value_type; typedef typename Iterator::pointer pointer; typedef typename Iterator::reference reference; typedef typename Iterator::difference_type difference_type; }; template struct iterator_traits_helper {}; template struct iterator_traits_helper : public iterator_traits_impl::value || std::is_convertible::value> { }; // 萃取迭代器的特性 template struct iterator_traits : public iterator_traits_helper::value> {}; // 针对原生指针的偏特化版本 template struct iterator_traits { typedef random_access_iterator_tag iterator_category; typedef T value_type; typedef T* pointer; typedef T& reference; typedef ptrdiff_t difference_type; }; template struct iterator_traits { typedef random_access_iterator_tag iterator_category; typedef T value_type; typedef const T* pointer; typedef const T& reference; typedef ptrdiff_t difference_type; }; template >::value> struct has_iterator_cat_of : public m_bool_constant::iterator_category, U>::value> { }; // 萃取某种迭代器 template struct has_iterator_cat_of : public m_false_type {}; template struct is_exactly_input_iterator : public m_bool_constant::value && !has_iterator_cat_of::value> {}; template struct is_input_iterator : public has_iterator_cat_of {}; template struct is_output_iterator : public has_iterator_cat_of {}; template struct is_forward_iterator : public has_iterator_cat_of {}; template struct is_bidirectional_iterator : public has_iterator_cat_of {}; template struct is_random_access_iterator : public has_iterator_cat_of {}; template struct is_iterator : public m_bool_constant::value || is_output_iterator::value> { }; // 萃取某个迭代器的 category template typename iterator_traits::iterator_category iterator_category(const Iterator&) { typedef typename iterator_traits::iterator_category Category; return Category(); } // 萃取某个迭代器的 distance_type template typename iterator_traits::difference_type* distance_type(const Iterator&) { return static_cast::difference_type*>(0); } // 萃取某个迭代器的 value_type template typename iterator_traits::value_type* value_type(const Iterator&) { return static_cast::value_type*>(0); } // 以下函数用于计算迭代器间的距离 // distance 的 input_iterator_tag 的版本 template typename iterator_traits::difference_type distance_dispatch(InputIterator first, InputIterator last, input_iterator_tag) { typename iterator_traits::difference_type n = 0; while (first != last) { ++first; ++n; } return n; } // distance 的 random_access_iterator_tag 的版本 template typename iterator_traits::difference_type distance_dispatch(RandomIter first, RandomIter last, random_access_iterator_tag) { return last - first; } template typename iterator_traits::difference_type distance(InputIterator first, InputIterator last) { return distance_dispatch(first, last, iterator_category(first)); } // 以下函数用于让迭代器前进 n 个距离 // advance 的 input_iterator_tag 的版本 template void advance_dispatch(InputIterator& i, Distance n, input_iterator_tag) { while (n--) ++i; } // advance 的 bidirectional_iterator_tag 的版本 template void advance_dispatch(BidirectionalIterator& i, Distance n, bidirectional_iterator_tag) { if (n >= 0) while (n--) ++i; else while (n++) --i; } // advance 的 random_access_iterator_tag 的版本 template void advance_dispatch(RandomIter& i, Distance n, random_access_iterator_tag) { i += n; } template void advance(InputIterator& i, Distance n) { advance_dispatch(i, n, iterator_category(i)); } /*****************************************************************************************/ // 模板类 : reverse_iterator // 代表反向迭代器，使前进为后退，后退为前进 template class reverse_iterator { private: Iterator current; // 记录对应的正向迭代器 public: // 反向迭代器的五种相应型别 typedef typename iterator_traits::iterator_category iterator_category; typedef typename iterator_traits::value_type value_type; typedef typename iterator_traits::difference_type difference_type; typedef typename iterator_traits::pointer pointer; typedef typename iterator_traits::reference reference; typedef Iterator iterator_type; typedef reverse_iterator self; public: // 构造函数 reverse_iterator() {} explicit reverse_iterator(iterator_type i) :current(i) {} reverse_iterator(const self& rhs) :current(rhs.current) {} public: // 取出对应的正向迭代器 iterator_type base() const { return current; } // 重载操作符 reference operator*() const { // 实际对应正向迭代器的前一个位置 auto tmp = current; return *--tmp; } pointer operator->() const { return &(operator*()); } // 前进(++)变为后退(--) self& operator++() { --current; return *this; } self operator++(int) { self tmp = *this; --current; return tmp; } // 后退(--)变为前进(++) self& operator--() { ++current; return *this; } self operator--(int) { self tmp = *this; ++current; return tmp; } self& operator+=(difference_type n) { current -= n; return *this; } self operator+(difference_type n) const { return self(current - n); } self& operator-=(difference_type n) { current += n; return *this; } self operator-(difference_type n) const { return self(current + n); } reference operator[](difference_type n) const { return *(*this + n); } }; // 重载 operator- template typename reverse_iterator::difference_type operator-(const reverse_iterator& lhs, const reverse_iterator& rhs) { return rhs.base() - lhs.base(); } // 重载比较操作符 template bool operator==(const reverse_iterator& lhs, const reverse_iterator& rhs) { return lhs.base() == rhs.base(); } template bool operator<(const reverse_iterator& lhs, const reverse_iterator& rhs) { return rhs.base() < lhs.base(); } template bool operator!=(const reverse_iterator& lhs, const reverse_iterator& rhs) { return !(lhs == rhs); } template bool operator>(const reverse_iterator& lhs, const reverse_iterator& rhs) { return rhs < lhs; } template bool operator<=(const reverse_iterator& lhs, const reverse_iterator& rhs) { return !(rhs < lhs); } template bool operator>=(const reverse_iterator& lhs, const reverse_iterator& rhs) { return !(lhs < rhs); } } // namespace mystl #endif // !MYTINYSTL_ITERATOR_H_ ================================================ FILE: MyTinySTL/list.h ================================================ #ifndef MYTINYSTL_LIST_H_ #define MYTINYSTL_LIST_H_ // 这个头文件包含了一个模板类 list // list : 双向链表 // notes: // // 异常保证： // mystl::list 满足基本异常保证，部分函数无异常保证，并对以下等函数做强异常安全保证： // * emplace_front // * emplace_back // * emplace // * push_front // * push_back // * insert #include #include "iterator.h" #include "memory.h" #include "functional.h" #include "util.h" #include "exceptdef.h" namespace mystl { template struct list_node_base; template struct list_node; template struct node_traits { typedef list_node_base* base_ptr; typedef list_node* node_ptr; }; // list 的节点结构 template struct list_node_base { typedef typename node_traits::base_ptr base_ptr; typedef typename node_traits::node_ptr node_ptr; base_ptr prev; // 前一节点 base_ptr next; // 下一节点 list_node_base() = default; node_ptr as_node() { return static_cast(self()); } void unlink() { prev = next = self(); } base_ptr self() { return static_cast(&*this); } }; template struct list_node : public list_node_base { typedef typename node_traits::base_ptr base_ptr; typedef typename node_traits::node_ptr node_ptr; T value; // 数据域 list_node() = default; list_node(const T& v) :value(v) { } list_node(T&& v) :value(mystl::move(v)) { } base_ptr as_base() { return static_cast(&*this); } node_ptr self() { return static_cast(&*this); } }; // list 的迭代器设计 template struct list_iterator : public mystl::iterator { typedef T value_type; typedef T* pointer; typedef T& reference; typedef typename node_traits::base_ptr base_ptr; typedef typename node_traits::node_ptr node_ptr; typedef list_iterator self; base_ptr node_; // 指向当前节点 // 构造函数 list_iterator() = default; list_iterator(base_ptr x) :node_(x) {} list_iterator(node_ptr x) :node_(x->as_base()) {} list_iterator(const list_iterator& rhs) :node_(rhs.node_) {} // 重载操作符 reference operator*() const { return node_->as_node()->value; } pointer operator->() const { return &(operator*()); } self& operator++() { MYSTL_DEBUG(node_ != nullptr); node_ = node_->next; return *this; } self operator++(int) { self tmp = *this; ++*this; return tmp; } self& operator--() { MYSTL_DEBUG(node_ != nullptr); node_ = node_->prev; return *this; } self operator--(int) { self tmp = *this; --*this; return tmp; } // 重载比较操作符 bool operator==(const self& rhs) const { return node_ == rhs.node_; } bool operator!=(const self& rhs) const { return node_ != rhs.node_; } }; template struct list_const_iterator : public iterator { typedef T value_type; typedef const T* pointer; typedef const T& reference; typedef typename node_traits::base_ptr base_ptr; typedef typename node_traits::node_ptr node_ptr; typedef list_const_iterator self; base_ptr node_; list_const_iterator() = default; list_const_iterator(base_ptr x) :node_(x) {} list_const_iterator(node_ptr x) :node_(x->as_base()) {} list_const_iterator(const list_iterator& rhs) :node_(rhs.node_) {} list_const_iterator(const list_const_iterator& rhs) :node_(rhs.node_) {} reference operator*() const { return node_->as_node()->value; } pointer operator->() const { return &(operator*()); } self& operator++() { MYSTL_DEBUG(node_ != nullptr); node_ = node_->next; return *this; } self operator++(int) { self tmp = *this; ++*this; return tmp; } self& operator--() { MYSTL_DEBUG(node_ != nullptr); node_ = node_->prev; return *this; } self operator--(int) { self tmp = *this; --*this; return tmp; } // 重载比较操作符 bool operator==(const self& rhs) const { return node_ == rhs.node_; } bool operator!=(const self& rhs) const { return node_ != rhs.node_; } }; // 模板类: list // 模板参数 T 代表数据类型 template class list { public: // list 的嵌套型别定义 typedef mystl::allocator allocator_type; typedef mystl::allocator data_allocator; typedef mystl::allocator> base_allocator; typedef mystl::allocator> node_allocator; typedef typename allocator_type::value_type value_type; typedef typename allocator_type::pointer pointer; typedef typename allocator_type::const_pointer const_pointer; typedef typename allocator_type::reference reference; typedef typename allocator_type::const_reference const_reference; typedef typename allocator_type::size_type size_type; typedef typename allocator_type::difference_type difference_type; typedef list_iterator iterator; typedef list_const_iterator const_iterator; typedef mystl::reverse_iterator reverse_iterator; typedef mystl::reverse_iterator const_reverse_iterator; typedef typename node_traits::base_ptr base_ptr; typedef typename node_traits::node_ptr node_ptr; allocator_type get_allocator() { return node_allocator(); } private: base_ptr node_; // 指向末尾节点 size_type size_; // 大小 public: // 构造、复制、移动、析构函数 list() { fill_init(0, value_type()); } explicit list(size_type n) { fill_init(n, value_type()); } list(size_type n, const T& value) { fill_init(n, value); } template ::value, int>::type = 0> list(Iter first, Iter last) { copy_init(first, last); } list(std::initializer_list ilist) { copy_init(ilist.begin(), ilist.end()); } list(const list& rhs) { copy_init(rhs.cbegin(), rhs.cend()); } list(list&& rhs) noexcept :node_(rhs.node_), size_(rhs.size_) { rhs.node_ = nullptr; rhs.size_ = 0; } list& operator=(const list& rhs) { if (this != &rhs) { assign(rhs.begin(), rhs.end()); } return *this; } list& operator=(list&& rhs) noexcept { clear(); splice(end(), rhs); return *this; } list& operator=(std::initializer_list ilist) { list tmp(ilist.begin(), ilist.end()); swap(tmp); return *this; } ~list() { if (node_) { clear(); base_allocator::deallocate(node_); node_ = nullptr; size_ = 0; } } public: // 迭代器相关操作 iterator begin() noexcept { return node_->next; } const_iterator begin() const noexcept { return node_->next; } iterator end() noexcept { return node_; } const_iterator end() const noexcept { return node_; } reverse_iterator rbegin() noexcept { return reverse_iterator(end()); } const_reverse_iterator rbegin() const noexcept { return reverse_iterator(end()); } reverse_iterator rend() noexcept { return reverse_iterator(begin()); } const_reverse_iterator rend() const noexcept { return reverse_iterator(begin()); } const_iterator cbegin() const noexcept { return begin(); } const_iterator cend() const noexcept { return end(); } const_reverse_iterator crbegin() const noexcept { return rbegin(); } const_reverse_iterator crend() const noexcept { return rend(); } // 容量相关操作 bool empty() const noexcept { return node_->next == node_; } size_type size() const noexcept { return size_; } size_type max_size() const noexcept { return static_cast(-1); } // 访问元素相关操作 reference front() { MYSTL_DEBUG(!empty()); return *begin(); } const_reference front() const { MYSTL_DEBUG(!empty()); return *begin(); } reference back() { MYSTL_DEBUG(!empty()); return *(--end()); } const_reference back() const { MYSTL_DEBUG(!empty()); return *(--end()); } // 调整容器相关操作 // assign void assign(size_type n, const value_type& value) { fill_assign(n, value); } template ::value, int>::type = 0> void assign(Iter first, Iter last) { copy_assign(first, last); } void assign(std::initializer_list ilist) { copy_assign(ilist.begin(), ilist.end()); } // emplace_front / emplace_back / emplace template void emplace_front(Args&& ...args) { THROW_LENGTH_ERROR_IF(size_ > max_size() - 1, "list's size too big"); auto link_node = create_node(mystl::forward(args)...); link_nodes_at_front(link_node->as_base(), link_node->as_base()); ++size_; } template void emplace_back(Args&& ...args) { THROW_LENGTH_ERROR_IF(size_ > max_size() - 1, "list's size too big"); auto link_node = create_node(mystl::forward(args)...); link_nodes_at_back(link_node->as_base(), link_node->as_base()); ++size_; } template iterator emplace(const_iterator pos, Args&& ...args) { THROW_LENGTH_ERROR_IF(size_ > max_size() - 1, "list's size too big"); auto link_node = create_node(mystl::forward(args)...); link_nodes(pos.node_, link_node->as_base(), link_node->as_base()); ++size_; return iterator(link_node); } // insert iterator insert(const_iterator pos, const value_type& value) { THROW_LENGTH_ERROR_IF(size_ > max_size() - 1, "list's size too big"); auto link_node = create_node(value); ++size_; return link_iter_node(pos, link_node->as_base()); } iterator insert(const_iterator pos, value_type&& value) { THROW_LENGTH_ERROR_IF(size_ > max_size() - 1, "list's size too big"); auto link_node = create_node(mystl::move(value)); ++size_; return link_iter_node(pos, link_node->as_base()); } iterator insert(const_iterator pos, size_type n, const value_type& value) { THROW_LENGTH_ERROR_IF(size_ > max_size() - n, "list's size too big"); return fill_insert(pos, n, value); } template ::value, int>::type = 0> iterator insert(const_iterator pos, Iter first, Iter last) { size_type n = mystl::distance(first, last); THROW_LENGTH_ERROR_IF(size_ > max_size() - n, "list's size too big"); return copy_insert(pos, n, first); } // push_front / push_back void push_front(const value_type& value) { THROW_LENGTH_ERROR_IF(size_ > max_size() - 1, "list's size too big"); auto link_node = create_node(value); link_nodes_at_front(link_node->as_base(), link_node->as_base()); ++size_; } void push_front(value_type&& value) { emplace_front(mystl::move(value)); } void push_back(const value_type& value) { THROW_LENGTH_ERROR_IF(size_ > max_size() - 1, "list's size too big"); auto link_node = create_node(value); link_nodes_at_back(link_node->as_base(), link_node->as_base()); ++size_; } void push_back(value_type&& value) { emplace_back(mystl::move(value)); } // pop_front / pop_back void pop_front() { MYSTL_DEBUG(!empty()); auto n = node_->next; unlink_nodes(n, n); destroy_node(n->as_node()); --size_; } void pop_back() { MYSTL_DEBUG(!empty()); auto n = node_->prev; unlink_nodes(n, n); destroy_node(n->as_node()); --size_; } // erase / clear iterator erase(const_iterator pos); iterator erase(const_iterator first, const_iterator last); void clear(); // resize void resize(size_type new_size) { resize(new_size, value_type()); } void resize(size_type new_size, const value_type& value); void swap(list& rhs) noexcept { mystl::swap(node_, rhs.node_); mystl::swap(size_, rhs.size_); } // list 相关操作 void splice(const_iterator pos, list& other); void splice(const_iterator pos, list& other, const_iterator it); void splice(const_iterator pos, list& other, const_iterator first, const_iterator last); void remove(const value_type& value) { remove_if([&](const value_type& v) {return v == value; }); } template void remove_if(UnaryPredicate pred); void unique() { unique(mystl::equal_to()); } template void unique(BinaryPredicate pred); void merge(list& x) { merge(x, mystl::less()); } template void merge(list& x, Compare comp); void sort() { list_sort(begin(), end(), size(), mystl::less()); } template void sort(Compared comp) { list_sort(begin(), end(), size(), comp); } void reverse(); private: // helper functions // create / destroy node template node_ptr create_node(Args&& ...agrs); void destroy_node(node_ptr p); // initialize void fill_init(size_type n, const value_type& value); template void copy_init(Iter first, Iter last); // link / unlink iterator link_iter_node(const_iterator pos, base_ptr node); void link_nodes(base_ptr p, base_ptr first, base_ptr last); void link_nodes_at_front(base_ptr first, base_ptr last); void link_nodes_at_back(base_ptr first, base_ptr last); void unlink_nodes(base_ptr f, base_ptr l); // assign void fill_assign(size_type n, const value_type& value); template void copy_assign(Iter first, Iter last); // insert iterator fill_insert(const_iterator pos, size_type n, const value_type& value); template iterator copy_insert(const_iterator pos, size_type n, Iter first); // sort template iterator list_sort(iterator first, iterator last, size_type n, Compared comp); }; /*****************************************************************************************/ // 删除 pos 处的元素 template typename list::iterator list::erase(const_iterator pos) { MYSTL_DEBUG(pos != cend()); auto n = pos.node_; auto next = n->next; unlink_nodes(n, n); destroy_node(n->as_node()); --size_; return iterator(next); } // 删除 [first, last) 内的元素 template typename list::iterator list::erase(const_iterator first, const_iterator last) { if (first != last) { unlink_nodes(first.node_, last.node_->prev); while (first != last) { auto cur = first.node_; ++first; destroy_node(cur->as_node()); --size_; } } return iterator(last.node_); } // 清空 list template void list::clear() { if (size_ != 0) { auto cur = node_->next; for (base_ptr next = cur->next; cur != node_; cur = next, next = cur->next) { destroy_node(cur->as_node()); } node_->unlink(); size_ = 0; } } // 重置容器大小 template void list::resize(size_type new_size, const value_type& value) { auto i = begin(); size_type len = 0; while (i != end() && len < new_size) { ++i; ++len; } if (len == new_size) { erase(i, node_); } else { insert(node_, new_size - len, value); } } // 将 list x 接合于 pos 之前 template void list::splice(const_iterator pos, list& x) { MYSTL_DEBUG(this != &x); if (!x.empty()) { THROW_LENGTH_ERROR_IF(size_ > max_size() - x.size_, "list's size too big"); auto f = x.node_->next; auto l = x.node_->prev; x.unlink_nodes(f, l); link_nodes(pos.node_, f, l); size_ += x.size_; x.size_ = 0; } } // 将 it 所指的节点接合于 pos 之前 template void list::splice(const_iterator pos, list& x, const_iterator it) { if (pos.node_ != it.node_ && pos.node_ != it.node_->next) { THROW_LENGTH_ERROR_IF(size_ > max_size() - 1, "list's size too big"); auto f = it.node_; x.unlink_nodes(f, f); link_nodes(pos.node_, f, f); ++size_; --x.size_; } } // 将 list x 的 [first, last) 内的节点接合于 pos 之前 template void list::splice(const_iterator pos, list& x, const_iterator first, const_iterator last) { if (first != last && this != &x) { size_type n = mystl::distance(first, last); THROW_LENGTH_ERROR_IF(size_ > max_size() - n, "list's size too big"); auto f = first.node_; auto l = last.node_->prev; x.unlink_nodes(f, l); link_nodes(pos.node_, f, l); size_ += n; x.size_ -= n; } } // 将另一元操作 pred 为 true 的所有元素移除 template template void list::remove_if(UnaryPredicate pred) { auto f = begin(); auto l = end(); for (auto next = f; f != l; f = next) { ++next; if (pred(*f)) { erase(f); } } } // 移除 list 中满足 pred 为 true 重复元素 template template void list::unique(BinaryPredicate pred) { auto i = begin(); auto e = end(); auto j = i; ++j; while (j != e) { if (pred(*i, *j)) { erase(j); } else { i = j; } j = i; ++j; } } // 与另一个 list 合并，按照 comp 为 true 的顺序 template template void list::merge(list& x, Compare comp) { if (this != &x) { THROW_LENGTH_ERROR_IF(size_ > max_size() - x.size_, "list's size too big"); auto f1 = begin(); auto l1 = end(); auto f2 = x.begin(); auto l2 = x.end(); while (f1 != l1 && f2 != l2) { if (comp(*f2, *f1)) { // 使 comp 为 true 的一段区间 auto next = f2; ++next; for (; next != l2 && comp(*next, *f1); ++next) ; auto f = f2.node_; auto l = next.node_->prev; f2 = next; // link node x.unlink_nodes(f, l); link_nodes(f1.node_, f, l); ++f1; } else { ++f1; } } // 连接剩余部分 if (f2 != l2) { auto f = f2.node_; auto l = l2.node_->prev; x.unlink_nodes(f, l); link_nodes(l1.node_, f, l); } size_ += x.size_; x.size_ = 0; } } // 将 list 反转 template void list::reverse() { if (size_ <= 1) { return; } auto i = begin(); auto e = end(); while (i.node_ != e.node_) { mystl::swap(i.node_->prev, i.node_->next); i.node_ = i.node_->prev; } mystl::swap(e.node_->prev, e.node_->next); } /*****************************************************************************************/ // helper function // 创建结点 template template typename list::node_ptr list::create_node(Args&& ...args) { node_ptr p = node_allocator::allocate(1); try { data_allocator::construct(mystl::address_of(p->value), mystl::forward(args)...); p->prev = nullptr; p->next = nullptr; } catch (...) { node_allocator::deallocate(p); throw; } return p; } // 销毁结点 template void list::destroy_node(node_ptr p) { data_allocator::destroy(mystl::address_of(p->value)); node_allocator::deallocate(p); } // 用 n 个元素初始化容器 template void list::fill_init(size_type n, const value_type& value) { node_ = base_allocator::allocate(1); node_->unlink(); size_ = n; try { for (; n > 0; --n) { auto node = create_node(value); link_nodes_at_back(node->as_base(), node->as_base()); } } catch (...) { clear(); base_allocator::deallocate(node_); node_ = nullptr; throw; } } // 以 [first, last) 初始化容器 template template void list::copy_init(Iter first, Iter last) { node_ = base_allocator::allocate(1); node_->unlink(); size_type n = mystl::distance(first, last); size_ = n; try { for (; n > 0; --n, ++first) { auto node = create_node(*first); link_nodes_at_back(node->as_base(), node->as_base()); } } catch (...) { clear(); base_allocator::deallocate(node_); node_ = nullptr; throw; } } // 在 pos 处连接一个节点 template typename list::iterator list::link_iter_node(const_iterator pos, base_ptr link_node) { if (pos == node_->next) { link_nodes_at_front(link_node, link_node); } else if (pos == node_) { link_nodes_at_back(link_node, link_node); } else { link_nodes(pos.node_, link_node, link_node); } return iterator(link_node); } // 在 pos 处连接 [first, last] 的结点 template void list::link_nodes(base_ptr pos, base_ptr first, base_ptr last) { pos->prev->next = first; first->prev = pos->prev; pos->prev = last; last->next = pos; } // 在头部连接 [first, last] 结点 template void list::link_nodes_at_front(base_ptr first, base_ptr last) { first->prev = node_; last->next = node_->next; last->next->prev = last; node_->next = first; } // 在尾部连接 [first, last] 结点 template void list::link_nodes_at_back(base_ptr first, base_ptr last) { last->next = node_; first->prev = node_->prev; first->prev->next = first; node_->prev = last; } // 容器与 [first, last] 结点断开连接 template void list::unlink_nodes(base_ptr first, base_ptr last) { first->prev->next = last->next; last->next->prev = first->prev; } // 用 n 个元素为容器赋值 template void list::fill_assign(size_type n, const value_type& value) { auto i = begin(); auto e = end(); for (; n > 0 && i != e; --n, ++i) { *i = value; } if (n > 0) { insert(e, n, value); } else { erase(i, e); } } // 复制[f2, l2)为容器赋值 template template void list::copy_assign(Iter f2, Iter l2) { auto f1 = begin(); auto l1 = end(); for (; f1 != l1 && f2 != l2; ++f1, ++f2) { *f1 = *f2; } if (f2 == l2) { erase(f1, l1); } else { insert(l1, f2, l2); } } // 在 pos 处插入 n 个元素 template typename list::iterator list::fill_insert(const_iterator pos, size_type n, const value_type& value) { iterator r(pos.node_); if (n != 0) { const auto add_size = n; auto node = create_node(value); node->prev = nullptr; r = iterator(node); iterator end = r; try { // 前面已经创建了一个节点，还需 n - 1 个 for (--n; n > 0; --n, ++end) { auto next = create_node(value); end.node_->next = next->as_base(); // link node next->prev = end.node_; } size_ += add_size; } catch (...) { auto enode = end.node_; while (true) { auto prev = enode->prev; destroy_node(enode->as_node()); if (prev == nullptr) break; enode = prev; } throw; } link_nodes(pos.node_, r.node_, end.node_); } return r; } // 在 pos 处插入 [first, last) 的元素 template template typename list::iterator list::copy_insert(const_iterator pos, size_type n, Iter first) { iterator r(pos.node_); if (n != 0) { const auto add_size = n; auto node = create_node(*first); node->prev = nullptr; r = iterator(node); iterator end = r; try { for (--n, ++first; n > 0; --n, ++first, ++end) { auto next = create_node(*first); end.node_->next = next->as_base(); // link node next->prev = end.node_; } size_ += add_size; } catch (...) { auto enode = end.node_; while (true) { auto prev = enode->prev; destroy_node(enode->as_node()); if (prev == nullptr) break; enode = prev; } throw; } link_nodes(pos.node_, r.node_, end.node_); } return r; } // 对 list 进行归并排序，返回一个迭代器指向区间最小元素的位置 template template typename list::iterator list::list_sort(iterator f1, iterator l2, size_type n, Compared comp) { if (n < 2) return f1; if (n == 2) { if (comp(*--l2, *f1)) { auto ln = l2.node_; unlink_nodes(ln, ln); link_nodes(f1.node_, ln, ln); return l2; } return f1; } auto n2 = n / 2; auto l1 = f1; mystl::advance(l1, n2); auto result = f1 = list_sort(f1, l1, n2, comp); // 前半段的最小位置 auto f2 = l1 = list_sort(l1, l2, n - n2, comp); // 后半段的最小位置 // 把较小的一段区间移到前面 if (comp(*f2, *f1)) { auto m = f2; ++m; for (; m != l2 && comp(*m, *f1); ++m) ; auto f = f2.node_; auto l = m.node_->prev; result = f2; l1 = f2 = m; unlink_nodes(f, l); m = f1; ++m; link_nodes(f1.node_, f, l); f1 = m; } else { ++f1; } // 合并两段有序区间 while (f1 != l1 && f2 != l2) { if (comp(*f2, *f1)) { auto m = f2; ++m; for (; m != l2 && comp(*m, *f1); ++m) ; auto f = f2.node_; auto l = m.node_->prev; if (l1 == f2) l1 = m; f2 = m; unlink_nodes(f, l); m = f1; ++m; link_nodes(f1.node_, f, l); f1 = m; } else { ++f1; } } return result; } // 重载比较操作符 template bool operator==(const list& lhs, const list& rhs) { auto f1 = lhs.cbegin(); auto f2 = rhs.cbegin(); auto l1 = lhs.cend(); auto l2 = rhs.cend(); for (; f1 != l1 && f2 != l2 && *f1 == *f2; ++f1, ++f2) ; return f1 == l1 && f2 == l2; } template bool operator<(const list& lhs, const list& rhs) { return mystl::lexicographical_compare(lhs.cbegin(), lhs.cend(), rhs.cbegin(), rhs.cend()); } template bool operator!=(const list& lhs, const list& rhs) { return !(lhs == rhs); } template bool operator>(const list& lhs, const list& rhs) { return rhs < lhs; } template bool operator<=(const list& lhs, const list& rhs) { return !(rhs < lhs); } template bool operator>=(const list& lhs, const list& rhs) { return !(lhs < rhs); } // 重载 mystl 的 swap template void swap(list& lhs, list& rhs) noexcept { lhs.swap(rhs); } } // namespace mystl #endif // !MYTINYSTL_LIST_H_ ================================================ FILE: MyTinySTL/map.h ================================================ #ifndef MYTINYSTL_MAP_H_ #define MYTINYSTL_MAP_H_ // 这个头文件包含了两个模板类 map 和 multimap // map : 映射，元素具有键值和实值，会根据键值大小自动排序，键值不允许重复 // multimap : 映射，元素具有键值和实值，会根据键值大小自动排序，键值允许重复 // notes: // // 异常保证： // mystl::map / mystl::multimap 满足基本异常保证，对以下等函数做强异常安全保证： // * emplace // * emplace_hint // * insert #include "rb_tree.h" namespace mystl { // 模板类 map，键值不允许重复 // 参数一代表键值类型，参数二代表实值类型，参数三代表键值的比较方式，缺省使用 mystl::less template > class map { public: // map 的嵌套型别定义 typedef Key key_type; typedef T mapped_type; typedef mystl::pair value_type; typedef Compare key_compare; // 定义一个 functor，用来进行元素比较 class value_compare : public binary_function { friend class map; private: Compare comp; value_compare(Compare c) : comp(c) {} public: bool operator()(const value_type& lhs, const value_type& rhs) const { return comp(lhs.first, rhs.first); // 比较键值的大小 } }; private: // 以 mystl::rb_tree 作为底层机制 typedef mystl::rb_tree base_type; base_type tree_; public: // 使用 rb_tree 的型别 typedef typename base_type::node_type node_type; typedef typename base_type::pointer pointer; typedef typename base_type::const_pointer const_pointer; typedef typename base_type::reference reference; typedef typename base_type::const_reference const_reference; typedef typename base_type::iterator iterator; typedef typename base_type::const_iterator const_iterator; typedef typename base_type::reverse_iterator reverse_iterator; typedef typename base_type::const_reverse_iterator const_reverse_iterator; typedef typename base_type::size_type size_type; typedef typename base_type::difference_type difference_type; typedef typename base_type::allocator_type allocator_type; public: // 构造、复制、移动、赋值函数 map() = default; template map(InputIterator first, InputIterator last) :tree_() { tree_.insert_unique(first, last); } map(std::initializer_list ilist) :tree_() { tree_.insert_unique(ilist.begin(), ilist.end()); } map(const map& rhs) :tree_(rhs.tree_) { } map(map&& rhs) noexcept :tree_(mystl::move(rhs.tree_)) { } map& operator=(const map& rhs) { tree_ = rhs.tree_; return *this; } map& operator=(map&& rhs) { tree_ = mystl::move(rhs.tree_); return *this; } map& operator=(std::initializer_list ilist) { tree_.clear(); tree_.insert_unique(ilist.begin(), ilist.end()); return *this; } // 相关接口 key_compare key_comp() const { return tree_.key_comp(); } value_compare value_comp() const { return value_compare(tree_.key_comp()); } allocator_type get_allocator() const { return tree_.get_allocator(); } // 迭代器相关 iterator begin() noexcept { return tree_.begin(); } const_iterator begin() const noexcept { return tree_.begin(); } iterator end() noexcept { return tree_.end(); } const_iterator end() const noexcept { return tree_.end(); } reverse_iterator rbegin() noexcept { return reverse_iterator(end()); } const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); } reverse_iterator rend() noexcept { return reverse_iterator(begin()); } const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); } const_iterator cbegin() const noexcept { return begin(); } const_iterator cend() const noexcept { return end(); } const_reverse_iterator crbegin() const noexcept { return rbegin(); } const_reverse_iterator crend() const noexcept { return rend(); } // 容量相关 bool empty() const noexcept { return tree_.empty(); } size_type size() const noexcept { return tree_.size(); } size_type max_size() const noexcept { return tree_.max_size(); } // 访问元素相关 // 若键值不存在，at 会抛出一个异常 mapped_type& at(const key_type& key) { iterator it = lower_bound(key); // it->first >= key THROW_OUT_OF_RANGE_IF(it == end() || key_comp()(it->first, key), "map no such element exists"); return it->second; } const mapped_type& at(const key_type& key) const { const_iterator it = lower_bound(key); // it->first >= key THROW_OUT_OF_RANGE_IF(it == end() || key_comp()(it->first, key), "map no such element exists"); return it->second; } mapped_type& operator[](const key_type& key) { iterator it = lower_bound(key); // it->first >= key if (it == end() || key_comp()(key, it->first)) it = emplace_hint(it, key, T{}); return it->second; } mapped_type& operator[](key_type&& key) { iterator it = lower_bound(key); // it->first >= key if (it == end() || key_comp()(key, it->first)) it = emplace_hint(it, mystl::move(key), T{}); return it->second; } // 插入删除相关 template pair emplace(Args&& ...args) { return tree_.emplace_unique(mystl::forward(args)...); } template iterator emplace_hint(iterator hint, Args&& ...args) { return tree_.emplace_unique_use_hint(hint, mystl::forward(args)...); } pair insert(const value_type& value) { return tree_.insert_unique(value); } pair insert(value_type&& value) { return tree_.insert_unique(mystl::move(value)); } iterator insert(iterator hint, const value_type& value) { return tree_.insert_unique(hint, value); } iterator insert(iterator hint, value_type&& value) { return tree_.insert_unique(hint, mystl::move(value)); } template void insert(InputIterator first, InputIterator last) { tree_.insert_unique(first, last); } void erase(iterator position) { tree_.erase(position); } size_type erase(const key_type& key) { return tree_.erase_unique(key); } void erase(iterator first, iterator last) { tree_.erase(first, last); } void clear() { tree_.clear(); } // map 相关操作 iterator find(const key_type& key) { return tree_.find(key); } const_iterator find(const key_type& key) const { return tree_.find(key); } size_type count(const key_type& key) const { return tree_.count_unique(key); } iterator lower_bound(const key_type& key) { return tree_.lower_bound(key); } const_iterator lower_bound(const key_type& key) const { return tree_.lower_bound(key); } iterator upper_bound(const key_type& key) { return tree_.upper_bound(key); } const_iterator upper_bound(const key_type& key) const { return tree_.upper_bound(key); } pair equal_range(const key_type& key) { return tree_.equal_range_unique(key); } pair equal_range(const key_type& key) const { return tree_.equal_range_unique(key); } void swap(map& rhs) noexcept { tree_.swap(rhs.tree_); } public: friend bool operator==(const map& lhs, const map& rhs) { return lhs.tree_ == rhs.tree_; } friend bool operator< (const map& lhs, const map& rhs) { return lhs.tree_ < rhs.tree_; } }; // 重载比较操作符 template bool operator==(const map& lhs, const map& rhs) { return lhs == rhs; } template bool operator<(const map& lhs, const map& rhs) { return lhs < rhs; } template bool operator!=(const map& lhs, const map& rhs) { return !(lhs == rhs); } template bool operator>(const map& lhs, const map& rhs) { return rhs < lhs; } template bool operator<=(const map& lhs, const map& rhs) { return !(rhs < lhs); } template bool operator>=(const map& lhs, const map& rhs) { return !(lhs < rhs); } // 重载 mystl 的 swap template void swap(map& lhs, map& rhs) noexcept { lhs.swap(rhs); } /*****************************************************************************************/ // 模板类 multimap，键值允许重复 // 参数一代表键值类型，参数二代表实值类型，参数三代表键值的比较方式，缺省使用 mystl::less template > class multimap { public: // multimap 的型别定义 typedef Key key_type; typedef T mapped_type; typedef mystl::pair value_type; typedef Compare key_compare; // 定义一个 functor，用来进行元素比较 class value_compare : public binary_function { friend class multimap; private: Compare comp; value_compare(Compare c) : comp(c) {} public: bool operator()(const value_type& lhs, const value_type& rhs) const { return comp(lhs.first, rhs.first); } }; private: // 用 mystl::rb_tree 作为底层机制 typedef mystl::rb_tree base_type; base_type tree_; public: // 使用 rb_tree 的型别 typedef typename base_type::node_type node_type; typedef typename base_type::pointer pointer; typedef typename base_type::const_pointer const_pointer; typedef typename base_type::reference reference; typedef typename base_type::const_reference const_reference; typedef typename base_type::iterator iterator; typedef typename base_type::const_iterator const_iterator; typedef typename base_type::reverse_iterator reverse_iterator; typedef typename base_type::const_reverse_iterator const_reverse_iterator; typedef typename base_type::size_type size_type; typedef typename base_type::difference_type difference_type; typedef typename base_type::allocator_type allocator_type; public: // 构造、复制、移动函数 multimap() = default; template multimap(InputIterator first, InputIterator last) :tree_() { tree_.insert_multi(first, last); } multimap(std::initializer_list ilist) :tree_() { tree_.insert_multi(ilist.begin(), ilist.end()); } multimap(const multimap& rhs) :tree_(rhs.tree_) { } multimap(multimap&& rhs) noexcept :tree_(mystl::move(rhs.tree_)) { } multimap& operator=(const multimap& rhs) { tree_ = rhs.tree_; return *this; } multimap& operator=(multimap&& rhs) { tree_ = mystl::move(rhs.tree_); return *this; } multimap& operator=(std::initializer_list ilist) { tree_.clear(); tree_.insert_multi(ilist.begin(), ilist.end()); return *this; } // 相关接口 key_compare key_comp() const { return tree_.key_comp(); } value_compare value_comp() const { return value_compare(tree_.key_comp()); } allocator_type get_allocator() const { return tree_.get_allocator(); } // 迭代器相关 iterator begin() noexcept { return tree_.begin(); } const_iterator begin() const noexcept { return tree_.begin(); } iterator end() noexcept { return tree_.end(); } const_iterator end() const noexcept { return tree_.end(); } reverse_iterator rbegin() noexcept { return reverse_iterator(end()); } const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); } reverse_iterator rend() noexcept { return reverse_iterator(begin()); } const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); } const_iterator cbegin() const noexcept { return begin(); } const_iterator cend() const noexcept { return end(); } const_reverse_iterator crbegin() const noexcept { return rbegin(); } const_reverse_iterator crend() const noexcept { return rend(); } // 容量相关 bool empty() const noexcept { return tree_.empty(); } size_type size() const noexcept { return tree_.size(); } size_type max_size() const noexcept { return tree_.max_size(); } // 插入删除操作 template iterator emplace(Args&& ...args) { return tree_.emplace_multi(mystl::forward(args)...); } template iterator emplace_hint(iterator hint, Args&& ...args) { return tree_.emplace_multi_use_hint(hint, mystl::forward(args)...); } iterator insert(const value_type& value) { return tree_.insert_multi(value); } iterator insert(value_type&& value) { return tree_.insert_multi(mystl::move(value)); } iterator insert(iterator hint, const value_type& value) { return tree_.insert_multi(hint, value); } iterator insert(iterator hint, value_type&& value) { return tree_.insert_multi(hint, mystl::move(value)); } template void insert(InputIterator first, InputIterator last) { tree_.insert_multi(first, last); } void erase(iterator position) { tree_.erase(position); } size_type erase(const key_type& key) { return tree_.erase_multi(key); } void erase(iterator first, iterator last) { tree_.erase(first, last); } void clear() { tree_.clear(); } // multimap 相关操作 iterator find(const key_type& key) { return tree_.find(key); } const_iterator find(const key_type& key) const { return tree_.find(key); } size_type count(const key_type& key) const { return tree_.count_multi(key); } iterator lower_bound(const key_type& key) { return tree_.lower_bound(key); } const_iterator lower_bound(const key_type& key) const { return tree_.lower_bound(key); } iterator upper_bound(const key_type& key) { return tree_.upper_bound(key); } const_iterator upper_bound(const key_type& key) const { return tree_.upper_bound(key); } pair equal_range(const key_type& key) { return tree_.equal_range_multi(key); } pair equal_range(const key_type& key) const { return tree_.equal_range_multi(key); } void swap(multimap& rhs) noexcept { tree_.swap(rhs.tree_); } public: friend bool operator==(const multimap& lhs, const multimap& rhs) { return lhs.tree_ == rhs.tree_; } friend bool operator< (const multimap& lhs, const multimap& rhs) { return lhs.tree_ < rhs.tree_; } }; // 重载比较操作符 template bool operator==(const multimap& lhs, const multimap& rhs) { return lhs == rhs; } template bool operator<(const multimap& lhs, const multimap& rhs) { return lhs < rhs; } template bool operator!=(const multimap& lhs, const multimap& rhs) { return !(lhs == rhs); } template bool operator>(const multimap& lhs, const multimap& rhs) { return rhs < lhs; } template bool operator<=(const multimap& lhs, const multimap& rhs) { return !(rhs < lhs); } template bool operator>=(const multimap& lhs, const multimap& rhs) { return !(lhs < rhs); } // 重载 mystl 的 swap template void swap(multimap& lhs, multimap& rhs) noexcept { lhs.swap(rhs); } } // namespace mystl #endif // !MYTINYSTL_MAP_H_ ================================================ FILE: MyTinySTL/memory.h ================================================ #ifndef MYTINYSTL_MEMORY_H_ #define MYTINYSTL_MEMORY_H_ // 这个头文件负责更高级的动态内存管理 // 包含一些基本函数、空间配置器、未初始化的储存空间管理，以及一个模板类 auto_ptr #include #include #include #include "algobase.h" #include "allocator.h" #include "construct.h" #include "uninitialized.h" namespace mystl { // 获取对象地址 template constexpr Tp* address_of(Tp& value) noexcept { return &value; } // 获取 / 释放 临时缓冲区 template pair get_buffer_helper(ptrdiff_t len, T*) { if (len > static_cast(INT_MAX / sizeof(T))) len = INT_MAX / sizeof(T); while (len > 0) { T* tmp = static_cast(malloc(static_cast(len) * sizeof(T))); if (tmp) return pair(tmp, len); len /= 2; // 申请失败时减少 len 的大小 } return pair(nullptr, 0); } template pair get_temporary_buffer(ptrdiff_t len) { return get_buffer_helper(len, static_cast(0)); } template pair get_temporary_buffer(ptrdiff_t len, T*) { return get_buffer_helper(len, static_cast(0)); } template void release_temporary_buffer(T* ptr) { free(ptr); } // -------------------------------------------------------------------------------------- // 类模板 : temporary_buffer // 进行临时缓冲区的申请与释放 template class temporary_buffer { private: ptrdiff_t original_len; // 缓冲区申请的大小 ptrdiff_t len; // 缓冲区实际的大小 T* buffer; // 指向缓冲区的指针 public: // 构造、析构函数 temporary_buffer(ForwardIterator first, ForwardIterator last); ~temporary_buffer() { mystl::destroy(buffer, buffer + len); free(buffer); } public: ptrdiff_t size() const noexcept { return len; } ptrdiff_t requested_size() const noexcept { return original_len; } T* begin() noexcept { return buffer; } T* end() noexcept { return buffer + len; } private: void allocate_buffer(); void initialize_buffer(const T&, std::true_type) {} void initialize_buffer(const T& value, std::false_type) { mystl::uninitialized_fill_n(buffer, len, value); } private: temporary_buffer(const temporary_buffer&); void operator=(const temporary_buffer&); }; // 构造函数 template temporary_buffer:: temporary_buffer(ForwardIterator first, ForwardIterator last) { try { len = mystl::distance(first, last); allocate_buffer(); if (len > 0) { initialize_buffer(*first, std::is_trivially_default_constructible()); } } catch (...) { free(buffer); buffer = nullptr; len = 0; } } // allocate_buffer 函数 template void temporary_buffer::allocate_buffer() { original_len = len; if (len > static_cast(INT_MAX / sizeof(T))) len = INT_MAX / sizeof(T); while (len > 0) { buffer = static_cast(malloc(len * sizeof(T))); if (buffer) break; len /= 2; // 申请失败时减少申请空间大小 } } // -------------------------------------------------------------------------------------- // 模板类: auto_ptr // 一个具有严格对象所有权的小型智能指针 template class auto_ptr { public: typedef T elem_type; private: T* m_ptr; // 实际指针 public: // 构造、复制、析构函数 explicit auto_ptr(T* p = nullptr) :m_ptr(p) {} auto_ptr(auto_ptr& rhs) :m_ptr(rhs.release()) {} template auto_ptr(auto_ptr& rhs) : m_ptr(rhs.release()) {} auto_ptr& operator=(auto_ptr& rhs) { if (this != &rhs) { delete m_ptr; m_ptr = rhs.release(); } return *this; } template auto_ptr& operator=(auto_ptr& rhs) { if (this->get() != rhs.get()) { delete m_ptr; m_ptr = rhs.release(); } return *this; } ~auto_ptr() { delete m_ptr; } public: // 重载 operator* 和 operator-> T& operator*() const { return *m_ptr; } T* operator->() const { return m_ptr; } // 获得指针 T* get() const { return m_ptr; } // 释放指针 T* release() { T* tmp = m_ptr; m_ptr = nullptr; return tmp; } // 重置指针 void reset(T* p = nullptr) { if (m_ptr != p) { delete m_ptr; m_ptr = p; } } }; } // namespace mystl #endif // !MYTINYSTL_MEMORY_H_ ================================================ FILE: MyTinySTL/numeric.h ================================================ #ifndef MYTINYSTL_NUMERIC_H_ #define MYTINYSTL_NUMERIC_H_ // 这个头文件包含了 mystl 的数值算法 #include "iterator.h" namespace mystl { /*****************************************************************************************/ // accumulate // 版本1：以初值 init 对每个元素进行累加 // 版本2：以初值 init 对每个元素进行二元操作 /*****************************************************************************************/ // 版本1 template T accumulate(InputIter first, InputIter last, T init) { for (; first != last; ++first) { init += *first; } return init; } // 版本2 template T accumulate(InputIter first, InputIter last, T init, BinaryOp binary_op) { for (; first != last; ++first) { init = binary_op(init, *first); } return init; } /*****************************************************************************************/ // adjacent_difference // 版本1：计算相邻元素的差值，结果保存到以 result 为起始的区间上 // 版本2：自定义相邻元素的二元操作 /*****************************************************************************************/ // 版本1 template OutputIter adjacent_difference(InputIter first, InputIter last, OutputIter result) { if (first == last) return result; *result = *first; // 记录第一个元素 auto value = *first; while (++first != last) { auto tmp = *first; *++result = tmp - value; value = tmp; } return ++result; } // 版本2 template OutputIter adjacent_difference(InputIter first, InputIter last, OutputIter result, BinaryOp binary_op) { if (first == last) return result; *result = *first; // 记录第一个元素 auto value = *first; while (++first != last) { auto tmp = *first; *++result = binary_op(tmp, value); value = tmp; } return ++result; } /*****************************************************************************************/ // inner_product // 版本1：以 init 为初值，计算两个区间的内积 // 版本2：自定义 operator+ 和 operator* /*****************************************************************************************/ // 版本1 template T inner_product(InputIter1 first1, InputIter1 last1, InputIter2 first2, T init) { for (; first1 != last1; ++first1, ++first2) { init = init + (*first1 * *first2); } return init; } // 版本2 template T inner_product(InputIter1 first1, InputIter1 last1, InputIter2 first2, T init, BinaryOp1 binary_op1, BinaryOp2 binary_op2) { for (; first1 != last1; ++first1, ++first2) { init = binary_op1(init, binary_op2(*first1, *first2)); } return init; } /*****************************************************************************************/ // iota // 填充[first, last)，以 value 为初值开始递增 /*****************************************************************************************/ template void iota(ForwardIter first, ForwardIter last, T value) { while (first != last) { *first++ = value; ++value; } } /*****************************************************************************************/ // partial_sum // 版本1：计算局部累计求和，结果保存到以 result 为起始的区间上 // 版本2：进行局部进行自定义二元操作 /*****************************************************************************************/ template OutputIter partial_sum(InputIter first, InputIter last, OutputIter result) { if (first == last) return result; *result = *first; // 记录第一个元素 auto value = *first; while (++first != last) { value = value + *first; *++result = value; } return ++result; } // 版本2 template OutputIter partial_sum(InputIter first, InputIter last, OutputIter result, BinaryOp binary_op) { if (first == last) return result; *result = *first; //记录第一个元素 auto value = *first; while (++first != last) { value = binary_op(value, *first); *++result = value; } return ++result; } } // namespace mystl #endif // !MYTINYSTL_NUMERIC_H_ ================================================ FILE: MyTinySTL/queue.h ================================================ #ifndef MYTINYSTL_QUEUE_H_ #define MYTINYSTL_QUEUE_H_ // 这个头文件包含了两个模板类 queue 和 priority_queue // queue : 队列 // priority_queue : 优先队列 #include "deque.h" #include "vector.h" #include "functional.h" #include "heap_algo.h" namespace mystl { // 模板类 queue // 参数一代表数据类型，参数二代表底层容器类型，缺省使用 mystl::deque 作为底层容器 template > class queue { public: typedef Container container_type; // 使用底层容器的型别 typedef typename Container::value_type value_type; typedef typename Container::size_type size_type; typedef typename Container::reference reference; typedef typename Container::const_reference const_reference; static_assert(std::is_same::value, "the value_type of Container should be same with T"); private: container_type c_; // 用底层容器表现 queue public: // 构造、复制、移动函数 queue() = default; explicit queue(size_type n) :c_(n) { } queue(size_type n, const value_type& value) :c_(n, value) { } template queue(IIter first, IIter last) :c_(first, last) { } queue(std::initializer_list ilist) :c_(ilist.begin(), ilist.end()) { } queue(const Container& c) :c_(c) { } queue(Container&& c) noexcept(std::is_nothrow_move_constructible::value) :c_(mystl::move(c)) { } queue(const queue& rhs) :c_(rhs.c_) { } queue(queue&& rhs) noexcept(std::is_nothrow_move_constructible::value) :c_(mystl::move(rhs.c_)) { } queue& operator=(const queue& rhs) { c_ = rhs.c_; return *this; } queue& operator=(queue&& rhs) noexcept(std::is_nothrow_move_assignable::value) { c_ = mystl::move(rhs.c_); return *this; } queue& operator=(std::initializer_list ilist) { c_ = ilist; return *this; } ~queue() = default; // 访问元素相关操作 reference front() { return c_.front(); } const_reference front() const { return c_.front(); } reference back() { return c_.back(); } const_reference back() const { return c_.back(); } // 容量相关操作 bool empty() const noexcept { return c_.empty(); } size_type size() const noexcept { return c_.size(); } // 修改容器相关操作 template void emplace(Args&& ...args) { c_.emplace_back(mystl::forward(args)...); } void push(const value_type& value) { c_.push_back(value); } void push(value_type&& value) { c_.emplace_back(mystl::move(value)); } void pop() { c_.pop_front(); } void clear() { while (!empty()) pop(); } void swap(queue& rhs) noexcept(noexcept(mystl::swap(c_, rhs.c_))) { mystl::swap(c_, rhs.c_); } public: friend bool operator==(const queue& lhs, const queue& rhs) { return lhs.c_ == rhs.c_; } friend bool operator< (const queue& lhs, const queue& rhs) { return lhs.c_ < rhs.c_; } }; // 重载比较操作符 template bool operator==(const queue& lhs, const queue& rhs) { return lhs == rhs; } template bool operator!=(const queue& lhs, const queue& rhs) { return !(lhs == rhs); } template bool operator<(const queue& lhs, const queue& rhs) { return lhs < rhs; } template bool operator>(const queue& lhs, const queue& rhs) { return rhs < lhs; } template bool operator<=(const queue& lhs, const queue& rhs) { return !(rhs < lhs); } template bool operator>=(const queue& lhs, const queue& rhs) { return !(lhs < rhs); } // 重载 mystl 的 swap template void swap(queue& lhs, queue& rhs) noexcept(noexcept(lhs.swap(rhs))) { lhs.swap(rhs); } /*****************************************************************************************/ // 模板类 priority_queue // 参数一代表数据类型，参数二代表容器类型，缺省使用 mystl::vector 作为底层容器 // 参数三代表比较权值的方式，缺省使用 mystl::less 作为比较方式 template , class Compare = mystl::less> class priority_queue { public: typedef Container container_type; typedef Compare value_compare; // 使用底层容器的型别 typedef typename Container::value_type value_type; typedef typename Container::size_type size_type; typedef typename Container::reference reference; typedef typename Container::const_reference const_reference; static_assert(std::is_same::value, "the value_type of Container should be same with T"); private: container_type c_; // 用底层容器来表现 priority_queue value_compare comp_; // 权值比较的标准 public: // 构造、复制、移动函数 priority_queue() = default; priority_queue(const Compare& c) :c_(), comp_(c) { } explicit priority_queue(size_type n) :c_(n) { mystl::make_heap(c_.begin(), c_.end(), comp_); } priority_queue(size_type n, const value_type& value) :c_(n, value) { mystl::make_heap(c_.begin(), c_.end(), comp_); } template priority_queue(IIter first, IIter last) :c_(first, last) { mystl::make_heap(c_.begin(), c_.end(), comp_); } priority_queue(std::initializer_list ilist) :c_(ilist) { mystl::make_heap(c_.begin(), c_.end(), comp_); } priority_queue(const Container& s) :c_(s) { mystl::make_heap(c_.begin(), c_.end(), comp_); } priority_queue(Container&& s) :c_(mystl::move(s)) { mystl::make_heap(c_.begin(), c_.end(), comp_); } priority_queue(const priority_queue& rhs) :c_(rhs.c_), comp_(rhs.comp_) { mystl::make_heap(c_.begin(), c_.end(), comp_); } priority_queue(priority_queue&& rhs) :c_(mystl::move(rhs.c_)), comp_(rhs.comp_) { mystl::make_heap(c_.begin(), c_.end(), comp_); } priority_queue& operator=(const priority_queue& rhs) { c_ = rhs.c_; comp_ = rhs.comp_; mystl::make_heap(c_.begin(), c_.end(), comp_); return *this; } priority_queue& operator=(priority_queue&& rhs) { c_ = mystl::move(rhs.c_); comp_ = rhs.comp_; mystl::make_heap(c_.begin(), c_.end(), comp_); return *this; } priority_queue& operator=(std::initializer_list ilist) { c_ = ilist; comp_ = value_compare(); mystl::make_heap(c_.begin(), c_.end(), comp_); return *this; } ~priority_queue() = default; public: // 访问元素相关操作 const_reference top() const { return c_.front(); } // 容量相关操作 bool empty() const noexcept { return c_.empty(); } size_type size() const noexcept { return c_.size(); } // 修改容器相关操作 template void emplace(Args&& ...args) { c_.emplace_back(mystl::forward(args)...); mystl::push_heap(c_.begin(), c_.end(), comp_); } void push(const value_type& value) { c_.push_back(value); mystl::push_heap(c_.begin(), c_.end(), comp_); } void push(value_type&& value) { c_.push_back(mystl::move(value)); mystl::push_heap(c_.begin(), c_.end(), comp_); } void pop() { mystl::pop_heap(c_.begin(), c_.end(), comp_); c_.pop_back(); } void clear() { while (!empty()) pop(); } void swap(priority_queue& rhs) noexcept(noexcept(mystl::swap(c_, rhs.c_)) && noexcept(mystl::swap(comp_, rhs.comp_))) { mystl::swap(c_, rhs.c_); mystl::swap(comp_, rhs.comp_); } public: friend bool operator==(const priority_queue& lhs, const priority_queue& rhs) { return lhs.c_ == rhs.c_; } friend bool operator!=(const priority_queue& lhs, const priority_queue& rhs) { return lhs.c_ != rhs.c_; } }; // 重载比较操作符 template bool operator==(priority_queue& lhs, priority_queue& rhs) { return lhs == rhs; } template bool operator!=(priority_queue& lhs, priority_queue& rhs) { return lhs != rhs; } // 重载 mystl 的 swap template void swap(priority_queue& lhs, priority_queue& rhs) noexcept(noexcept(lhs.swap(rhs))) { lhs.swap(rhs); } } // namespace mystl #endif // !MYTINYSTL_QUEUE_H_ ================================================ FILE: MyTinySTL/rb_tree.h ================================================ #ifndef MYTINYSTL_RB_TREE_H_ #define MYTINYSTL_RB_TREE_H_ // 这个头文件包含一个模板类 rb_tree // rb_tree : 红黑树 #include #include #include "functional.h" #include "iterator.h" #include "memory.h" #include "type_traits.h" #include "exceptdef.h" namespace mystl { // rb tree 节点颜色的类型 typedef bool rb_tree_color_type; static constexpr rb_tree_color_type rb_tree_red = false; static constexpr rb_tree_color_type rb_tree_black = true; // forward declaration template struct rb_tree_node_base; template struct rb_tree_node; template struct rb_tree_iterator; template struct rb_tree_const_iterator; // rb tree value traits template struct rb_tree_value_traits_imp { typedef T key_type; typedef T mapped_type; typedef T value_type; template static const key_type& get_key(const Ty& value) { return value; } template static const value_type& get_value(const Ty& value) { return value; } }; template struct rb_tree_value_traits_imp { typedef typename std::remove_cv::type key_type; typedef typename T::second_type mapped_type; typedef T value_type; template static const key_type& get_key(const Ty& value) { return value.first; } template static const value_type& get_value(const Ty& value) { return value; } }; template struct rb_tree_value_traits { static constexpr bool is_map = mystl::is_pair::value; typedef rb_tree_value_traits_imp value_traits_type; typedef typename value_traits_type::key_type key_type; typedef typename value_traits_type::mapped_type mapped_type; typedef typename value_traits_type::value_type value_type; template static const key_type& get_key(const Ty& value) { return value_traits_type::get_key(value); } template static const value_type& get_value(const Ty& value) { return value_traits_type::get_value(value); } }; // rb tree node traits template struct rb_tree_node_traits { typedef rb_tree_color_type color_type; typedef rb_tree_value_traits value_traits; typedef typename value_traits::key_type key_type; typedef typename value_traits::mapped_type mapped_type; typedef typename value_traits::value_type value_type; typedef rb_tree_node_base* base_ptr; typedef rb_tree_node* node_ptr; }; // rb tree 的节点设计 template struct rb_tree_node_base { typedef rb_tree_color_type color_type; typedef rb_tree_node_base* base_ptr; typedef rb_tree_node* node_ptr; base_ptr parent; // 父节点 base_ptr left; // 左子节点 base_ptr right; // 右子节点 color_type color; // 节点颜色 base_ptr get_base_ptr() { return &*this; } node_ptr get_node_ptr() { return reinterpret_cast(&*this); } node_ptr& get_node_ref() { return reinterpret_cast(*this); } }; template struct rb_tree_node :public rb_tree_node_base { typedef rb_tree_node_base* base_ptr; typedef rb_tree_node* node_ptr; T value; // 节点值 base_ptr get_base_ptr() { return static_cast(&*this); } node_ptr get_node_ptr() { return &*this; } }; // rb tree traits template struct rb_tree_traits { typedef rb_tree_value_traits value_traits; typedef typename value_traits::key_type key_type; typedef typename value_traits::mapped_type mapped_type; typedef typename value_traits::value_type value_type; typedef value_type* pointer; typedef value_type& reference; typedef const value_type* const_pointer; typedef const value_type& const_reference; typedef rb_tree_node_base base_type; typedef rb_tree_node node_type; typedef base_type* base_ptr; typedef node_type* node_ptr; }; // rb tree 的迭代器设计 template struct rb_tree_iterator_base :public mystl::iterator { typedef typename rb_tree_traits::base_ptr base_ptr; base_ptr node; // 指向节点本身 rb_tree_iterator_base() :node(nullptr) {} // 使迭代器前进 void inc() { if (node->right != nullptr) { node = rb_tree_min(node->right); } else { // 如果没有右子节点 auto y = node->parent; while (y->right == node) { node = y; y = y->parent; } if (node->right != y) // 应对“寻找根节点的下一节点，而根节点没有右子节点”的特殊情况 node = y; } } // 使迭代器后退 void dec() { if (node->parent->parent == node && rb_tree_is_red(node)) { // 如果 node 为 header node = node->right; // 指向整棵树的 max 节点 } else if (node->left != nullptr) { node = rb_tree_max(node->left); } else { // 非 header 节点，也无左子节点 auto y = node->parent; while (node == y->left) { node = y; y = y->parent; } node = y; } } bool operator==(const rb_tree_iterator_base& rhs) { return node == rhs.node; } bool operator!=(const rb_tree_iterator_base& rhs) { return node != rhs.node; } }; template struct rb_tree_iterator :public rb_tree_iterator_base { typedef rb_tree_traits tree_traits; typedef typename tree_traits::value_type value_type; typedef typename tree_traits::pointer pointer; typedef typename tree_traits::reference reference; typedef typename tree_traits::base_ptr base_ptr; typedef typename tree_traits::node_ptr node_ptr; typedef rb_tree_iterator iterator; typedef rb_tree_const_iterator const_iterator; typedef iterator self; using rb_tree_iterator_base::node; // 构造函数 rb_tree_iterator() {} rb_tree_iterator(base_ptr x) { node = x; } rb_tree_iterator(node_ptr x) { node = x; } rb_tree_iterator(const iterator& rhs) { node = rhs.node; } rb_tree_iterator(const const_iterator& rhs) { node = rhs.node; } // 重载操作符 reference operator*() const { return node->get_node_ptr()->value; } pointer operator->() const { return &(operator*()); } self& operator++() { this->inc(); return *this; } self operator++(int) { self tmp(*this); this->inc(); return tmp; } self& operator--() { this->dec(); return *this; } self operator--(int) { self tmp(*this); this->dec(); return tmp; } }; template struct rb_tree_const_iterator :public rb_tree_iterator_base { typedef rb_tree_traits tree_traits; typedef typename tree_traits::value_type value_type; typedef typename tree_traits::const_pointer pointer; typedef typename tree_traits::const_reference reference; typedef typename tree_traits::base_ptr base_ptr; typedef typename tree_traits::node_ptr node_ptr; typedef rb_tree_iterator iterator; typedef rb_tree_const_iterator const_iterator; typedef const_iterator self; using rb_tree_iterator_base::node; // 构造函数 rb_tree_const_iterator() {} rb_tree_const_iterator(base_ptr x) { node = x; } rb_tree_const_iterator(node_ptr x) { node = x; } rb_tree_const_iterator(const iterator& rhs) { node = rhs.node; } rb_tree_const_iterator(const const_iterator& rhs) { node = rhs.node; } // 重载操作符 reference operator*() const { return node->get_node_ptr()->value; } pointer operator->() const { return &(operator*()); } self& operator++() { this->inc(); return *this; } self operator++(int) { self tmp(*this); this->inc(); return tmp; } self& operator--() { this->dec(); return *this; } self operator--(int) { self tmp(*this); this->dec(); return tmp; } }; // tree algorithm template NodePtr rb_tree_min(NodePtr x) noexcept { while (x->left != nullptr) x = x->left; return x; } template NodePtr rb_tree_max(NodePtr x) noexcept { while (x->right != nullptr) x = x->right; return x; } template bool rb_tree_is_lchild(NodePtr node) noexcept { return node == node->parent->left; } template bool rb_tree_is_red(NodePtr node) noexcept { return node->color == rb_tree_red; } template void rb_tree_set_black(NodePtr& node) noexcept { node->color = rb_tree_black; } template void rb_tree_set_red(NodePtr& node) noexcept { node->color = rb_tree_red; } template NodePtr rb_tree_next(NodePtr node) noexcept { if (node->right != nullptr) return rb_tree_min(node->right); while (!rb_tree_is_lchild(node)) node = node->parent; return node->parent; } /*---------------------------------------*\ | p p | | / \ / \ | | x d rotate left y d | | / \ ===========> / \ | | a y x c | | / \ / \ | | b c a b | \*---------------------------------------*/ // 左旋，参数一为左旋点，参数二为根节点 template void rb_tree_rotate_left(NodePtr x, NodePtr& root) noexcept { auto y = x->right; // y 为 x 的右子节点 x->right = y->left; if (y->left != nullptr) y->left->parent = x; y->parent = x->parent; if (x == root) { // 如果 x 为根节点，让 y 顶替 x 成为根节点 root = y; } else if (rb_tree_is_lchild(x)) { // 如果 x 是左子节点 x->parent->left = y; } else { // 如果 x 是右子节点 x->parent->right = y; } // 调整 x 与 y 的关系 y->left = x; x->parent = y; } /*----------------------------------------*\ | p p | | / \ / \ | | d x rotate right d y | | / \ ===========> / \ | | y a b x | | / \ / \ | | b c c a | \*----------------------------------------*/ // 右旋，参数一为右旋点，参数二为根节点 template void rb_tree_rotate_right(NodePtr x, NodePtr& root) noexcept { auto y = x->left; x->left = y->right; if (y->right) y->right->parent = x; y->parent = x->parent; if (x == root) { // 如果 x 为根节点，让 y 顶替 x 成为根节点 root = y; } else if (rb_tree_is_lchild(x)) { // 如果 x 是右子节点 x->parent->left = y; } else { // 如果 x 是左子节点 x->parent->right = y; } // 调整 x 与 y 的关系 y->right = x; x->parent = y; } // 插入节点后使 rb tree 重新平衡，参数一为新增节点，参数二为根节点 // // case 1: 新增节点位于根节点，令新增节点为黑 // case 2: 新增节点的父节点为黑，没有破坏平衡，直接返回 // case 3: 父节点和叔叔节点都为红，令父节点和叔叔节点为黑，祖父节点为红， // 然后令祖父节点为当前节点，继续处理 // case 4: 父节点为红，叔叔节点为 NIL 或黑色，父节点为左（右）孩子，当前节点为右（左）孩子， // 让父节点成为当前节点，再以当前节点为支点左（右）旋 // case 5: 父节点为红，叔叔节点为 NIL 或黑色，父节点为左（右）孩子，当前节点为左（右）孩子， // 让父节点变为黑色，祖父节点变为红色，以祖父节点为支点右（左）旋 // // 参考博客: http://blog.csdn.net/v_JULY_v/article/details/6105630 // http://blog.csdn.net/v_JULY_v/article/details/6109153 template void rb_tree_insert_rebalance(NodePtr x, NodePtr& root) noexcept { rb_tree_set_red(x); // 新增节点为红色 while (x != root && rb_tree_is_red(x->parent)) { if (rb_tree_is_lchild(x->parent)) { // 如果父节点是左子节点 auto uncle = x->parent->parent->right; if (uncle != nullptr && rb_tree_is_red(uncle)) { // case 3: 父节点和叔叔节点都为红 rb_tree_set_black(x->parent); rb_tree_set_black(uncle); x = x->parent->parent; rb_tree_set_red(x); } else { // 无叔叔节点或叔叔节点为黑 if (!rb_tree_is_lchild(x)) { // case 4: 当前节点 x 为右子节点 x = x->parent; rb_tree_rotate_left(x, root); } // 都转换成 case 5： 当前节点为左子节点 rb_tree_set_black(x->parent); rb_tree_set_red(x->parent->parent); rb_tree_rotate_right(x->parent->parent, root); break; } } else // 如果父节点是右子节点，对称处理 { auto uncle = x->parent->parent->left; if (uncle != nullptr && rb_tree_is_red(uncle)) { // case 3: 父节点和叔叔节点都为红 rb_tree_set_black(x->parent); rb_tree_set_black(uncle); x = x->parent->parent; rb_tree_set_red(x); // 此时祖父节点为红，可能会破坏红黑树的性质，令当前节点为祖父节点，继续处理 } else { // 无叔叔节点或叔叔节点为黑 if (rb_tree_is_lchild(x)) { // case 4: 当前节点 x 为左子节点 x = x->parent; rb_tree_rotate_right(x, root); } // 都转换成 case 5： 当前节点为左子节点 rb_tree_set_black(x->parent); rb_tree_set_red(x->parent->parent); rb_tree_rotate_left(x->parent->parent, root); break; } } } rb_tree_set_black(root); // 根节点永远为黑 } // 删除节点后使 rb tree 重新平衡，参数一为要删除的节点，参数二为根节点，参数三为最小节点，参数四为最大节点 // // 参考博客: http://blog.csdn.net/v_JULY_v/article/details/6105630 // http://blog.csdn.net/v_JULY_v/article/details/6109153 template NodePtr rb_tree_erase_rebalance(NodePtr z, NodePtr& root, NodePtr& leftmost, NodePtr& rightmost) { // y 是可能的替换节点，指向最终要删除的节点 auto y = (z->left == nullptr || z->right == nullptr) ? z : rb_tree_next(z); // x 是 y 的一个独子节点或 NIL 节点 auto x = y->left != nullptr ? y->left : y->right; // xp 为 x 的父节点 NodePtr xp = nullptr; // y != z 说明 z 有两个非空子节点，此时 y 指向 z 右子树的最左节点，x 指向 y 的右子节点。 // 用 y 顶替 z 的位置，用 x 顶替 y 的位置，最后用 y 指向 z if (y != z) { z->left->parent = y; y->left = z->left; // 如果 y 不是 z 的右子节点，那么 z 的右子节点一定有左孩子 if (y != z->right) { // x 替换 y 的位置 xp = y->parent; if (x != nullptr) x->parent = y->parent; y->parent->left = x; y->right = z->right; z->right->parent = y; } else { xp = y; } // 连接 y 与 z 的父节点 if (root == z) root = y; else if (rb_tree_is_lchild(z)) z->parent->left = y; else z->parent->right = y; y->parent = z->parent; mystl::swap(y->color, z->color); y = z; } // y == z 说明 z 至多只有一个孩子 else { xp = y->parent; if (x) x->parent = y->parent; // 连接 x 与 z 的父节点 if (root == z) root = x; else if (rb_tree_is_lchild(z)) z->parent->left = x; else z->parent->right = x; // 此时 z 有可能是最左节点或最右节点，更新数据 if (leftmost == z) leftmost = x == nullptr ? xp : rb_tree_min(x); if (rightmost == z) rightmost = x == nullptr ? xp : rb_tree_max(x); } // 此时，y 指向要删除的节点，x 为替代节点，从 x 节点开始调整。 // 如果删除的节点为红色，树的性质没有被破坏，否则按照以下情况调整（x 为左子节点为例）： // case 1: 兄弟节点为红色，令父节点为红，兄弟节点为黑，进行左（右）旋，继续处理 // case 2: 兄弟节点为黑色，且两个子节点都为黑色或 NIL，令兄弟节点为红，父节点成为当前节点，继续处理 // case 3: 兄弟节点为黑色，左子节点为红色或 NIL，右子节点为黑色或 NIL， // 令兄弟节点为红，兄弟节点的左子节点为黑，以兄弟节点为支点右（左）旋，继续处理 // case 4: 兄弟节点为黑色，右子节点为红色，令兄弟节点为父节点的颜色，父节点为黑色，兄弟节点的右子节点 // 为黑色，以父节点为支点左（右）旋，树的性质调整完成，算法结束 if (!rb_tree_is_red(y)) { // x 为黑色时，调整，否则直接将 x 变为黑色即可 while (x != root && (x == nullptr || !rb_tree_is_red(x))) { if (x == xp->left) { // 如果 x 为左子节点 auto brother = xp->right; if (rb_tree_is_red(brother)) { // case 1 rb_tree_set_black(brother); rb_tree_set_red(xp); rb_tree_rotate_left(xp, root); brother = xp->right; } // case 1 转为为了 case 2、3、4 中的一种 if ((brother->left == nullptr || !rb_tree_is_red(brother->left)) && (brother->right == nullptr || !rb_tree_is_red(brother->right))) { // case 2 rb_tree_set_red(brother); x = xp; xp = xp->parent; } else { if (brother->right == nullptr || !rb_tree_is_red(brother->right)) { // case 3 if (brother->left != nullptr) rb_tree_set_black(brother->left); rb_tree_set_red(brother); rb_tree_rotate_right(brother, root); brother = xp->right; } // 转为 case 4 brother->color = xp->color; rb_tree_set_black(xp); if (brother->right != nullptr) rb_tree_set_black(brother->right); rb_tree_rotate_left(xp, root); break; } } else // x 为右子节点，对称处理 { auto brother = xp->left; if (rb_tree_is_red(brother)) { // case 1 rb_tree_set_black(brother); rb_tree_set_red(xp); rb_tree_rotate_right(xp, root); brother = xp->left; } if ((brother->left == nullptr || !rb_tree_is_red(brother->left)) && (brother->right == nullptr || !rb_tree_is_red(brother->right))) { // case 2 rb_tree_set_red(brother); x = xp; xp = xp->parent; } else { if (brother->left == nullptr || !rb_tree_is_red(brother->left)) { // case 3 if (brother->right != nullptr) rb_tree_set_black(brother->right); rb_tree_set_red(brother); rb_tree_rotate_left(brother, root); brother = xp->left; } // 转为 case 4 brother->color = xp->color; rb_tree_set_black(xp); if (brother->left != nullptr) rb_tree_set_black(brother->left); rb_tree_rotate_right(xp, root); break; } } } if (x != nullptr) rb_tree_set_black(x); } return y; } // 模板类 rb_tree // 参数一代表数据类型，参数二代表键值比较类型 template class rb_tree { public: // rb_tree 的嵌套型别定义 typedef rb_tree_traits tree_traits; typedef rb_tree_value_traits value_traits; typedef typename tree_traits::base_type base_type; typedef typename tree_traits::base_ptr base_ptr; typedef typename tree_traits::node_type node_type; typedef typename tree_traits::node_ptr node_ptr; typedef typename tree_traits::key_type key_type; typedef typename tree_traits::mapped_type mapped_type; typedef typename tree_traits::value_type value_type; typedef Compare key_compare; typedef mystl::allocator allocator_type; typedef mystl::allocator data_allocator; typedef mystl::allocator base_allocator; typedef mystl::allocator node_allocator; typedef typename allocator_type::pointer pointer; typedef typename allocator_type::const_pointer const_pointer; typedef typename allocator_type::reference reference; typedef typename allocator_type::const_reference const_reference; typedef typename allocator_type::size_type size_type; typedef typename allocator_type::difference_type difference_type; typedef rb_tree_iterator iterator; typedef rb_tree_const_iterator const_iterator; typedef mystl::reverse_iterator reverse_iterator; typedef mystl::reverse_iterator const_reverse_iterator; allocator_type get_allocator() const { return node_allocator(); } key_compare key_comp() const { return key_comp_; } private: // 用以下三个数据表现 rb tree base_ptr header_; // 特殊节点，与根节点互为对方的父节点 size_type node_count_; // 节点数 key_compare key_comp_; // 节点键值比较的准则 private: // 以下三个函数用于取得根节点，最小节点和最大节点 base_ptr& root() const { return header_->parent; } base_ptr& leftmost() const { return header_->left; } base_ptr& rightmost() const { return header_->right; } public: // 构造、复制、析构函数 rb_tree() { rb_tree_init(); } rb_tree(const rb_tree& rhs); rb_tree(rb_tree&& rhs) noexcept; rb_tree& operator=(const rb_tree& rhs); rb_tree& operator=(rb_tree&& rhs); ~rb_tree() { clear(); } public: // 迭代器相关操作 iterator begin() noexcept { return leftmost(); } const_iterator begin() const noexcept { return leftmost(); } iterator end() noexcept { return header_; } const_iterator end() const noexcept { return header_; } reverse_iterator rbegin() noexcept { return reverse_iterator(end()); } const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); } reverse_iterator rend() noexcept { return reverse_iterator(begin()); } const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); } const_iterator cbegin() const noexcept { return begin(); } const_iterator cend() const noexcept { return end(); } const_reverse_iterator crbegin() const noexcept { return rbegin(); } const_reverse_iterator crend() const noexcept { return rend(); } // 容量相关操作 bool empty() const noexcept { return node_count_ == 0; } size_type size() const noexcept { return node_count_; } size_type max_size() const noexcept { return static_cast(-1); } // 插入删除相关操作 // emplace template iterator emplace_multi(Args&& ...args); template mystl::pair emplace_unique(Args&& ...args); template iterator emplace_multi_use_hint(iterator hint, Args&& ...args); template iterator emplace_unique_use_hint(iterator hint, Args&& ...args); // insert iterator insert_multi(const value_type& value); iterator insert_multi(value_type&& value) { return emplace_multi(mystl::move(value)); } iterator insert_multi(iterator hint, const value_type& value) { return emplace_multi_use_hint(hint, value); } iterator insert_multi(iterator hint, value_type&& value) { return emplace_multi_use_hint(hint, mystl::move(value)); } template void insert_multi(InputIterator first, InputIterator last) { size_type n = mystl::distance(first, last); THROW_LENGTH_ERROR_IF(node_count_ > max_size() - n, "rb_tree's size too big"); for (; n > 0; --n, ++first) insert_multi(end(), *first); } mystl::pair insert_unique(const value_type& value); mystl::pair insert_unique(value_type&& value) { return emplace_unique(mystl::move(value)); } iterator insert_unique(iterator hint, const value_type& value) { return emplace_unique_use_hint(hint, value); } iterator insert_unique(iterator hint, value_type&& value) { return emplace_unique_use_hint(hint, mystl::move(value)); } template void insert_unique(InputIterator first, InputIterator last) { size_type n = mystl::distance(first, last); THROW_LENGTH_ERROR_IF(node_count_ > max_size() - n, "rb_tree's size too big"); for (; n > 0; --n, ++first) insert_unique(end(), *first); } // erase iterator erase(iterator hint); size_type erase_multi(const key_type& key); size_type erase_unique(const key_type& key); void erase(iterator first, iterator last); void clear(); // rb_tree 相关操作 iterator find(const key_type& key); const_iterator find(const key_type& key) const; size_type count_multi(const key_type& key) const { auto p = equal_range_multi(key); return static_cast(mystl::distance(p.first, p.second)); } size_type count_unique(const key_type& key) const { return find(key) != end() ? 1 : 0; } iterator lower_bound(const key_type& key); const_iterator lower_bound(const key_type& key) const; iterator upper_bound(const key_type& key); const_iterator upper_bound(const key_type& key) const; mystl::pair equal_range_multi(const key_type& key) { return mystl::pair(lower_bound(key), upper_bound(key)); } mystl::pair equal_range_multi(const key_type& key) const { return mystl::pair(lower_bound(key), upper_bound(key)); } mystl::pair equal_range_unique(const key_type& key) { iterator it = find(key); auto next = it; return it == end() ? mystl::make_pair(it, it) : mystl::make_pair(it, ++next); } mystl::pair equal_range_unique(const key_type& key) const { const_iterator it = find(key); auto next = it; return it == end() ? mystl::make_pair(it, it) : mystl::make_pair(it, ++next); } void swap(rb_tree& rhs) noexcept; private: // node related template node_ptr create_node(Args&&... args); node_ptr clone_node(base_ptr x); void destroy_node(node_ptr p); // init / reset void rb_tree_init(); void reset(); // get insert pos mystl::pair get_insert_multi_pos(const key_type& key); mystl::pair, bool> get_insert_unique_pos(const key_type& key); // insert value / insert node iterator insert_value_at(base_ptr x, const value_type& value, bool add_to_left); iterator insert_node_at(base_ptr x, node_ptr node, bool add_to_left); // insert use hint iterator insert_multi_use_hint(iterator hint, key_type key, node_ptr node); iterator insert_unique_use_hint(iterator hint, key_type key, node_ptr node); // copy tree / erase tree base_ptr copy_from(base_ptr x, base_ptr p); void erase_since(base_ptr x); }; /*****************************************************************************************/ // 复制构造函数 template rb_tree:: rb_tree(const rb_tree& rhs) { rb_tree_init(); if (rhs.node_count_ != 0) { root() = copy_from(rhs.root(), header_); leftmost() = rb_tree_min(root()); rightmost() = rb_tree_max(root()); } node_count_ = rhs.node_count_; key_comp_ = rhs.key_comp_; } // 移动构造函数 template rb_tree:: rb_tree(rb_tree&& rhs) noexcept :header_(mystl::move(rhs.header_)), node_count_(rhs.node_count_), key_comp_(rhs.key_comp_) { rhs.reset(); } // 复制赋值操作符 template rb_tree& rb_tree:: operator=(const rb_tree& rhs) { if (this != &rhs) { clear(); if (rhs.node_count_ != 0) { root() = copy_from(rhs.root(), header_); leftmost() = rb_tree_min(root()); rightmost() = rb_tree_max(root()); } node_count_ = rhs.node_count_; key_comp_ = rhs.key_comp_; } return *this; } // 移动赋值操作符 template rb_tree& rb_tree:: operator=(rb_tree&& rhs) { clear(); header_ = mystl::move(rhs.header_); node_count_ = rhs.node_count_; key_comp_ = rhs.key_comp_; rhs.reset(); return *this; } // 就地插入元素，键值允许重复 template template typename rb_tree::iterator rb_tree:: emplace_multi(Args&& ...args) { THROW_LENGTH_ERROR_IF(node_count_ > max_size() - 1, "rb_tree's size too big"); node_ptr np = create_node(mystl::forward(args)...); auto res = get_insert_multi_pos(value_traits::get_key(np->value)); return insert_node_at(res.first, np, res.second); } // 就地插入元素，键值不允许重复 template template mystl::pair::iterator, bool> rb_tree:: emplace_unique(Args&& ...args) { THROW_LENGTH_ERROR_IF(node_count_ > max_size() - 1, "rb_tree's size too big"); node_ptr np = create_node(mystl::forward(args)...); auto res = get_insert_unique_pos(value_traits::get_key(np->value)); if (res.second) { // 插入成功 return mystl::make_pair(insert_node_at(res.first.first, np, res.first.second), true); } destroy_node(np); return mystl::make_pair(iterator(res.first.first), false); } // 就地插入元素，键值允许重复，当 hint 位置与插入位置接近时，插入操作的时间复杂度可以降低 template template typename rb_tree::iterator rb_tree:: emplace_multi_use_hint(iterator hint, Args&& ...args) { THROW_LENGTH_ERROR_IF(node_count_ > max_size() - 1, "rb_tree's size too big"); node_ptr np = create_node(mystl::forward(args)...); if (node_count_ == 0) { return insert_node_at(header_, np, true); } key_type key = value_traits::get_key(np->value); if (hint == begin()) { // 位于 begin 处 if (key_comp_(key, value_traits::get_key(*hint))) { return insert_node_at(hint.node, np, true); } else { auto pos = get_insert_multi_pos(key); return insert_node_at(pos.first, np, pos.second); } } else if (hint == end()) { // 位于 end 处 if (!key_comp_(key, value_traits::get_key(rightmost()->get_node_ptr()->value))) { return insert_node_at(rightmost(), np, false); } else { auto pos = get_insert_multi_pos(key); return insert_node_at(pos.first, np, pos.second); } } return insert_multi_use_hint(hint, key, np); } // 就地插入元素，键值不允许重复，当 hint 位置与插入位置接近时，插入操作的时间复杂度可以降低 template template typename rb_tree::iterator rb_tree:: emplace_unique_use_hint(iterator hint, Args&& ...args) { THROW_LENGTH_ERROR_IF(node_count_ > max_size() - 1, "rb_tree's size too big"); node_ptr np = create_node(mystl::forward(args)...); if (node_count_ == 0) { return insert_node_at(header_, np, true); } key_type key = value_traits::get_key(np->value); if (hint == begin()) { // 位于 begin 处 if (key_comp_(key, value_traits::get_key(*hint))) { return insert_node_at(hint.node, np, true); } else { auto pos = get_insert_unique_pos(key); if (!pos.second) { destroy_node(np); return pos.first.first; } return insert_node_at(pos.first.first, np, pos.first.second); } } else if (hint == end()) { // 位于 end 处 if (key_comp_(value_traits::get_key(rightmost()->get_node_ptr()->value), key)) { return insert_node_at(rightmost(), np, false); } else { auto pos = get_insert_unique_pos(key); if (!pos.second) { destroy_node(np); return pos.first.first; } return insert_node_at(pos.first.first, np, pos.first.second); } } return insert_unique_use_hint(hint, key, np); } // 插入元素，节点键值允许重复 template typename rb_tree::iterator rb_tree:: insert_multi(const value_type& value) { THROW_LENGTH_ERROR_IF(node_count_ > max_size() - 1, "rb_tree's size too big"); auto res = get_insert_multi_pos(value_traits::get_key(value)); return insert_value_at(res.first, value, res.second); } // 插入新值，节点键值不允许重复，返回一个 pair，若插入成功，pair 的第二参数为 true，否则为 false template mystl::pair::iterator, bool> rb_tree:: insert_unique(const value_type& value) { THROW_LENGTH_ERROR_IF(node_count_ > max_size() - 1, "rb_tree's size too big"); auto res = get_insert_unique_pos(value_traits::get_key(value)); if (res.second) { // 插入成功 return mystl::make_pair(insert_value_at(res.first.first, value, res.first.second), true); } return mystl::make_pair(res.first.first, false); } // 删除 hint 位置的节点 template typename rb_tree::iterator rb_tree:: erase(iterator hint) { auto node = hint.node->get_node_ptr(); iterator next(node); ++next; rb_tree_erase_rebalance(hint.node, root(), leftmost(), rightmost()); destroy_node(node); --node_count_; return next; } // 删除键值等于 key 的元素，返回删除的个数 template typename rb_tree::size_type rb_tree:: erase_multi(const key_type& key) { auto p = equal_range_multi(key); size_type n = mystl::distance(p.first, p.second); erase(p.first, p.second); return n; } // 删除键值等于 key 的元素，返回删除的个数 template typename rb_tree::size_type rb_tree:: erase_unique(const key_type& key) { auto it = find(key); if (it != end()) { erase(it); return 1; } return 0; } // 删除[first, last)区间内的元素 template void rb_tree:: erase(iterator first, iterator last) { if (first == begin() && last == end()) { clear(); } else { while (first != last) erase(first++); } } // 清空 rb tree template void rb_tree:: clear() { if (node_count_ != 0) { erase_since(root()); leftmost() = header_; root() = nullptr; rightmost() = header_; node_count_ = 0; } } // 查找键值为 k 的节点，返回指向它的迭代器 template typename rb_tree::iterator rb_tree:: find(const key_type& key) { auto y = header_; // 最后一个不小于 key 的节点 auto x = root(); while (x != nullptr) { if (!key_comp_(value_traits::get_key(x->get_node_ptr()->value), key)) { // key 小于等于 x 键值，向左走 y = x, x = x->left; } else { // key 大于 x 键值，向右走 x = x->right; } } iterator j = iterator(y); return (j == end() || key_comp_(key, value_traits::get_key(*j))) ? end() : j; } template typename rb_tree::const_iterator rb_tree:: find(const key_type& key) const { auto y = header_; // 最后一个不小于 key 的节点 auto x = root(); while (x != nullptr) { if (!key_comp_(value_traits::get_key(x->get_node_ptr()->value), key)) { // key 小于等于 x 键值，向左走 y = x, x = x->left; } else { // key 大于 x 键值，向右走 x = x->right; } } const_iterator j = const_iterator(y); return (j == end() || key_comp_(key, value_traits::get_key(*j))) ? end() : j; } // 键值不小于 key 的第一个位置 template typename rb_tree::iterator rb_tree:: lower_bound(const key_type& key) { auto y = header_; auto x = root(); while (x != nullptr) { if (!key_comp_(value_traits::get_key(x->get_node_ptr()->value), key)) { // key <= x y = x, x = x->left; } else { x = x->right; } } return iterator(y); } template typename rb_tree::const_iterator rb_tree:: lower_bound(const key_type& key) const { auto y = header_; auto x = root(); while (x != nullptr) { if (!key_comp_(value_traits::get_key(x->get_node_ptr()->value), key)) { // key <= x y = x, x = x->left; } else { x = x->right; } } return const_iterator(y); } // 键值不小于 key 的最后一个位置 template typename rb_tree::iterator rb_tree:: upper_bound(const key_type& key) { auto y = header_; auto x = root(); while (x != nullptr) { if (key_comp_(key, value_traits::get_key(x->get_node_ptr()->value))) { // key < x y = x, x = x->left; } else { x = x->right; } } return iterator(y); } template typename rb_tree::const_iterator rb_tree:: upper_bound(const key_type& key) const { auto y = header_; auto x = root(); while (x != nullptr) { if (key_comp_(key, value_traits::get_key(x->get_node_ptr()->value))) { // key < x y = x, x = x->left; } else { x = x->right; } } return const_iterator(y); } // 交换 rb tree template void rb_tree:: swap(rb_tree& rhs) noexcept { if (this != &rhs) { mystl::swap(header_, rhs.header_); mystl::swap(node_count_, rhs.node_count_); mystl::swap(key_comp_, rhs.key_comp_); } } /*****************************************************************************************/ // helper function // 创建一个结点 template template typename rb_tree::node_ptr rb_tree:: create_node(Args&&... args) { auto tmp = node_allocator::allocate(1); try { data_allocator::construct(mystl::address_of(tmp->value), mystl::forward(args)...); tmp->left = nullptr; tmp->right = nullptr; tmp->parent = nullptr; } catch (...) { node_allocator::deallocate(tmp); throw; } return tmp; } // 复制一个结点 template typename rb_tree::node_ptr rb_tree:: clone_node(base_ptr x) { node_ptr tmp = create_node(x->get_node_ptr()->value); tmp->color = x->color; tmp->left = nullptr; tmp->right = nullptr; return tmp; } // 销毁一个结点 template void rb_tree:: destroy_node(node_ptr p) { data_allocator::destroy(&p->value); node_allocator::deallocate(p); } // 初始化容器 template void rb_tree:: rb_tree_init() { header_ = base_allocator::allocate(1); header_->color = rb_tree_red; // header_ 节点颜色为红，与 root 区分 root() = nullptr; leftmost() = header_; rightmost() = header_; node_count_ = 0; } // reset 函数 template void rb_tree::reset() { header_ = nullptr; node_count_ = 0; } // get_insert_multi_pos 函数 template mystl::pair::base_ptr, bool> rb_tree::get_insert_multi_pos(const key_type& key) { auto x = root(); auto y = header_; bool add_to_left = true; while (x != nullptr) { y = x; add_to_left = key_comp_(key, value_traits::get_key(x->get_node_ptr()->value)); x = add_to_left ? x->left : x->right; } return mystl::make_pair(y, add_to_left); } // get_insert_unique_pos 函数 template mystl::pair::base_ptr, bool>, bool> rb_tree::get_insert_unique_pos(const key_type& key) { // 返回一个 pair，第一个值为一个 pair，包含插入点的父节点和一个 bool 表示是否在左边插入， // 第二个值为一个 bool，表示是否插入成功 auto x = root(); auto y = header_; bool add_to_left = true; // 树为空时也在 header_ 左边插入 while (x != nullptr) { y = x; add_to_left = key_comp_(key, value_traits::get_key(x->get_node_ptr()->value)); x = add_to_left ? x->left : x->right; } iterator j = iterator(y); // 此时 y 为插入点的父节点 if (add_to_left) { if (y == header_ || j == begin()) { // 如果树为空树或插入点在最左节点处，肯定可以插入新的节点 return mystl::make_pair(mystl::make_pair(y, true), true); } else { // 否则，如果存在重复节点，那么 --j 就是重复的值 --j; } } if (key_comp_(value_traits::get_key(*j), key)) { // 表明新节点没有重复 return mystl::make_pair(mystl::make_pair(y, add_to_left), true); } // 进行至此，表示新节点与现有节点键值重复 return mystl::make_pair(mystl::make_pair(y, add_to_left), false); } // insert_value_at 函数 // x 为插入点的父节点， value 为要插入的值，add_to_left 表示是否在左边插入 template typename rb_tree::iterator rb_tree:: insert_value_at(base_ptr x, const value_type& value, bool add_to_left) { node_ptr node = create_node(value); node->parent = x; auto base_node = node->get_base_ptr(); if (x == header_) { root() = base_node; leftmost() = base_node; rightmost() = base_node; } else if (add_to_left) { x->left = base_node; if (leftmost() == x) leftmost() = base_node; } else { x->right = base_node; if (rightmost() == x) rightmost() = base_node; } rb_tree_insert_rebalance(base_node, root()); ++node_count_; return iterator(node); } // 在 x 节点处插入新的节点 // x 为插入点的父节点， node 为要插入的节点，add_to_left 表示是否在左边插入 template typename rb_tree::iterator rb_tree:: insert_node_at(base_ptr x, node_ptr node, bool add_to_left) { node->parent = x; auto base_node = node->get_base_ptr(); if (x == header_) { root() = base_node; leftmost() = base_node; rightmost() = base_node; } else if (add_to_left) { x->left = base_node; if (leftmost() == x) leftmost() = base_node; } else { x->right = base_node; if (rightmost() == x) rightmost() = base_node; } rb_tree_insert_rebalance(base_node, root()); ++node_count_; return iterator(node); } // 插入元素，键值允许重复，使用 hint template typename rb_tree::iterator rb_tree:: insert_multi_use_hint(iterator hint, key_type key, node_ptr node) { // 在 hint 附近寻找可插入的位置 auto np = hint.node; auto before = hint; --before; auto bnp = before.node; if (!key_comp_(key, value_traits::get_key(*before)) && !key_comp_(value_traits::get_key(*hint), key)) { // before <= node <= hint if (bnp->right == nullptr) { return insert_node_at(bnp, node, false); } else if (np->left == nullptr) { return insert_node_at(np, node, true); } } auto pos = get_insert_multi_pos(key); return insert_node_at(pos.first, node, pos.second); } // 插入元素，键值不允许重复，使用 hint template typename rb_tree::iterator rb_tree:: insert_unique_use_hint(iterator hint, key_type key, node_ptr node) { // 在 hint 附近寻找可插入的位置 auto np = hint.node; auto before = hint; --before; auto bnp = before.node; if (key_comp_(value_traits::get_key(*before), key) && key_comp_(key, value_traits::get_key(*hint))) { // before < node < hint if (bnp->right == nullptr) { return insert_node_at(bnp, node, false); } else if (np->left == nullptr) { return insert_node_at(np, node, true); } } auto pos = get_insert_unique_pos(key); if (!pos.second) { destroy_node(node); return pos.first.first; } return insert_node_at(pos.first.first, node, pos.first.second); } // copy_from 函数 // 递归复制一颗树，节点从 x 开始，p 为 x 的父节点 template typename rb_tree::base_ptr rb_tree::copy_from(base_ptr x, base_ptr p) { auto top = clone_node(x); top->parent = p; try { if (x->right) top->right = copy_from(x->right, top); p = top; x = x->left; while (x != nullptr) { auto y = clone_node(x); p->left = y; y->parent = p; if (x->right) y->right = copy_from(x->right, y); p = y; x = x->left; } } catch (...) { erase_since(top); throw; } return top; } // erase_since 函数 // 从 x 节点开始删除该节点及其子树 template void rb_tree:: erase_since(base_ptr x) { while (x != nullptr) { erase_since(x->right); auto y = x->left; destroy_node(x->get_node_ptr()); x = y; } } // 重载比较操作符 template bool operator==(const rb_tree& lhs, const rb_tree& rhs) { return lhs.size() == rhs.size() && mystl::equal(lhs.begin(), lhs.end(), rhs.begin()); } template bool operator<(const rb_tree& lhs, const rb_tree& rhs) { return mystl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); } template bool operator!=(const rb_tree& lhs, const rb_tree& rhs) { return !(lhs == rhs); } template bool operator>(const rb_tree& lhs, const rb_tree& rhs) { return rhs < lhs; } template bool operator<=(const rb_tree& lhs, const rb_tree& rhs) { return !(rhs < lhs); } template bool operator>=(const rb_tree& lhs, const rb_tree& rhs) { return !(lhs < rhs); } // 重载 mystl 的 swap template void swap(rb_tree& lhs, rb_tree& rhs) noexcept { lhs.swap(rhs); } } // namespace mystl #endif // !MYTINYSTL_RB_TREE_H_ ================================================ FILE: MyTinySTL/set.h ================================================ #ifndef MYTINYSTL_SET_H_ #define MYTINYSTL_SET_H_ // 这个头文件包含两个模板类 set 和 multiset // set : 集合，键值即实值，集合内元素会自动排序，键值不允许重复 // multiset : 集合，键值即实值，集合内元素会自动排序，键值允许重复 // notes: // // 异常保证： // mystl::set / mystl::multiset 满足基本异常保证，对以下等函数做强异常安全保证： // * emplace // * emplace_hint // * insert #include "rb_tree.h" namespace mystl { // 模板类 set，键值不允许重复 // 参数一代表键值类型，参数二代表键值比较方式，缺省使用 mystl::less template > class set { public: typedef Key key_type; typedef Key value_type; typedef Compare key_compare; typedef Compare value_compare; private: // 以 mystl::rb_tree 作为底层机制 typedef mystl::rb_tree base_type; base_type tree_; public: // 使用 rb_tree 定义的型别 typedef typename base_type::node_type node_type; typedef typename base_type::const_pointer pointer; typedef typename base_type::const_pointer const_pointer; typedef typename base_type::const_reference reference; typedef typename base_type::const_reference const_reference; typedef typename base_type::const_iterator iterator; typedef typename base_type::const_iterator const_iterator; typedef typename base_type::const_reverse_iterator reverse_iterator; typedef typename base_type::const_reverse_iterator const_reverse_iterator; typedef typename base_type::size_type size_type; typedef typename base_type::difference_type difference_type; typedef typename base_type::allocator_type allocator_type; public: // 构造、复制、移动函数 set() = default; template set(InputIterator first, InputIterator last) :tree_() { tree_.insert_unique(first, last); } set(std::initializer_list ilist) :tree_() { tree_.insert_unique(ilist.begin(), ilist.end()); } set(const set& rhs) :tree_(rhs.tree_) { } set(set&& rhs) noexcept :tree_(mystl::move(rhs.tree_)) { } set& operator=(const set& rhs) { tree_ = rhs.tree_; return *this; } set& operator=(set&& rhs) { tree_ = mystl::move(rhs.tree_); return *this; } set& operator=(std::initializer_list ilist) { tree_.clear(); tree_.insert_unique(ilist.begin(), ilist.end()); return *this; } // 相关接口 key_compare key_comp() const { return tree_.key_comp(); } value_compare value_comp() const { return tree_.key_comp(); } allocator_type get_allocator() const { return tree_.get_allocator(); } // 迭代器相关 iterator begin() noexcept { return tree_.begin(); } const_iterator begin() const noexcept { return tree_.begin(); } iterator end() noexcept { return tree_.end(); } const_iterator end() const noexcept { return tree_.end(); } reverse_iterator rbegin() noexcept { return reverse_iterator(end()); } const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); } reverse_iterator rend() noexcept { return reverse_iterator(begin()); } const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); } const_iterator cbegin() const noexcept { return begin(); } const_iterator cend() const noexcept { return end(); } const_reverse_iterator crbegin() const noexcept { return rbegin(); } const_reverse_iterator crend() const noexcept { return rend(); } // 容量相关 bool empty() const noexcept { return tree_.empty(); } size_type size() const noexcept { return tree_.size(); } size_type max_size() const noexcept { return tree_.max_size(); } // 插入删除操作 template pair emplace(Args&& ...args) { return tree_.emplace_unique(mystl::forward(args)...); } template iterator emplace_hint(iterator hint, Args&& ...args) { return tree_.emplace_unique_use_hint(hint, mystl::forward(args)...); } pair insert(const value_type& value) { return tree_.insert_unique(value); } pair insert(value_type&& value) { return tree_.insert_unique(mystl::move(value)); } iterator insert(iterator hint, const value_type& value) { return tree_.insert_unique(hint, value); } iterator insert(iterator hint, value_type&& value) { return tree_.insert_unique(hint, mystl::move(value)); } template void insert(InputIterator first, InputIterator last) { tree_.insert_unique(first, last); } void erase(iterator position) { tree_.erase(position); } size_type erase(const key_type& key) { return tree_.erase_unique(key); } void erase(iterator first, iterator last) { tree_.erase(first, last); } void clear() { tree_.clear(); } // set 相关操作 iterator find(const key_type& key) { return tree_.find(key); } const_iterator find(const key_type& key) const { return tree_.find(key); } size_type count(const key_type& key) const { return tree_.count_unique(key); } iterator lower_bound(const key_type& key) { return tree_.lower_bound(key); } const_iterator lower_bound(const key_type& key) const { return tree_.lower_bound(key); } iterator upper_bound(const key_type& key) { return tree_.upper_bound(key); } const_iterator upper_bound(const key_type& key) const { return tree_.upper_bound(key); } pair equal_range(const key_type& key) { return tree_.equal_range_unique(key); } pair equal_range(const key_type& key) const { return tree_.equal_range_unique(key); } void swap(set& rhs) noexcept { tree_.swap(rhs.tree_); } public: friend bool operator==(const set& lhs, const set& rhs) { return lhs.tree_ == rhs.tree_; } friend bool operator< (const set& lhs, const set& rhs) { return lhs.tree_ < rhs.tree_; } }; // 重载比较操作符 template bool operator==(const set& lhs, const set& rhs) { return lhs == rhs; } template bool operator<(const set& lhs, const set& rhs) { return lhs < rhs; } template bool operator!=(const set& lhs, const set& rhs) { return !(lhs == rhs); } template bool operator>(const set& lhs, const set& rhs) { return rhs < lhs; } template bool operator<=(const set& lhs, const set& rhs) { return !(rhs < lhs); } template bool operator>=(const set& lhs, const set& rhs) { return !(lhs < rhs); } // 重载 mystl 的 swap template void swap(set& lhs, set& rhs) noexcept { lhs.swap(rhs); } /*****************************************************************************************/ // 模板类 multiset，键值允许重复 // 参数一代表键值类型，参数二代表键值比较方式，缺省使用 mystl::less template > class multiset { public: typedef Key key_type; typedef Key value_type; typedef Compare key_compare; typedef Compare value_compare; private: // 以 mystl::rb_tree 作为底层机制 typedef mystl::rb_tree base_type; base_type tree_; // 以 rb_tree 表现 multiset public: // 使用 rb_tree 定义的型别 typedef typename base_type::node_type node_type; typedef typename base_type::const_pointer pointer; typedef typename base_type::const_pointer const_pointer; typedef typename base_type::const_reference reference; typedef typename base_type::const_reference const_reference; typedef typename base_type::const_iterator iterator; typedef typename base_type::const_iterator const_iterator; typedef typename base_type::const_reverse_iterator reverse_iterator; typedef typename base_type::const_reverse_iterator const_reverse_iterator; typedef typename base_type::size_type size_type; typedef typename base_type::difference_type difference_type; typedef typename base_type::allocator_type allocator_type; public: // 构造、复制、移动函数 multiset() = default; template multiset(InputIterator first, InputIterator last) :tree_() { tree_.insert_multi(first, last); } multiset(std::initializer_list ilist) :tree_() { tree_.insert_multi(ilist.begin(), ilist.end()); } multiset(const multiset& rhs) :tree_(rhs.tree_) { } multiset(multiset&& rhs) noexcept :tree_(mystl::move(rhs.tree_)) { } multiset& operator=(const multiset& rhs) { tree_ = rhs.tree_; return *this; } multiset& operator=(multiset&& rhs) { tree_ = mystl::move(rhs.tree_); return *this; } multiset& operator=(std::initializer_list ilist) { tree_.clear(); tree_.insert_multi(ilist.begin(), ilist.end()); return *this; } // 相关接口 key_compare key_comp() const { return tree_.key_comp(); } value_compare value_comp() const { return tree_.key_comp(); } allocator_type get_allocator() const { return tree_.get_allocator(); } // 迭代器相关 iterator begin() noexcept { return tree_.begin(); } const_iterator begin() const noexcept { return tree_.begin(); } iterator end() noexcept { return tree_.end(); } const_iterator end() const noexcept { return tree_.end(); } reverse_iterator rbegin() noexcept { return reverse_iterator(end()); } const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); } reverse_iterator rend() noexcept { return reverse_iterator(begin()); } const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); } const_iterator cbegin() const noexcept { return begin(); } const_iterator cend() const noexcept { return end(); } const_reverse_iterator crbegin() const noexcept { return rbegin(); } const_reverse_iterator crend() const noexcept { return rend(); } // 容量相关 bool empty() const noexcept { return tree_.empty(); } size_type size() const noexcept { return tree_.size(); } size_type max_size() const noexcept { return tree_.max_size(); } // 插入删除操作 template iterator emplace(Args&& ...args) { return tree_.emplace_multi(mystl::forward(args)...); } template iterator emplace_hint(iterator hint, Args&& ...args) { return tree_.emplace_multi_use_hint(hint, mystl::forward(args)...); } iterator insert(const value_type& value) { return tree_.insert_multi(value); } iterator insert(value_type&& value) { return tree_.insert_multi(mystl::move(value)); } iterator insert(iterator hint, const value_type& value) { return tree_.insert_multi(hint, value); } iterator insert(iterator hint, value_type&& value) { return tree_.insert_multi(hint, mystl::move(value)); } template void insert(InputIterator first, InputIterator last) { tree_.insert_multi(first, last); } void erase(iterator position) { tree_.erase(position); } size_type erase(const key_type& key) { return tree_.erase_multi(key); } void erase(iterator first, iterator last) { tree_.erase(first, last); } void clear() { tree_.clear(); } // multiset 相关操作 iterator find(const key_type& key) { return tree_.find(key); } const_iterator find(const key_type& key) const { return tree_.find(key); } size_type count(const key_type& key) const { return tree_.count_multi(key); } iterator lower_bound(const key_type& key) { return tree_.lower_bound(key); } const_iterator lower_bound(const key_type& key) const { return tree_.lower_bound(key); } iterator upper_bound(const key_type& key) { return tree_.upper_bound(key); } const_iterator upper_bound(const key_type& key) const { return tree_.upper_bound(key); } pair equal_range(const key_type& key) { return tree_.equal_range_multi(key); } pair equal_range(const key_type& key) const { return tree_.equal_range_multi(key); } void swap(multiset& rhs) noexcept { tree_.swap(rhs.tree_); } public: friend bool operator==(const multiset& lhs, const multiset& rhs) { return lhs.tree_ == rhs.tree_; } friend bool operator< (const multiset& lhs, const multiset& rhs) { return lhs.tree_ < rhs.tree_; } }; // 重载比较操作符 template bool operator==(const multiset& lhs, const multiset& rhs) { return lhs == rhs; } template bool operator<(const multiset& lhs, const multiset& rhs) { return lhs < rhs; } template bool operator!=(const multiset& lhs, const multiset& rhs) { return !(lhs == rhs); } template bool operator>(const multiset& lhs, const multiset& rhs) { return rhs < lhs; } template bool operator<=(const multiset& lhs, const multiset& rhs) { return !(rhs < lhs); } template bool operator>=(const multiset& lhs, const multiset& rhs) { return !(lhs < rhs); } // 重载 mystl 的 swap template void swap(multiset& lhs, multiset& rhs) noexcept { lhs.swap(rhs); } } // namespace mystl #endif // !MYTINYSTL_SET_H_ ================================================ FILE: MyTinySTL/set_algo.h ================================================ #ifndef MYTINYSTL_SET_ALGO_H_ #define MYTINYSTL_SET_ALGO_H_ // 这个头文件包含 set 的四种算法: union, intersection, difference, symmetric_difference // 所有函数都要求序列有序 #include "algobase.h" #include "iterator.h" namespace mystl { /*****************************************************************************************/ // set_union // 计算 S1∪S2 的结果并保存到 result 中，返回一个迭代器指向输出结果的尾部 /*****************************************************************************************/ template OutputIter set_union(InputIter1 first1, InputIter1 last1, InputIter2 first2, InputIter2 last2, OutputIter result) { while (first1 != last1 && first2 != last2) { if (*first1 < *first2) { *result = *first1; ++first1; } else if (*first2 < *first1) { *result = *first2; ++first2; } else { *result = *first1; ++first1; ++first2; } ++result; } // 将剩余元素拷贝到 result return mystl::copy(first2, last2, mystl::copy(first1, last1, result)); } // 重载版本使用函数对象 comp 代替比较操作 template OutputIter set_union(InputIter1 first1, InputIter1 last1, InputIter2 first2, InputIter2 last2, OutputIter result, Compared comp) { while (first1 != last1 && first2 != last2) { if (comp(*first1, *first2)) { *result = *first1; ++first1; } else if (comp(*first2, *first1)) { *result = *first2; ++first2; } else { *result = *first1; ++first1; ++first2; } ++result; } // 将剩余元素拷贝到 result return mystl::copy(first2, last2, mystl::copy(first1, last1, result)); } /*****************************************************************************************/ // set_intersection // 计算 S1∩S2 的结果并保存到 result 中，返回一个迭代器指向输出结果的尾部 /*****************************************************************************************/ template OutputIter set_intersection(InputIter1 first1, InputIter1 last1, InputIter2 first2, InputIter2 last2, OutputIter result) { while (first1 != last1 && first2 != last2) { if (*first1 < *first2) { ++first1; } else if (*first2 < *first1) { ++first2; } else { *result = *first1; ++first1; ++first2; ++result; } } return result; } // 重载版本使用函数对象 comp 代替比较操作 template OutputIter set_intersection(InputIter1 first1, InputIter1 last1, InputIter2 first2, InputIter2 last2, OutputIter result, Compared comp) { while (first1 != last1 && first2 != last2) { if (comp(*first1, *first2)) { ++first1; } else if (comp(*first2, *first1)) { ++first2; } else { *result = *first1; ++first1; ++first2; ++result; } } return result; } /*****************************************************************************************/ // set_difference // 计算 S1-S2 的结果并保存到 result 中，返回一个迭代器指向输出结果的尾部 /*****************************************************************************************/ template OutputIter set_difference(InputIter1 first1, InputIter1 last1, InputIter2 first2, InputIter2 last2, OutputIter result) { while (first1 != last1 && first2 != last2) { if (*first1 < *first2) { *result = *first1; ++first1; ++result; } else if (*first2 < *first1) { ++first2; } else { ++first1; ++first2; } } return mystl::copy(first1, last1, result); } // 重载版本使用函数对象 comp 代替比较操作 template OutputIter set_difference(InputIter1 first1, InputIter1 last1, InputIter2 first2, InputIter2 last2, OutputIter result, Compared comp) { while (first1 != last1 && first2 != last2) { if (comp(*first1, *first2)) { *result = *first1; ++first1; ++result; } else if (comp(*first2, *first1)) { ++first2; } else { ++first1; ++first2; } } return mystl::copy(first1, last1, result); } /*****************************************************************************************/ // set_symmetric_difference // 计算 (S1-S2)∪(S2-S1) 的结果并保存到 result 中，返回一个迭代器指向输出结果的尾部 /*****************************************************************************************/ template OutputIter set_symmetric_difference(InputIter1 first1, InputIter1 last1, InputIter2 first2, InputIter2 last2, OutputIter result) { while (first1 != last1 && first2 != last2) { if (*first1 < *first2) { *result = *first1; ++first1; ++result; } else if (*first2 < *first1) { *result = *first2; ++first2; ++result; } else { ++first1; ++first2; } } return mystl::copy(first2, last2, mystl::copy(first1, last1, result)); } // 重载版本使用函数对象 comp 代替比较操作 template OutputIter set_symmetric_difference(InputIter1 first1, InputIter1 last1, InputIter2 first2, InputIter2 last2, OutputIter result, Compared comp) { while (first1 != last1 && first2 != last2) { if (comp(*first1, *first2)) { *result = *first1; ++first1; ++result; } else if (comp(*first2, *first1)) { *result = *first2; ++first2; ++result; } else { ++first1; ++first2; } } return mystl::copy(first2, last2, mystl::copy(first1, last1, result)); } } // namespace mystl #endif // !MYTINYSTL_SET_ALGO_H_ ================================================ FILE: MyTinySTL/stack.h ================================================ #ifndef MYTINYSTL_STACK_H_ #define MYTINYSTL_STACK_H_ // 这个头文件包含了一个模板类 stack // stack : 栈 #include "deque.h" namespace mystl { // 模板类 stack // 参数一代表数据类型，参数二代表底层容器类型，缺省使用 mystl::deque 作为底层容器 template > class stack { public: typedef Container container_type; // 使用底层容器的型别 typedef typename Container::value_type value_type; typedef typename Container::size_type size_type; typedef typename Container::reference reference; typedef typename Container::const_reference const_reference; static_assert(std::is_same::value, "the value_type of Container should be same with T"); private: container_type c_; // 用底层容器表现 stack public: // 构造、复制、移动函数 stack() = default; explicit stack(size_type n) :c_(n) { } stack(size_type n, const value_type& value) :c_(n, value) { } template stack(IIter first, IIter last) : c_(first, last) { } stack(std::initializer_list ilist) :c_(ilist.begin(), ilist.end()) { } stack(const Container& c) :c_(c) { } stack(Container&& c) noexcept(std::is_nothrow_move_constructible::value) :c_(mystl::move(c)) { } stack(const stack& rhs) :c_(rhs.c_) { } stack(stack&& rhs) noexcept(std::is_nothrow_move_constructible::value) :c_(mystl::move(rhs.c_)) { } stack& operator=(const stack& rhs) { c_ = rhs.c_; return *this; } stack& operator=(stack&& rhs) noexcept(std::is_nothrow_move_assignable::value) { c_ = mystl::move(rhs.c_); return *this; } stack& operator=(std::initializer_list ilist) { c_ = ilist; return *this; } ~stack() = default; // 访问元素相关操作 reference top() { return c_.back(); } const_reference top() const { return c_.back(); } // 容量相关操作 bool empty() const noexcept { return c_.empty(); } size_type size() const noexcept { return c_.size(); } // 修改容器相关操作 template void emplace(Args&& ...args) { c_.emplace_back(mystl::forward(args)...); } void push(const value_type& value) { c_.push_back(value); } void push(value_type&& value) { c_.push_back(mystl::move(value)); } void pop() { c_.pop_back(); } void clear() { while (!empty()) pop(); } void swap(stack& rhs) noexcept(noexcept(mystl::swap(c_, rhs.c_))) { mystl::swap(c_, rhs.c_); } public: friend bool operator==(const stack& lhs, const stack& rhs) { return lhs.c_ == rhs.c_; } friend bool operator< (const stack& lhs, const stack& rhs) { return lhs.c_ < rhs.c_; } }; // 重载比较操作符 template bool operator==(const stack& lhs, const stack& rhs) { return lhs == rhs; } template bool operator<(const stack& lhs, const stack& rhs) { return lhs < rhs; } template bool operator!=(const stack& lhs, const stack& rhs) { return !(lhs == rhs); } template bool operator>(const stack& lhs, const stack& rhs) { return rhs < lhs; } template bool operator<=(const stack& lhs, const stack& rhs) { return !(rhs < lhs); } template bool operator>=(const stack& lhs, const stack& rhs) { return !(lhs < rhs); } // 重载 mystl 的 swap template void swap(stack& lhs, stack& rhs) noexcept(noexcept(lhs.swap(rhs))) { lhs.swap(rhs); } } // namespace mystl #endif // !MYTINYSTL_STACK_H_ ================================================ FILE: MyTinySTL/stream_iterator.h ================================================ #ifndef MYTINYSTL_STREAM_ITERATOR_H_ #define MYTINYSTL_STREAM_ITERATOR_H_ #include "basic_string.h" namespace mystl { template, typename Dist = ptrdiff_t> class istream_iterator : public iterator { public: using char_type = CharT; using traits_type = Traits; using istream_type = std::basic_istream; istream_iterator() /* noexcept(std::is_nothrow_default_constructible::value) */ : m_stream{nullptr}, m_value{} {} istream_iterator(istream_type& is) : m_stream{std::addressof(is)} { read(); } istream_iterator(const istream_iterator& other) /* noexcept(std::is_nothrow_copy_constructible::value) */ = default; // memberwise copy istream_iterator& operator=(const istream_iterator&) = default; // memberwise copy-asgn ~istream_iterator() = default; const T& operator*() const noexcept { MYSTL_DEBUG(m_stream != nullptr); return m_value; } const T* operator->() const noexcept { return std::addressof(*this); } istream_iterator& operator++() { MYSTL_DEBUG(m_stream != nullptr); read(); return *this; } istream_iterator operator++(int) { auto tmp = *this; ++*this; return tmp; } private: istream_type* m_stream; T m_value; void read() { if (m_stream && !(*m_stream >> m_value)) { // m_stream 有效且读到 EOS m_stream = nullptr; } } friend bool operator==(const istream_iterator& lhs, const istream_iterator& rhs) { return lhs.m_stream == rhs.m_stream; } friend bool operator!=(const istream_iterator& lhs, const istream_iterator& rhs) { return lhs.m_stream != rhs.m_stream; } }; // TODO // template > // class ostream_iterator : public iterator {}; } #endif ================================================ FILE: MyTinySTL/type_traits.h ================================================ #ifndef MYTINYSTL_TYPE_TRAITS_H_ #define MYTINYSTL_TYPE_TRAITS_H_ // 这个头文件用于提取类型信息 // use standard header for type_traits #include namespace mystl { // helper struct template struct m_integral_constant { static constexpr T value = v; }; template using m_bool_constant = m_integral_constant; typedef m_bool_constant m_true_type; typedef m_bool_constant m_false_type; /*****************************************************************************************/ // type traits // is_pair // --- forward declaration begin template struct pair; // --- forward declaration end template struct is_pair : mystl::m_false_type {}; template struct is_pair> : mystl::m_true_type {}; } // namespace mystl #endif // !MYTINYSTL_TYPE_TRAITS_H_ ================================================ FILE: MyTinySTL/uninitialized.h ================================================ #ifndef MYTINYSTL_UNINITIALIZED_H_ #define MYTINYSTL_UNINITIALIZED_H_ // 这个头文件用于对未初始化空间构造元素 #include "algobase.h" #include "construct.h" #include "iterator.h" #include "type_traits.h" #include "util.h" namespace mystl { /*****************************************************************************************/ // uninitialized_copy // 把 [first, last) 上的内容复制到以 result 为起始处的空间，返回复制结束的位置 /*****************************************************************************************/ template ForwardIter unchecked_uninit_copy(InputIter first, InputIter last, ForwardIter result, std::true_type) { return mystl::copy(first, last, result); } template ForwardIter unchecked_uninit_copy(InputIter first, InputIter last, ForwardIter result, std::false_type) { auto cur = result; try { for (; first != last; ++first, ++cur) { mystl::construct(&*cur, *first); } } catch (...) { for (; result != cur; --cur) mystl::destroy(&*cur); } return cur; } template ForwardIter uninitialized_copy(InputIter first, InputIter last, ForwardIter result) { return mystl::unchecked_uninit_copy(first, last, result, std::is_trivially_copy_assignable< typename iterator_traits:: value_type>{}); } /*****************************************************************************************/ // uninitialized_copy_n // 把 [first, first + n) 上的内容复制到以 result 为起始处的空间，返回复制结束的位置 /*****************************************************************************************/ template ForwardIter unchecked_uninit_copy_n(InputIter first, Size n, ForwardIter result, std::true_type) { return mystl::copy_n(first, n, result).second; } template ForwardIter unchecked_uninit_copy_n(InputIter first, Size n, ForwardIter result, std::false_type) { auto cur = result; try { for (; n > 0; --n, ++cur, ++first) { mystl::construct(&*cur, *first); } } catch (...) { for (; result != cur; --cur) mystl::destroy(&*cur); } return cur; } template ForwardIter uninitialized_copy_n(InputIter first, Size n, ForwardIter result) { return mystl::unchecked_uninit_copy_n(first, n, result, std::is_trivially_copy_assignable< typename iterator_traits:: value_type>{}); } /*****************************************************************************************/ // uninitialized_fill // 在 [first, last) 区间内填充元素值 /*****************************************************************************************/ template void unchecked_uninit_fill(ForwardIter first, ForwardIter last, const T& value, std::true_type) { mystl::fill(first, last, value); } template void unchecked_uninit_fill(ForwardIter first, ForwardIter last, const T& value, std::false_type) { auto cur = first; try { for (; cur != last; ++cur) { mystl::construct(&*cur, value); } } catch (...) { for (;first != cur; ++first) mystl::destroy(&*first); } } template void uninitialized_fill(ForwardIter first, ForwardIter last, const T& value) { mystl::unchecked_uninit_fill(first, last, value, std::is_trivially_copy_assignable< typename iterator_traits:: value_type>{}); } /*****************************************************************************************/ // uninitialized_fill_n // 从 first 位置开始，填充 n 个元素值，返回填充结束的位置 /*****************************************************************************************/ template ForwardIter unchecked_uninit_fill_n(ForwardIter first, Size n, const T& value, std::true_type) { return mystl::fill_n(first, n, value); } template ForwardIter unchecked_uninit_fill_n(ForwardIter first, Size n, const T& value, std::false_type) { auto cur = first; try { for (; n > 0; --n, ++cur) { mystl::construct(&*cur, value); } } catch (...) { for (; first != cur; ++first) mystl::destroy(&*first); } return cur; } template ForwardIter uninitialized_fill_n(ForwardIter first, Size n, const T& value) { return mystl::unchecked_uninit_fill_n(first, n, value, std::is_trivially_copy_assignable< typename iterator_traits:: value_type>{}); } /*****************************************************************************************/ // uninitialized_move // 把[first, last)上的内容移动到以 result 为起始处的空间，返回移动结束的位置 /*****************************************************************************************/ template ForwardIter unchecked_uninit_move(InputIter first, InputIter last, ForwardIter result, std::true_type) { return mystl::move(first, last, result); } template ForwardIter unchecked_uninit_move(InputIter first, InputIter last, ForwardIter result, std::false_type) { ForwardIter cur = result; try { for (; first != last; ++first, ++cur) { mystl::construct(&*cur, mystl::move(*first)); } } catch (...) { mystl::destroy(result, cur); } return cur; } template ForwardIter uninitialized_move(InputIter first, InputIter last, ForwardIter result) { return mystl::unchecked_uninit_move(first, last, result, std::is_trivially_move_assignable< typename iterator_traits:: value_type>{}); } /*****************************************************************************************/ // uninitialized_move_n // 把[first, first + n)上的内容移动到以 result 为起始处的空间，返回移动结束的位置 /*****************************************************************************************/ template ForwardIter unchecked_uninit_move_n(InputIter first, Size n, ForwardIter result, std::true_type) { return mystl::move(first, first + n, result); } template ForwardIter unchecked_uninit_move_n(InputIter first, Size n, ForwardIter result, std::false_type) { auto cur = result; try { for (; n > 0; --n, ++first, ++cur) { mystl::construct(&*cur, mystl::move(*first)); } } catch (...) { for (; result != cur; ++result) mystl::destroy(&*result); throw; } return cur; } template ForwardIter uninitialized_move_n(InputIter first, Size n, ForwardIter result) { return mystl::unchecked_uninit_move_n(first, n, result, std::is_trivially_move_assignable< typename iterator_traits:: value_type>{}); } } // namespace mystl #endif // !MYTINYSTL_UNINITIALIZED_H_ ================================================ FILE: MyTinySTL/unordered_map.h ================================================ #ifndef MYTINYSTL_UNORDERED_MAP_H_ #define MYTINYSTL_UNORDERED_MAP_H_ // 这个头文件包含两个模板类 unordered_map 和 unordered_multimap // 功能与用法与 map 和 multimap 类似，不同的是使用 hashtable 作为底层实现机制，容器内的元素不会自动排序 // notes: // // 异常保证： // mystl::unordered_map / mystl::unordered_multimap 满足基本异常保证，对以下等函数做强异常安全保证： // * emplace // * emplace_hint // * insert #include "hashtable.h" namespace mystl { // 模板类 unordered_map，键值不允许重复 // 参数一代表键值类型，参数二代表实值类型，参数三代表哈希函数，缺省使用 mystl::hash // 参数四代表键值比较方式，缺省使用 mystl::equal_to template , class KeyEqual = mystl::equal_to> class unordered_map { private: // 使用 hashtable 作为底层机制 typedef hashtable, Hash, KeyEqual> base_type; base_type ht_; public: // 使用 hashtable 的型别 typedef typename base_type::allocator_type allocator_type; typedef typename base_type::key_type key_type; typedef typename base_type::mapped_type mapped_type; typedef typename base_type::value_type value_type; typedef typename base_type::hasher hasher; typedef typename base_type::key_equal key_equal; typedef typename base_type::size_type size_type; typedef typename base_type::difference_type difference_type; typedef typename base_type::pointer pointer; typedef typename base_type::const_pointer const_pointer; typedef typename base_type::reference reference; typedef typename base_type::const_reference const_reference; typedef typename base_type::iterator iterator; typedef typename base_type::const_iterator const_iterator; typedef typename base_type::local_iterator local_iterator; typedef typename base_type::const_local_iterator const_local_iterator; allocator_type get_allocator() const { return ht_.get_allocator(); } public: // 构造、复制、移动、析构函数 unordered_map() :ht_(100, Hash(), KeyEqual()) { } explicit unordered_map(size_type bucket_count, const Hash& hash = Hash(), const KeyEqual& equal = KeyEqual()) :ht_(bucket_count, hash, equal) { } template unordered_map(InputIterator first, InputIterator last, const size_type bucket_count = 100, const Hash& hash = Hash(), const KeyEqual& equal = KeyEqual()) : ht_(mystl::max(bucket_count, static_cast(mystl::distance(first, last))), hash, equal) { for (; first != last; ++first) ht_.insert_unique_noresize(*first); } unordered_map(std::initializer_list ilist, const size_type bucket_count = 100, const Hash& hash = Hash(), const KeyEqual& equal = KeyEqual()) :ht_(mystl::max(bucket_count, static_cast(ilist.size())), hash, equal) { for (auto first = ilist.begin(), last = ilist.end(); first != last; ++first) ht_.insert_unique_noresize(*first); } unordered_map(const unordered_map& rhs) :ht_(rhs.ht_) { } unordered_map(unordered_map&& rhs) noexcept :ht_(mystl::move(rhs.ht_)) { } unordered_map& operator=(const unordered_map& rhs) { ht_ = rhs.ht_; return *this; } unordered_map& operator=(unordered_map&& rhs) { ht_ = mystl::move(rhs.ht_); return *this; } unordered_map& operator=(std::initializer_list ilist) { ht_.clear(); ht_.reserve(ilist.size()); for (auto first = ilist.begin(), last = ilist.end(); first != last; ++first) ht_.insert_unique_noresize(*first); return *this; } ~unordered_map() = default; // 迭代器相关 iterator begin() noexcept { return ht_.begin(); } const_iterator begin() const noexcept { return ht_.begin(); } iterator end() noexcept { return ht_.end(); } const_iterator end() const noexcept { return ht_.end(); } const_iterator cbegin() const noexcept { return ht_.cbegin(); } const_iterator cend() const noexcept { return ht_.cend(); } // 容量相关 bool empty() const noexcept { return ht_.empty(); } size_type size() const noexcept { return ht_.size(); } size_type max_size() const noexcept { return ht_.max_size(); } // 修改容器操作 // empalce / empalce_hint template pair emplace(Args&& ...args) { return ht_.emplace_unique(mystl::forward(args)...); } template iterator emplace_hint(const_iterator hint, Args&& ...args) { return ht_.emplace_unique_use_hint(hint, mystl::forward(args)...); } // insert pair insert(const value_type& value) { return ht_.insert_unique(value); } pair insert(value_type&& value) { return ht_.emplace_unique(mystl::move(value)); } iterator insert(const_iterator hint, const value_type& value) { return ht_.insert_unique_use_hint(hint, value); } iterator insert(const_iterator hint, value_type&& value) { return ht_.emplace_unique_use_hint(hint, mystl::move(value)); } template void insert(InputIterator first, InputIterator last) { ht_.insert_unique(first, last); } // erase / clear void erase(iterator it) { ht_.erase(it); } void erase(iterator first, iterator last) { ht_.erase(first, last); } size_type erase(const key_type& key) { return ht_.erase_unique(key); } void clear() { ht_.clear(); } void swap(unordered_map& other) noexcept { ht_.swap(other.ht_); } // 查找相关 mapped_type& at(const key_type& key) { iterator it = ht_.find(key); THROW_OUT_OF_RANGE_IF(it.node == nullptr, "unordered_map no such element exists"); return it->second; } const mapped_type& at(const key_type& key) const { iterator it = ht_.find(key); THROW_OUT_OF_RANGE_IF(it.node == nullptr, "unordered_map no such element exists"); return it->second; } mapped_type& operator[](const key_type& key) { iterator it = ht_.find(key); if (it.node == nullptr) it = ht_.emplace_unique(key, T{}).first; return it->second; } mapped_type& operator[](key_type&& key) { iterator it = ht_.find(key); if (it.node == nullptr) it = ht_.emplace_unique(mystl::move(key), T{}).first; return it->second; } size_type count(const key_type& key) const { return ht_.count(key); } iterator find(const key_type& key) { return ht_.find(key); } const_iterator find(const key_type& key) const { return ht_.find(key); } pair equal_range(const key_type& key) { return ht_.equal_range_unique(key); } pair equal_range(const key_type& key) const { return ht_.equal_range_unique(key); } // bucket interface local_iterator begin(size_type n) noexcept { return ht_.begin(n); } const_local_iterator begin(size_type n) const noexcept { return ht_.begin(n); } const_local_iterator cbegin(size_type n) const noexcept { return ht_.cbegin(n); } local_iterator end(size_type n) noexcept { return ht_.end(n); } const_local_iterator end(size_type n) const noexcept { return ht_.end(n); } const_local_iterator cend(size_type n) const noexcept { return ht_.cend(n); } size_type bucket_count() const noexcept { return ht_.bucket_count(); } size_type max_bucket_count() const noexcept { return ht_.max_bucket_count(); } size_type bucket_size(size_type n) const noexcept { return ht_.bucket_size(n); } size_type bucket(const key_type& key) const { return ht_.bucket(key); } // hash policy float load_factor() const noexcept { return ht_.load_factor(); } float max_load_factor() const noexcept { return ht_.max_load_factor(); } void max_load_factor(float ml) { ht_.max_load_factor(ml); } void rehash(size_type count) { ht_.rehash(count); } void reserve(size_type count) { ht_.reserve(count); } hasher hash_fcn() const { return ht_.hash_fcn(); } key_equal key_eq() const { return ht_.key_eq(); } public: friend bool operator==(const unordered_map& lhs, const unordered_map& rhs) { return lhs.ht_.equal_range_unique(rhs.ht_); } friend bool operator!=(const unordered_map& lhs, const unordered_map& rhs) { return !lhs.ht_.equal_range_unique(rhs.ht_); } }; // 重载比较操作符 template bool operator==(const unordered_map& lhs, const unordered_map& rhs) { return lhs == rhs; } template bool operator!=(const unordered_map& lhs, const unordered_map& rhs) { return lhs != rhs; } // 重载 mystl 的 swap template void swap(unordered_map& lhs, unordered_map& rhs) { lhs.swap(rhs); } /*****************************************************************************************/ // 模板类 unordered_multimap，键值允许重复 // 参数一代表键值类型，参数二代表实值类型，参数三代表哈希函数，缺省使用 mystl::hash // 参数四代表键值比较方式，缺省使用 mystl::equal_to template , class KeyEqual = mystl::equal_to> class unordered_multimap { private: // 使用 hashtable 作为底层机制 typedef hashtable, Hash, KeyEqual> base_type; base_type ht_; public: // 使用 hashtable 的型别 typedef typename base_type::allocator_type allocator_type; typedef typename base_type::key_type key_type; typedef typename base_type::mapped_type mapped_type; typedef typename base_type::value_type value_type; typedef typename base_type::hasher hasher; typedef typename base_type::key_equal key_equal; typedef typename base_type::size_type size_type; typedef typename base_type::difference_type difference_type; typedef typename base_type::pointer pointer; typedef typename base_type::const_pointer const_pointer; typedef typename base_type::reference reference; typedef typename base_type::const_reference const_reference; typedef typename base_type::iterator iterator; typedef typename base_type::const_iterator const_iterator; typedef typename base_type::local_iterator local_iterator; typedef typename base_type::const_local_iterator const_local_iterator; allocator_type get_allocator() const { return ht_.get_allocator(); } public: // 构造、复制、移动函数 unordered_multimap() :ht_(100, Hash(), KeyEqual()) { } explicit unordered_multimap(size_type bucket_count, const Hash& hash = Hash(), const KeyEqual& equal = KeyEqual()) :ht_(bucket_count, hash, equal) { } template unordered_multimap(InputIterator first, InputIterator last, const size_type bucket_count = 100, const Hash& hash = Hash(), const KeyEqual& equal = KeyEqual()) :ht_(mystl::max(bucket_count, static_cast(mystl::distance(first, last))), hash, equal) { for (; first != last; ++first) ht_.insert_multi_noresize(*first); } unordered_multimap(std::initializer_list ilist, const size_type bucket_count = 100, const Hash& hash = Hash(), const KeyEqual& equal = KeyEqual()) :ht_(mystl::max(bucket_count, static_cast(ilist.size())), hash, equal) { for (auto first = ilist.begin(), last = ilist.end(); first != last; ++first) ht_.insert_multi_noresize(*first); } unordered_multimap(const unordered_multimap& rhs) :ht_(rhs.ht_) { } unordered_multimap(unordered_multimap&& rhs) noexcept :ht_(mystl::move(rhs.ht_)) { } unordered_multimap& operator=(const unordered_multimap& rhs) { ht_ = rhs.ht_; return *this; } unordered_multimap& operator=(unordered_multimap&& rhs) { ht_ = mystl::move(rhs.ht_); return *this; } unordered_multimap& operator=(std::initializer_list ilist) { ht_.clear(); ht_.reserve(ilist.size()); for (auto first = ilist.begin(), last = ilist.end(); first != last; ++first) ht_.insert_multi_noresize(*first); return *this; } ~unordered_multimap() = default; // 迭代器相关 iterator begin() noexcept { return ht_.begin(); } const_iterator begin() const noexcept { return ht_.begin(); } iterator end() noexcept { return ht_.end(); } const_iterator end() const noexcept { return ht_.end(); } const_iterator cbegin() const noexcept { return ht_.cbegin(); } const_iterator cend() const noexcept { return ht_.cend(); } // 容量相关 bool empty() const noexcept { return ht_.empty(); } size_type size() const noexcept { return ht_.size(); } size_type max_size() const noexcept { return ht_.max_size(); } // 修改容器相关 // emplace / emplace_hint template iterator emplace(Args&& ...args) { return ht_.emplace_multi(mystl::forward(args)...); } template iterator emplace_hint(const_iterator hint, Args&& ...args) { return ht_.emplace_multi_use_hint(hint, mystl::forward(args)...); } // insert iterator insert(const value_type& value) { return ht_.insert_multi(value); } iterator insert(value_type&& value) { return ht_.emplace_multi(mystl::move(value)); } iterator insert(const_iterator hint, const value_type& value) { return ht_.insert_multi_use_hint(hint, value); } iterator insert(const_iterator hint, value_type&& value) { return ht_.emplace_multi_use_hint(hint, mystl::move(value)); } template void insert(InputIterator first, InputIterator last) { ht_.insert_multi(first, last); } // erase / clear void erase(iterator it) { ht_.erase(it); } void erase(iterator first, iterator last) { ht_.erase(first, last); } size_type erase(const key_type& key) { return ht_.erase_multi(key); } void clear() { ht_.clear(); } void swap(unordered_multimap& other) noexcept { ht_.swap(other.ht_); } // 查找相关 size_type count(const key_type& key) const { return ht_.count(key); } iterator find(const key_type& key) { return ht_.find(key); } const_iterator find(const key_type& key) const { return ht_.find(key); } pair equal_range(const key_type& key) { return ht_.equal_range_multi(key); } pair equal_range(const key_type& key) const { return ht_.equal_range_multi(key); } // bucket interface local_iterator begin(size_type n) noexcept { return ht_.begin(n); } const_local_iterator begin(size_type n) const noexcept { return ht_.begin(n); } const_local_iterator cbegin(size_type n) const noexcept { return ht_.cbegin(n); } local_iterator end(size_type n) noexcept { return ht_.end(n); } const_local_iterator end(size_type n) const noexcept { return ht_.end(n); } const_local_iterator cend(size_type n) const noexcept { return ht_.cend(n); } size_type bucket_count() const noexcept { return ht_.bucket_count(); } size_type max_bucket_count() const noexcept { return ht_.max_bucket_count(); } size_type bucket_size(size_type n) const noexcept { return ht_.bucket_size(n); } size_type bucket(const key_type& key) const { return ht_.bucket(key); } // hash policy float load_factor() const noexcept { return ht_.load_factor(); } float max_load_factor() const noexcept { return ht_.max_load_factor(); } void max_load_factor(float ml) { ht_.max_load_factor(ml); } void rehash(size_type count) { ht_.rehash(count); } void reserve(size_type count) { ht_.reserve(count); } hasher hash_fcn() const { return ht_.hash_fcn(); } key_equal key_eq() const { return ht_.key_eq(); } public: friend bool operator==(const unordered_multimap& lhs, const unordered_multimap& rhs) { return lhs.ht_.equal_range_multi(rhs.ht_); } friend bool operator!=(const unordered_multimap& lhs, const unordered_multimap& rhs) { return !lhs.ht_.equal_range_multi(rhs.ht_); } }; // 重载比较操作符 template bool operator==(const unordered_multimap& lhs, const unordered_multimap& rhs) { return lhs == rhs; } template bool operator!=(const unordered_multimap& lhs, const unordered_multimap& rhs) { return lhs != rhs; } // 重载 mystl 的 swap template void swap(unordered_multimap& lhs, unordered_multimap& rhs) { lhs.swap(rhs); } } // namespace mystl #endif // !MYTINYSTL_UNORDERED_MAP_H_ ================================================ FILE: MyTinySTL/unordered_set.h ================================================ #ifndef MYTINYSTL_UNORDERED_SET_H_ #define MYTINYSTL_UNORDERED_SET_H_ // 这个头文件包含两个模板类 unordered_set 和 unordered_multiset // 功能与用法与 set 和 multiset 类似，不同的是使用 hashtable 作为底层实现机制，容器中的元素不会自动排序 // notes: // // 异常保证： // mystl::unordered_set / mystl::unordered_multiset 满足基本异常保证，对以下等函数做强异常安全保证： // * emplace // * emplace_hint // * insert #include "hashtable.h" namespace mystl { // 模板类 unordered_set，键值不允许重复 // 参数一代表键值类型，参数二代表哈希函数，缺省使用 mystl::hash， // 参数三代表键值比较方式，缺省使用 mystl::equal_to template , class KeyEqual = mystl::equal_to> class unordered_set { private: // 使用 hashtable 作为底层机制 typedef hashtable base_type; base_type ht_; public: // 使用 hashtable 的型别 typedef typename base_type::allocator_type allocator_type; typedef typename base_type::key_type key_type; typedef typename base_type::value_type value_type; typedef typename base_type::hasher hasher; typedef typename base_type::key_equal key_equal; typedef typename base_type::size_type size_type; typedef typename base_type::difference_type difference_type; typedef typename base_type::pointer pointer; typedef typename base_type::const_pointer const_pointer; typedef typename base_type::reference reference; typedef typename base_type::const_reference const_reference; typedef typename base_type::const_iterator iterator; typedef typename base_type::const_iterator const_iterator; typedef typename base_type::const_local_iterator local_iterator; typedef typename base_type::const_local_iterator const_local_iterator; allocator_type get_allocator() const { return ht_.get_allocator(); } public: // 构造、复制、移动函数 unordered_set() :ht_(100, Hash(), KeyEqual()) { } explicit unordered_set(size_type bucket_count, const Hash& hash = Hash(), const KeyEqual& equal = KeyEqual()) :ht_(bucket_count, hash, equal) { } template unordered_set(InputIterator first, InputIterator last, const size_type bucket_count = 100, const Hash& hash = Hash(), const KeyEqual& equal = KeyEqual()) : ht_(mystl::max(bucket_count, static_cast(mystl::distance(first, last))), hash, equal) { for (; first != last; ++first) ht_.insert_unique_noresize(*first); } unordered_set(std::initializer_list ilist, const size_type bucket_count = 100, const Hash& hash = Hash(), const KeyEqual& equal = KeyEqual()) :ht_(mystl::max(bucket_count, static_cast(ilist.size())), hash, equal) { for (auto first = ilist.begin(), last = ilist.end(); first != last; ++first) ht_.insert_unique_noresize(*first); } unordered_set(const unordered_set& rhs) :ht_(rhs.ht_) { } unordered_set(unordered_set&& rhs) noexcept : ht_(mystl::move(rhs.ht_)) { } unordered_set& operator=(const unordered_set& rhs) { ht_ = rhs.ht_; return *this; } unordered_set& operator=(unordered_set&& rhs) { ht_ = mystl::move(rhs.ht_); return *this; } unordered_set& operator=(std::initializer_list ilist) { ht_.clear(); ht_.reserve(ilist.size()); for (auto first = ilist.begin(), last = ilist.end(); first != last; ++first) ht_.insert_unique_noresize(*first); return *this; } ~unordered_set() = default; // 迭代器相关 iterator begin() noexcept { return ht_.begin(); } const_iterator begin() const noexcept { return ht_.begin(); } iterator end() noexcept { return ht_.end(); } const_iterator end() const noexcept { return ht_.end(); } const_iterator cbegin() const noexcept { return ht_.cbegin(); } const_iterator cend() const noexcept { return ht_.cend(); } // 容量相关 bool empty() const noexcept { return ht_.empty(); } size_type size() const noexcept { return ht_.size(); } size_type max_size() const noexcept { return ht_.max_size(); } // 修改容器操作 // empalce / empalce_hint template pair emplace(Args&& ...args) { return ht_.emplace_unique(mystl::forward(args)...); } template iterator emplace_hint(const_iterator hint, Args&& ...args) { return ht_.emplace_unique_use_hint(hint, mystl::forward(args)...); } // insert pair insert(const value_type& value) { return ht_.insert_unique(value); } pair insert(value_type&& value) { return ht_.emplace_unique(mystl::move(value)); } iterator insert(const_iterator hint, const value_type& value) { return ht_.insert_unique_use_hint(hint, value); } iterator insert(const_iterator hint, value_type&& value) { return ht_.emplace_unique_use_hint(hint, mystl::move(value)); } template void insert(InputIterator first, InputIterator last) { ht_.insert_unique(first, last); } // erase / clear void erase(iterator it) { ht_.erase(it); } void erase(iterator first, iterator last) { ht_.erase(first, last); } size_type erase(const key_type& key) { return ht_.erase_unique(key); } void clear() { ht_.clear(); } void swap(unordered_set& other) noexcept { ht_.swap(other.ht_); } // 查找相关 size_type count(const key_type& key) const { return ht_.count(key); } iterator find(const key_type& key) { return ht_.find(key); } const_iterator find(const key_type& key) const { return ht_.find(key); } pair equal_range(const key_type& key) { return ht_.equal_range_unique(key); } pair equal_range(const key_type& key) const { return ht_.equal_range_unique(key); } // bucket interface local_iterator begin(size_type n) noexcept { return ht_.begin(n); } const_local_iterator begin(size_type n) const noexcept { return ht_.begin(n); } const_local_iterator cbegin(size_type n) const noexcept { return ht_.cbegin(n); } local_iterator end(size_type n) noexcept { return ht_.end(n); } const_local_iterator end(size_type n) const noexcept { return ht_.end(n); } const_local_iterator cend(size_type n) const noexcept { return ht_.cend(n); } size_type bucket_count() const noexcept { return ht_.bucket_count(); } size_type max_bucket_count() const noexcept { return ht_.max_bucket_count(); } size_type bucket_size(size_type n) const noexcept { return ht_.bucket_size(n); } size_type bucket(const key_type& key) const { return ht_.bucket(key); } // hash policy float load_factor() const noexcept { return ht_.load_factor(); } float max_load_factor() const noexcept { return ht_.max_load_factor(); } void max_load_factor(float ml) { ht_.max_load_factor(ml); } void rehash(size_type count) { ht_.rehash(count); } void reserve(size_type count) { ht_.reserve(count); } hasher hash_fcn() const { return ht_.hash_fcn(); } key_equal key_eq() const { return ht_.key_eq(); } public: friend bool operator==(const unordered_set& lhs, const unordered_set& rhs) { return lhs.ht_.equal_range_unique(rhs.ht_); } friend bool operator!=(const unordered_set& lhs, const unordered_set& rhs) { return !lhs.ht_.equal_range_unique(rhs.ht_); } }; // 重载比较操作符 template bool operator==(const unordered_set& lhs, const unordered_set& rhs) { return lhs == rhs; } template bool operator!=(const unordered_set& lhs, const unordered_set& rhs) { return lhs != rhs; } // 重载 mystl 的 swap template void swap(unordered_set& lhs, unordered_set& rhs) { lhs.swap(rhs); } /*****************************************************************************************/ // 模板类 unordered_multiset，键值允许重复 // 参数一代表键值类型，参数二代表哈希函数，缺省使用 mystl::hash， // 参数三代表键值比较方式，缺省使用 mystl::equal_to template , class KeyEqual = mystl::equal_to> class unordered_multiset { private: // 使用 hashtable 作为底层机制 typedef hashtable base_type; base_type ht_; public: // 使用 hashtable 的型别 typedef typename base_type::allocator_type allocator_type; typedef typename base_type::key_type key_type; typedef typename base_type::value_type value_type; typedef typename base_type::hasher hasher; typedef typename base_type::key_equal key_equal; typedef typename base_type::size_type size_type; typedef typename base_type::difference_type difference_type; typedef typename base_type::pointer pointer; typedef typename base_type::const_pointer const_pointer; typedef typename base_type::reference reference; typedef typename base_type::const_reference const_reference; typedef typename base_type::const_iterator iterator; typedef typename base_type::const_iterator const_iterator; typedef typename base_type::const_local_iterator local_iterator; typedef typename base_type::const_local_iterator const_local_iterator; allocator_type get_allocator() const { return ht_.get_allocator(); } public: // 构造、复制、移动函数 unordered_multiset() :ht_(100, Hash(), KeyEqual()) { } explicit unordered_multiset(size_type bucket_count, const Hash& hash = Hash(), const KeyEqual& equal = KeyEqual()) :ht_(bucket_count, hash, equal) { } template unordered_multiset(InputIterator first, InputIterator last, const size_type bucket_count = 100, const Hash& hash = Hash(), const KeyEqual& equal = KeyEqual()) : ht_(mystl::max(bucket_count, static_cast(mystl::distance(first, last))), hash, equal) { for (; first != last; ++first) ht_.insert_multi_noresize(*first); } unordered_multiset(std::initializer_list ilist, const size_type bucket_count = 100, const Hash& hash = Hash(), const KeyEqual& equal = KeyEqual()) :ht_(mystl::max(bucket_count, static_cast(ilist.size())), hash, equal) { for (auto first = ilist.begin(), last = ilist.end(); first != last; ++first) ht_.insert_multi_noresize(*first); } unordered_multiset(const unordered_multiset& rhs) :ht_(rhs.ht_) { } unordered_multiset(unordered_multiset&& rhs) noexcept : ht_(mystl::move(rhs.ht_)) { } unordered_multiset& operator=(const unordered_multiset& rhs) { ht_ = rhs.ht_; return *this; } unordered_multiset& operator=(unordered_multiset&& rhs) { ht_ = mystl::move(rhs.ht_); return *this; } unordered_multiset& operator=(std::initializer_list ilist) { ht_.clear(); ht_.reserve(ilist.size()); for (auto first = ilist.begin(), last = ilist.end(); first != last; ++first) ht_.insert_multi_noresize(*first); return *this; } ~unordered_multiset() = default; // 迭代器相关 iterator begin() noexcept { return ht_.begin(); } const_iterator begin() const noexcept { return ht_.begin(); } iterator end() noexcept { return ht_.end(); } const_iterator end() const noexcept { return ht_.end(); } const_iterator cbegin() const noexcept { return ht_.cbegin(); } const_iterator cend() const noexcept { return ht_.cend(); } // 容量相关 bool empty() const noexcept { return ht_.empty(); } size_type size() const noexcept { return ht_.size(); } size_type max_size() const noexcept { return ht_.max_size(); } // 修改容器相关 // emplace / emplace_hint template iterator emplace(Args&& ...args) { return ht_.emplace_multi(mystl::forward(args)...); } template iterator emplace_hint(const_iterator hint, Args&& ...args) { return ht_.emplace_multi_use_hint(hint, mystl::forward(args)...); } // insert iterator insert(const value_type& value) { return ht_.insert_multi(value); } iterator insert(value_type&& value) { return ht_.emplace_multi(mystl::move(value)); } iterator insert(const_iterator hint, const value_type& value) { return ht_.insert_multi_use_hint(hint, value); } iterator insert(const_iterator hint, value_type&& value) { return ht_.emplace_multi_use_hint(hint, mystl::move(value)); } template void insert(InputIterator first, InputIterator last) { ht_.insert_multi(first, last); } // erase / clear void erase(iterator it) { ht_.erase(it); } void erase(iterator first, iterator last) { ht_.erase(first, last); } size_type erase(const key_type& key) { return ht_.erase_multi(key); } void clear() { ht_.clear(); } void swap(unordered_multiset& other) noexcept { ht_.swap(other.ht_); } // 查找相关 size_type count(const key_type& key) const { return ht_.count(key); } iterator find(const key_type& key) { return ht_.find(key); } const_iterator find(const key_type& key) const { return ht_.find(key); } pair equal_range(const key_type& key) { return ht_.equal_range_multi(key); } pair equal_range(const key_type& key) const { return ht_.equal_range_multi(key); } // bucket interface local_iterator begin(size_type n) noexcept { return ht_.begin(n); } const_local_iterator begin(size_type n) const noexcept { return ht_.begin(n); } const_local_iterator cbegin(size_type n) const noexcept { return ht_.cbegin(n); } local_iterator end(size_type n) noexcept { return ht_.end(n); } const_local_iterator end(size_type n) const noexcept { return ht_.end(n); } const_local_iterator cend(size_type n) const noexcept { return ht_.cend(n); } size_type bucket_count() const noexcept { return ht_.bucket_count(); } size_type max_bucket_count() const noexcept { return ht_.max_bucket_count(); } size_type bucket_size(size_type n) const noexcept { return ht_.bucket_size(n); } size_type bucket(const key_type& key) const { return ht_.bucket(key); } // hash policy float load_factor() const noexcept { return ht_.load_factor(); } float max_load_factor() const noexcept { return ht_.max_load_factor(); } void max_load_factor(float ml) { ht_.max_load_factor(ml); } void rehash(size_type count) { ht_.rehash(count); } void reserve(size_type count) { ht_.reserve(count); } hasher hash_fcn() const { return ht_.hash_fcn(); } key_equal key_eq() const { return ht_.key_eq(); } public: friend bool operator==(const unordered_multiset& lhs, const unordered_multiset& rhs) { return lhs.ht_.equal_range_multi(rhs.ht_); } friend bool operator!=(const unordered_multiset& lhs, const unordered_multiset& rhs) { return !lhs.ht_.equal_range_multi(rhs.ht_); } }; // 重载比较操作符 template bool operator==(const unordered_multiset& lhs, const unordered_multiset& rhs) { return lhs == rhs; } template bool operator!=(const unordered_multiset& lhs, const unordered_multiset& rhs) { return lhs != rhs; } // 重载 mystl 的 swap template void swap(unordered_multiset& lhs, unordered_multiset& rhs) { lhs.swap(rhs); } } // namespace mystl #endif // !MYTINYSTL_UNORDERED_SET_H_ ================================================ FILE: MyTinySTL/util.h ================================================ #ifndef MYTINYSTL_UTIL_H_ #define MYTINYSTL_UTIL_H_ // 这个文件包含一些通用工具，包括 move, forward, swap 等函数，以及 pair 等 #include #include "type_traits.h" namespace mystl { // move template typename std::remove_reference::type&& move(T&& arg) noexcept { return static_cast::type&&>(arg); } // forward template T&& forward(typename std::remove_reference::type& arg) noexcept { return static_cast(arg); } template T&& forward(typename std::remove_reference::type&& arg) noexcept { static_assert(!std::is_lvalue_reference::value, "bad forward"); return static_cast(arg); } // swap template void swap(Tp& lhs, Tp& rhs) { auto tmp(mystl::move(lhs)); lhs = mystl::move(rhs); rhs = mystl::move(tmp); } template ForwardIter2 swap_range(ForwardIter1 first1, ForwardIter1 last1, ForwardIter2 first2) { for (; first1 != last1; ++first1, (void) ++first2) mystl::swap(*first1, *first2); return first2; } template void swap(Tp(&a)[N], Tp(&b)[N]) { mystl::swap_range(a, a + N, b); } // -------------------------------------------------------------------------------------- // pair // 结构体模板 : pair // 两个模板参数分别表示两个数据的类型 // 用 first 和 second 来分别取出第一个数据和第二个数据 template struct pair { typedef Ty1 first_type; typedef Ty2 second_type; first_type first; // 保存第一个数据 second_type second; // 保存第二个数据 // default constructiable template ::value && std::is_default_constructible::value, void>::type> constexpr pair() : first(), second() { } // implicit constructiable for this type template ::value && std::is_copy_constructible::value && std::is_convertible::value && std::is_convertible::value, int>::type = 0> constexpr pair(const Ty1& a, const Ty2& b) : first(a), second(b) { } // explicit constructible for this type template ::value && std::is_copy_constructible::value && (!std::is_convertible::value || !std::is_convertible::value), int>::type = 0> explicit constexpr pair(const Ty1& a, const Ty2& b) : first(a), second(b) { } pair(const pair& rhs) = default; pair(pair&& rhs) = default; // implicit constructiable for other type template ::value && std::is_constructible::value && std::is_convertible::value && std::is_convertible::value, int>::type = 0> constexpr pair(Other1&& a, Other2&& b) : first(mystl::forward(a)), second(mystl::forward(b)) { } // explicit constructiable for other type template ::value && std::is_constructible::value && (!std::is_convertible::value || !std::is_convertible::value), int>::type = 0> explicit constexpr pair(Other1&& a, Other2&& b) : first(mystl::forward(a)), second(mystl::forward(b)) { } // implicit constructiable for other pair template ::value && std::is_constructible::value && std::is_convertible::value && std::is_convertible::value, int>::type = 0> constexpr pair(const pair& other) : first(other.first), second(other.second) { } // explicit constructiable for other pair template ::value && std::is_constructible::value && (!std::is_convertible::value || !std::is_convertible::value), int>::type = 0> explicit constexpr pair(const pair& other) : first(other.first), second(other.second) { } // implicit constructiable for other pair template ::value && std::is_constructible::value && std::is_convertible::value && std::is_convertible::value, int>::type = 0> constexpr pair(pair&& other) : first(mystl::forward(other.first)), second(mystl::forward(other.second)) { } // explicit constructiable for other pair template ::value && std::is_constructible::value && (!std::is_convertible::value || !std::is_convertible::value), int>::type = 0> explicit constexpr pair(pair&& other) : first(mystl::forward(other.first)), second(mystl::forward(other.second)) { } // copy assign for this pair pair& operator=(const pair& rhs) { if (this != &rhs) { first = rhs.first; second = rhs.second; } return *this; } // move assign for this pair pair& operator=(pair&& rhs) { if (this != &rhs) { first = mystl::move(rhs.first); second = mystl::move(rhs.second); } return *this; } // copy assign for other pair template pair& operator=(const pair& other) { first = other.first; second = other.second; return *this; } // move assign for other pair template pair& operator=(pair&& other) { first = mystl::forward(other.first); second = mystl::forward(other.second); return *this; } ~pair() = default; void swap(pair& other) { if (this != &other) { mystl::swap(first, other.first); mystl::swap(second, other.second); } } }; // 重载比较操作符 template bool operator==(const pair& lhs, const pair& rhs) { return lhs.first == rhs.first && lhs.second == rhs.second; } template bool operator<(const pair& lhs, const pair& rhs) { return lhs.first < rhs.first || (lhs.first == rhs.first && lhs.second < rhs.second); } template bool operator!=(const pair& lhs, const pair& rhs) { return !(lhs == rhs); } template bool operator>(const pair& lhs, const pair& rhs) { return rhs < lhs; } template bool operator<=(const pair& lhs, const pair& rhs) { return !(rhs < lhs); } template bool operator>=(const pair& lhs, const pair& rhs) { return !(lhs < rhs); } // 重载 mystl 的 swap template void swap(pair& lhs, pair& rhs) { lhs.swap(rhs); } // 全局函数，让两个数据成为一个 pair template pair make_pair(Ty1&& first, Ty2&& second) { return pair(mystl::forward(first), mystl::forward(second)); } } #endif // !MYTINYSTL_UTIL_H_ ================================================ FILE: MyTinySTL/vector.h ================================================ #ifndef MYTINYSTL_VECTOR_H_ #define MYTINYSTL_VECTOR_H_ // 这个头文件包含一个模板类 vector // vector : 向量 // notes: // // 异常保证： // mystl::vecotr 满足基本异常保证，部分函数无异常保证，并对以下函数做强异常安全保证： // * emplace // * emplace_back // * push_back // 当 std::is_nothrow_move_assignable::value == true 时，以下函数也满足强异常保证： // * reserve // * resize // * insert #include #include "iterator.h" #include "memory.h" #include "util.h" #include "exceptdef.h" #include "algo.h" namespace mystl { #ifdef max #pragma message("#undefing marco max") #undef max #endif // max #ifdef min #pragma message("#undefing marco min") #undef min #endif // min // 模板类: vector // 模板参数 T 代表类型 template class vector { static_assert(!std::is_same::value, "vector is abandoned in mystl"); public: // vector 的嵌套型别定义 typedef mystl::allocator allocator_type; typedef mystl::allocator data_allocator; typedef typename allocator_type::value_type value_type; typedef typename allocator_type::pointer pointer; typedef typename allocator_type::const_pointer const_pointer; typedef typename allocator_type::reference reference; typedef typename allocator_type::const_reference const_reference; typedef typename allocator_type::size_type size_type; typedef typename allocator_type::difference_type difference_type; typedef value_type* iterator; typedef const value_type* const_iterator; typedef mystl::reverse_iterator reverse_iterator; typedef mystl::reverse_iterator const_reverse_iterator; allocator_type get_allocator() { return data_allocator(); } private: iterator begin_; // 表示目前使用空间的头部 iterator end_; // 表示目前使用空间的尾部 iterator cap_; // 表示目前储存空间的尾部 public: // 构造、复制、移动、析构函数 vector() noexcept { try_init(); } explicit vector(size_type n) { fill_init(n, value_type()); } vector(size_type n, const value_type& value) { fill_init(n, value); } template ::value, int>::type = 0> vector(Iter first, Iter last) { MYSTL_DEBUG(!(last < first)); range_init(first, last); } vector(const vector& rhs) { range_init(rhs.begin_, rhs.end_); } vector(vector&& rhs) noexcept :begin_(rhs.begin_), end_(rhs.end_), cap_(rhs.cap_) { rhs.begin_ = nullptr; rhs.end_ = nullptr; rhs.cap_ = nullptr; } vector(std::initializer_list ilist) { range_init(ilist.begin(), ilist.end()); } vector& operator=(const vector& rhs); vector& operator=(vector&& rhs) noexcept; vector& operator=(std::initializer_list ilist) { vector tmp(ilist.begin(), ilist.end()); swap(tmp); return *this; } ~vector() { destroy_and_recover(begin_, end_, cap_ - begin_); begin_ = end_ = cap_ = nullptr; } public: // 迭代器相关操作 iterator begin() noexcept { return begin_; } const_iterator begin() const noexcept { return begin_; } iterator end() noexcept { return end_; } const_iterator end() const noexcept { return end_; } reverse_iterator rbegin() noexcept { return reverse_iterator(end()); } const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); } reverse_iterator rend() noexcept { return reverse_iterator(begin()); } const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); } const_iterator cbegin() const noexcept { return begin(); } const_iterator cend() const noexcept { return end(); } const_reverse_iterator crbegin() const noexcept { return rbegin(); } const_reverse_iterator crend() const noexcept { return rend(); } // 容量相关操作 bool empty() const noexcept { return begin_ == end_; } size_type size() const noexcept { return static_cast(end_ - begin_); } size_type max_size() const noexcept { return static_cast(-1) / sizeof(T); } size_type capacity() const noexcept { return static_cast(cap_ - begin_); } void reserve(size_type n); void shrink_to_fit(); // 访问元素相关操作 reference operator[](size_type n) { MYSTL_DEBUG(n < size()); return *(begin_ + n); } const_reference operator[](size_type n) const { MYSTL_DEBUG(n < size()); return *(begin_ + n); } reference at(size_type n) { THROW_OUT_OF_RANGE_IF(!(n < size()), "vector::at() subscript out of range"); return (*this)[n]; } const_reference at(size_type n) const { THROW_OUT_OF_RANGE_IF(!(n < size()), "vector::at() subscript out of range"); return (*this)[n]; } reference front() { MYSTL_DEBUG(!empty()); return *begin_; } const_reference front() const { MYSTL_DEBUG(!empty()); return *begin_; } reference back() { MYSTL_DEBUG(!empty()); return *(end_ - 1); } const_reference back() const { MYSTL_DEBUG(!empty()); return *(end_ - 1); } pointer data() noexcept { return begin_; } const_pointer data() const noexcept { return begin_; } // 修改容器相关操作 // assign void assign(size_type n, const value_type& value) { fill_assign(n, value); } template ::value, int>::type = 0> void assign(Iter first, Iter last) { MYSTL_DEBUG(!(last < first)); copy_assign(first, last, iterator_category(first)); } void assign(std::initializer_list il) { copy_assign(il.begin(), il.end(), mystl::forward_iterator_tag{}); } // emplace / emplace_back template iterator emplace(const_iterator pos, Args&& ...args); template void emplace_back(Args&& ...args); // push_back / pop_back void push_back(const value_type& value); void push_back(value_type&& value) { emplace_back(mystl::move(value)); } void pop_back(); // insert iterator insert(const_iterator pos, const value_type& value); iterator insert(const_iterator pos, value_type&& value) { return emplace(pos, mystl::move(value)); } iterator insert(const_iterator pos, size_type n, const value_type& value) { MYSTL_DEBUG(pos >= begin() && pos <= end()); return fill_insert(const_cast(pos), n, value); } template ::value, int>::type = 0> void insert(const_iterator pos, Iter first, Iter last) { MYSTL_DEBUG(pos >= begin() && pos <= end() && !(last < first)); copy_insert(const_cast(pos), first, last); } // erase / clear iterator erase(const_iterator pos); iterator erase(const_iterator first, const_iterator last); void clear() { erase(begin(), end()); } // resize / reverse void resize(size_type new_size) { return resize(new_size, value_type()); } void resize(size_type new_size, const value_type& value); void reverse() { mystl::reverse(begin(), end()); } // swap void swap(vector& rhs) noexcept; private: // helper functions // initialize / destroy void try_init() noexcept; void init_space(size_type size, size_type cap); void fill_init(size_type n, const value_type& value); template void range_init(Iter first, Iter last); void destroy_and_recover(iterator first, iterator last, size_type n); // calculate the growth size size_type get_new_cap(size_type add_size); // assign void fill_assign(size_type n, const value_type& value); template void copy_assign(IIter first, IIter last, input_iterator_tag); template void copy_assign(FIter first, FIter last, forward_iterator_tag); // reallocate template void reallocate_emplace(iterator pos, Args&& ...args); void reallocate_insert(iterator pos, const value_type& value); // insert iterator fill_insert(iterator pos, size_type n, const value_type& value); template void copy_insert(iterator pos, IIter first, IIter last); // shrink_to_fit void reinsert(size_type size); }; /*****************************************************************************************/ // 复制赋值操作符 template vector& vector::operator=(const vector& rhs) { if (this != &rhs) { const auto len = rhs.size(); if (len > capacity()) { vector tmp(rhs.begin(), rhs.end()); swap(tmp); } else if (size() >= len) { auto i = mystl::copy(rhs.begin(), rhs.end(), begin()); data_allocator::destroy(i, end_); end_ = begin_ + len; } else { mystl::copy(rhs.begin(), rhs.begin() + size(), begin_); mystl::uninitialized_copy(rhs.begin() + size(), rhs.end(), end_); cap_ = end_ = begin_ + len; } } return *this; } // 移动赋值操作符 template vector& vector::operator=(vector&& rhs) noexcept { destroy_and_recover(begin_, end_, cap_ - begin_); begin_ = rhs.begin_; end_ = rhs.end_; cap_ = rhs.cap_; rhs.begin_ = nullptr; rhs.end_ = nullptr; rhs.cap_ = nullptr; return *this; } // 预留空间大小，当原容量小于要求大小时，才会重新分配 template void vector::reserve(size_type n) { if (capacity() < n) { THROW_LENGTH_ERROR_IF(n > max_size(), "n can not larger than max_size() in vector::reserve(n)"); const auto old_size = size(); auto tmp = data_allocator::allocate(n); mystl::uninitialized_move(begin_, end_, tmp); data_allocator::deallocate(begin_, cap_ - begin_); begin_ = tmp; end_ = tmp + old_size; cap_ = begin_ + n; } } // 放弃多余的容量 template void vector::shrink_to_fit() { if (end_ < cap_) { reinsert(size()); } } // 在 pos 位置就地构造元素，避免额外的复制或移动开销 template template typename vector::iterator vector::emplace(const_iterator pos, Args&& ...args) { MYSTL_DEBUG(pos >= begin() && pos <= end()); iterator xpos = const_cast(pos); const size_type n = xpos - begin_; if (end_ != cap_ && xpos == end_) { data_allocator::construct(mystl::address_of(*end_), mystl::forward(args)...); ++end_; } else if (end_ != cap_) { auto new_end = end_; data_allocator::construct(mystl::address_of(*end_), *(end_ - 1)); ++new_end; mystl::copy_backward(xpos, end_ - 1, end_); *xpos = value_type(mystl::forward(args)...); end_ = new_end; } else { reallocate_emplace(xpos, mystl::forward(args)...); } return begin() + n; } // 在尾部就地构造元素，避免额外的复制或移动开销 template template void vector::emplace_back(Args&& ...args) { if (end_ < cap_) { data_allocator::construct(mystl::address_of(*end_), mystl::forward(args)...); ++end_; } else { reallocate_emplace(end_, mystl::forward(args)...); } } // 在尾部插入元素 template void vector::push_back(const value_type& value) { if (end_ != cap_) { data_allocator::construct(mystl::address_of(*end_), value); ++end_; } else { reallocate_insert(end_, value); } } // 弹出尾部元素 template void vector::pop_back() { MYSTL_DEBUG(!empty()); data_allocator::destroy(end_ - 1); --end_; } // 在 pos 处插入元素 template typename vector::iterator vector::insert(const_iterator pos, const value_type& value) { MYSTL_DEBUG(pos >= begin() && pos <= end()); iterator xpos = const_cast(pos); const size_type n = pos - begin_; if (end_ != cap_ && xpos == end_) { data_allocator::construct(mystl::address_of(*end_), value); ++end_; } else if (end_ != cap_) { auto new_end = end_; data_allocator::construct(mystl::address_of(*end_), *(end_ - 1)); ++new_end; auto value_copy = value; // 避免元素因以下复制操作而被改变 mystl::copy_backward(xpos, end_ - 1, end_); *xpos = mystl::move(value_copy); end_ = new_end; } else { reallocate_insert(xpos, value); } return begin_ + n; } // 删除 pos 位置上的元素 template typename vector::iterator vector::erase(const_iterator pos) { MYSTL_DEBUG(pos >= begin() && pos < end()); iterator xpos = begin_ + (pos - begin()); mystl::move(xpos + 1, end_, xpos); data_allocator::destroy(end_ - 1); --end_; return xpos; } // 删除[first, last)上的元素 template typename vector::iterator vector::erase(const_iterator first, const_iterator last) { MYSTL_DEBUG(first >= begin() && last <= end() && !(last < first)); const auto n = first - begin(); iterator r = begin_ + (first - begin()); data_allocator::destroy(mystl::move(r + (last - first), end_, r), end_); end_ = end_ - (last - first); return begin_ + n; } // 重置容器大小 template void vector::resize(size_type new_size, const value_type& value) { if (new_size < size()) { erase(begin() + new_size, end()); } else { insert(end(), new_size - size(), value); } } // 与另一个 vector 交换 template void vector::swap(vector& rhs) noexcept { if (this != &rhs) { mystl::swap(begin_, rhs.begin_); mystl::swap(end_, rhs.end_); mystl::swap(cap_, rhs.cap_); } } /*****************************************************************************************/ // helper function // try_init 函数，若分配失败则忽略，不抛出异常 template void vector::try_init() noexcept { try { begin_ = data_allocator::allocate(16); end_ = begin_; cap_ = begin_ + 16; } catch (...) { begin_ = nullptr; end_ = nullptr; cap_ = nullptr; } } // init_space 函数 template void vector::init_space(size_type size, size_type cap) { try { begin_ = data_allocator::allocate(cap); end_ = begin_ + size; cap_ = begin_ + cap; } catch (...) { begin_ = nullptr; end_ = nullptr; cap_ = nullptr; throw; } } // fill_init 函数 template void vector:: fill_init(size_type n, const value_type& value) { const size_type init_size = mystl::max(static_cast(16), n); init_space(n, init_size); mystl::uninitialized_fill_n(begin_, n, value); } // range_init 函数 template template void vector:: range_init(Iter first, Iter last) { const size_type len = mystl::distance(first, last); const size_type init_size = mystl::max(len, static_cast(16)); init_space(len, init_size); mystl::uninitialized_copy(first, last, begin_); } // destroy_and_recover 函数 template void vector:: destroy_and_recover(iterator first, iterator last, size_type n) { data_allocator::destroy(first, last); data_allocator::deallocate(first, n); } // get_new_cap 函数 template typename vector::size_type vector:: get_new_cap(size_type add_size) { const auto old_size = capacity(); THROW_LENGTH_ERROR_IF(old_size > max_size() - add_size, "vector's size too big"); if (old_size > max_size() - old_size / 2) { return old_size + add_size > max_size() - 16 ? old_size + add_size : old_size + add_size + 16; } const size_type new_size = old_size == 0 ? mystl::max(add_size, static_cast(16)) : mystl::max(old_size + old_size / 2, old_size + add_size); return new_size; } // fill_assign 函数 template void vector:: fill_assign(size_type n, const value_type& value) { if (n > capacity()) { vector tmp(n, value); swap(tmp); } else if (n > size()) { mystl::fill(begin(), end(), value); end_ = mystl::uninitialized_fill_n(end_, n - size(), value); } else { erase(mystl::fill_n(begin_, n, value), end_); } } // copy_assign 函数 template template void vector:: copy_assign(IIter first, IIter last, input_iterator_tag) { auto cur = begin_; for (; first != last && cur != end_; ++first, ++cur) { *cur = *first; } if (first == last) { erase(cur, end_); } else { insert(end_, first, last); } } // 用 [first, last) 为容器赋值 template template void vector:: copy_assign(FIter first, FIter last, forward_iterator_tag) { const size_type len = mystl::distance(first, last); if (len > capacity()) { vector tmp(first, last); swap(tmp); } else if (size() >= len) { auto new_end = mystl::copy(first, last, begin_); data_allocator::destroy(new_end, end_); end_ = new_end; } else { auto mid = first; mystl::advance(mid, size()); mystl::copy(first, mid, begin_); auto new_end = mystl::uninitialized_copy(mid, last, end_); end_ = new_end; } } // 重新分配空间并在 pos 处就地构造元素 template template void vector:: reallocate_emplace(iterator pos, Args&& ...args) { const auto new_size = get_new_cap(1); auto new_begin = data_allocator::allocate(new_size); auto new_end = new_begin; try { new_end = mystl::uninitialized_move(begin_, pos, new_begin); data_allocator::construct(mystl::address_of(*new_end), mystl::forward(args)...); ++new_end; new_end = mystl::uninitialized_move(pos, end_, new_end); } catch (...) { data_allocator::deallocate(new_begin, new_size); throw; } destroy_and_recover(begin_, end_, cap_ - begin_); begin_ = new_begin; end_ = new_end; cap_ = new_begin + new_size; } // 重新分配空间并在 pos 处插入元素 template void vector::reallocate_insert(iterator pos, const value_type& value) { const auto new_size = get_new_cap(1); auto new_begin = data_allocator::allocate(new_size); auto new_end = new_begin; const value_type& value_copy = value; try { new_end = mystl::uninitialized_move(begin_, pos, new_begin); data_allocator::construct(mystl::address_of(*new_end), value_copy); ++new_end; new_end = mystl::uninitialized_move(pos, end_, new_end); } catch (...) { data_allocator::deallocate(new_begin, new_size); throw; } destroy_and_recover(begin_, end_, cap_ - begin_); begin_ = new_begin; end_ = new_end; cap_ = new_begin + new_size; } // fill_insert 函数 template typename vector::iterator vector:: fill_insert(iterator pos, size_type n, const value_type& value) { if (n == 0) return pos; const size_type xpos = pos - begin_; const value_type value_copy = value; // 避免被覆盖 if (static_cast(cap_ - end_) >= n) { // 如果备用空间大于等于增加的空间 const size_type after_elems = end_ - pos; auto old_end = end_; if (after_elems > n) { mystl::uninitialized_copy(end_ - n, end_, end_); end_ += n; mystl::move_backward(pos, old_end - n, old_end); mystl::uninitialized_fill_n(pos, n, value_copy); } else { end_ = mystl::uninitialized_fill_n(end_, n - after_elems, value_copy); end_ = mystl::uninitialized_move(pos, old_end, end_); mystl::uninitialized_fill_n(pos, after_elems, value_copy); } } else { // 如果备用空间不足 const auto new_size = get_new_cap(n); auto new_begin = data_allocator::allocate(new_size); auto new_end = new_begin; try { new_end = mystl::uninitialized_move(begin_, pos, new_begin); new_end = mystl::uninitialized_fill_n(new_end, n, value); new_end = mystl::uninitialized_move(pos, end_, new_end); } catch (...) { destroy_and_recover(new_begin, new_end, new_size); throw; } data_allocator::deallocate(begin_, cap_ - begin_); begin_ = new_begin; end_ = new_end; cap_ = begin_ + new_size; } return begin_ + xpos; } // copy_insert 函数 template template void vector:: copy_insert(iterator pos, IIter first, IIter last) { if (first == last) return; const auto n = mystl::distance(first, last); if ((cap_ - end_) >= n) { // 如果备用空间大小足够 const auto after_elems = end_ - pos; auto old_end = end_; if (after_elems > n) { end_ = mystl::uninitialized_copy(end_ - n, end_, end_); mystl::move_backward(pos, old_end - n, old_end); mystl::uninitialized_copy(first, last, pos); } else { auto mid = first; mystl::advance(mid, after_elems); end_ = mystl::uninitialized_copy(mid, last, end_); end_ = mystl::uninitialized_move(pos, old_end, end_); mystl::uninitialized_copy(first, mid, pos); } } else { // 备用空间不足 const auto new_size = get_new_cap(n); auto new_begin = data_allocator::allocate(new_size); auto new_end = new_begin; try { new_end = mystl::uninitialized_move(begin_, pos, new_begin); new_end = mystl::uninitialized_copy(first, last, new_end); new_end = mystl::uninitialized_move(pos, end_, new_end); } catch (...) { destroy_and_recover(new_begin, new_end, new_size); throw; } data_allocator::deallocate(begin_, cap_ - begin_); begin_ = new_begin; end_ = new_end; cap_ = begin_ + new_size; } } // reinsert 函数 template void vector::reinsert(size_type size) { auto new_begin = data_allocator::allocate(size); try { mystl::uninitialized_move(begin_, end_, new_begin); } catch (...) { data_allocator::deallocate(new_begin, size); throw; } data_allocator::deallocate(begin_, cap_ - begin_); begin_ = new_begin; end_ = begin_ + size; cap_ = begin_ + size; } /*****************************************************************************************/ // 重载比较操作符 template bool operator==(const vector& lhs, const vector& rhs) { return lhs.size() == rhs.size() && mystl::equal(lhs.begin(), lhs.end(), rhs.begin()); } template bool operator<(const vector& lhs, const vector& rhs) { return mystl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); } template bool operator!=(const vector& lhs, const vector& rhs) { return !(lhs == rhs); } template bool operator>(const vector& lhs, const vector& rhs) { return rhs < lhs; } template bool operator<=(const vector& lhs, const vector& rhs) { return !(rhs < lhs); } template bool operator>=(const vector& lhs, const vector& rhs) { return !(lhs < rhs); } // 重载 mystl 的 swap template void swap(vector& lhs, vector& rhs) { lhs.swap(rhs); } } // namespace mystl #endif // !MYTINYSTL_VECTOR_H_ ================================================ FILE: README.md ================================================ MyTinySTL ===== [![Build Status](https://travis-ci.org/Alinshans/MyTinySTL.svg?branch=master)](https://travis-ci.org/Alinshans/MyTinySTL) [![Build Status](https://ci.appveyor.com/api/projects/status/github/Alinshans/MyTinySTL?branch=master&svg=true)](https://ci.appveyor.com/project/Alinshans/mytinystl) [![Release](https://img.shields.io/github/release/Alinshans/MyTinySTL.svg)](https://github.com/Alinshans/MyTinySTL/releases) [![License](https://img.shields.io/badge/License-MIT%20License-blue.svg)](https://opensource.org/licenses/MIT) [![Chat](https://img.shields.io/badge/chat-on%20gitter-FF6EB4.svg)](https://gitter.im/alinshans/MyTinySTL) ## 简介 基于 `C++11` 的 `tinySTL`，这是我的第一个项目，使用了中文文档与中文注释，有不规范或不当的地方还请海涵。刚开始是作为新手练习用途，直到现在已经发布了 `2.x.x` 版本。实现了大部分 STL 中的容器与函数，但仍存在许多不足与 bug 。从 `2.x.x` 版本开始，本项目会进入长期维护的阶段，即基本不会增加新的内容，只修复发现的 bug。如发现错误，还请在 [`Issues`](https://github.com/Alinshans/MyTinySTL/issues) 中指出，欢迎 `Fork` 和 [`Pull requests`](https://github.com/Alinshans/MyTinySTL/pulls) 改善代码，谢谢！ ## 支持 * 操作系统 * linux * windows * osx * 编译器 * g++ 5.4 或以上 * clang++ 3.5 或以上 * msvc 14.0 或以上 ## 需要 * 使用 cmake 2.8 来构建项目（**可选**） ## 运行 如果你想要运行测试，请先阅读 [这个](https://github.com/Alinshans/MyTinySTL/blob/master/Test/README.md) 。 * gcc/clang on linux/osx 1. 克隆仓库 ```bash $ git clone git@github.com:Alinshans/MyTinySTL.git $ cd MyTinySTL ``` 2. 构建并运行 ```bash $ mkdir build && cd build $ cmake .. $ make $ cd ../bin && ./stltest ``` * msvc on windows 1. 克隆仓库或 [Download ZIP](https://github.com/Alinshans/MyTinySTL/archive/master.zip) 2. 使用 `vs2015`（或 `vs2017`）打开 `MSVC/MyTinySTL_VS2015.sln`，配置成 `Release` 模式，（Ctrl + F5）开始执行。 ## 文档 见 [Wiki](https://github.com/Alinshans/MyTinySTL/wiki)。 ## 测试 见 [Test](https://github.com/Alinshans/MyTinySTL/tree/master/Test)。 --- ## Introduction This is a `tinySTL` based on `C++11`, which is my first project for practice. I use the Chinese documents and annotations for convenience, maybe there will be an English version later, but now I have no time to do that yet. Now I have released version `2.0.0`. I have achieved the vast majority of the containers and functions of `STL`, and there may be some deficiencies and bugs. From the version `2.x.x`, the project will enter the stage of long-term maintenance, i.e., I probably will not add new content but only fix bugs found. If you find any bugs, please point out that in [`Issues`](https://github.com/Alinshans/MyTinySTL/issues), or make a [`Pull requests`](https://github.com/Alinshans/MyTinySTL/pulls) to improve it, thanks! ## Supported * os * linux * windows * osx * complier * g++ 5.4 or later * clang++ 3.5 or later * msvc 14.0 or later ## Required * Use cmake 2.8 to build this project (**Optional**) ## Run test If you want to run the test, please read [this](https://github.com/Alinshans/MyTinySTL/blob/master/Test/README.md) first. * gcc/clang on linux/osx 1. git clone ```bash $ git clone git@github.com:Alinshans/MyTinySTL.git $ cd MyTinySTL ``` 2. build and run ```bash $ mkdir build && cd build $ cmake .. $ make $ cd ../bin && ./stltest ``` * msvc on windows 1. git clone or [Download ZIP](https://github.com/Alinshans/MyTinySTL/archive/master.zip) 2. use `vs2015`(or `vs2017`) open the file `MSVC/MyTinySTL_VS2015.sln`, configured in `Release`, run this project(Ctrl + F5). ## Documents See [Wiki](https://github.com/Alinshans/MyTinySTL/wiki). ## Test See [Test](https://github.com/Alinshans/MyTinySTL/tree/master/Test). ================================================ FILE: Test/CMakeLists.txt ================================================ include_directories(${PROJECT_SOURCE_DIR}/MyTinySTL) set(APP_SRC test.cpp) set(EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/bin) add_executable(stltest ${APP_SRC}) ================================================ FILE: Test/Lib/redbud/io/color.h ================================================ // ============================================================================ // Copyright (c) 2017 Alinshans. All rights reserved. // Licensed under the MIT License. See LICENSE for details. // // Header File : redbud/io/color.h // // This file is used to control font format and color in the terminal, which // refers to a project on github, see https://github.com/agauniyal/rang . // ============================================================================ #ifndef ALINSHANS_REDBUD_IO_COLOR_H_ #define ALINSHANS_REDBUD_IO_COLOR_H_ #include "../platform.h" #if defined(REDBUD_LINUX) || defined(REDBUD_OSX) #include // getenv #include // strstr #elif defined(REDBUD_WIN) #include #include #endif #include #include #include namespace redbud { namespace io { // ============================================================================ // Enumerates the ANSI escape code corresponding to the font attributes. // See https://en.wikipedia.org/wiki/ANSI_escape_code for details. // // Example: // using namespace redbud::io; // std::cout << fg::red << "This text has a red foreground color\n"; // std::cout << bg::green << "This text has a green background color\n" // ============================================================================ // Sets the text format, some of them is not widely supported. enum class format { reset = 0, // All attributes off. bold = 1, // Bold or increased intensity. faint = 2, // Faint (decreased intensity). italic = 3, // Italian font. underline = 4, // Underline. blinkslow = 5, // Blink slowly. blinkrapid = 6, // Blink quickly. inverse = 7, // Swap foreground and background. conceal = 8, // Hide the text. strikeline = 9 // Characters legible, but marked for deletion. }; // Sets the foreground color. enum class fg { black = 30, red = 31, green = 32, yellow = 33, blue = 34, purple = 35, cyan = 36, white = 37, reserve = 38, reset = 39 }; // Sets the background color. enum class bg { black = 40, red = 41, green = 42, yellow = 43, blue = 44, purple = 45, cyan = 46, white = 47, reserve = 38, reset = 39 }; // Sets the highlight foreground color. enum class hfg { black = 90, red = 91, green = 92, yellow = 93, blue = 94, purple = 95, cyan = 96, white = 97 }; // Sets the highlight background color. enum class hbg { black = 100, red = 101, green = 102, yellow = 103, blue = 104, purple = 105, cyan = 106, white = 107 }; // Sets the control state. enum class state { automatic = 0, // Automatic control. manual = 1 // Manual control. }; // ---------------------------------------------------------------------------- // Details namespace details { // Manages associated stream buffer. inline const std::streambuf*& get_coutbuf() { static const std::streambuf* pout = std::cout.rdbuf(); return pout; } inline const std::streambuf*& get_cerrbuf() { static const std::streambuf* perr = std::cerr.rdbuf(); return perr; } inline const std::streambuf*& get_clogbuf() { static const std::streambuf* plog = std::clog.rdbuf(); return plog; } // Gets an unique integer to use as index to iword() inline int get_iword() { static int i = std::ios_base::xalloc(); return i; } // Determines whether the terminal color of this system can be modified. inline bool is_modifiable() { #if defined(REDBUD_LINUX) || defined(REDBUD_OSX) static constexpr const char* terms[] = { "ansi", "color", "console", "cygwin", "gnome", "konsole", "kterm", "linux", "msys", "putty", "rxvt", "screen", "vt100", "xterm" }; const char *penv = std::getenv("TERM"); if (penv == nullptr) { return false; } bool result = false; for (const auto& t : terms) { if (std::strstr(penv, t) != nullptr) { result = true; break; } } #elif defined(REDBUD_WIN) static constexpr bool result = true; #endif return result; } /// Determines whether the buffer stream reaches the end. inline bool is_terminal(const std::streambuf* buf) { if (buf == get_coutbuf()) { #if defined(REDBUD_LINUX) || defined(REDBUD_OSX) return isatty(fileno(stdout)) ? true : false; #elif defined(REDBUD_WIN) return _isatty(_fileno(stdout)) ? true : false; #endif } if (buf == get_cerrbuf() || buf == get_clogbuf()) { #if defined(REDBUD_LINUX) || defined(REDBUD_OSX) return isatty(fileno(stderr)) ? true : false; #elif defined(REDBUD_WIN) return _isatty(_fileno(stderr)) ? true : false; #endif } return false; } // For overloading standard output stream. template using color_return_t = typename std::enable_if< std::is_same::value || std::is_same::value || std::is_same::value || std::is_same::value || std::is_same::value, std::ostream&>::type; template using state_return_t = typename std::enable_if< std::is_same::value, std::ostream&>::type; // Sets the format and color of the text. #if defined(REDBUD_LINUX) || defined(REDBUD_OSX) template inline color_return_t set_color(std::ostream& os, const T& value) { return os << "\033[" << static_cast(value) << "m"; } #elif defined(REDBUD_WIN) static constexpr WORD default_state = (FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED); // Gets the corresponding RGB value on Windows. inline WORD get_rgb(WORD rgb) { static constexpr WORD cor[8] = { 0, 4, 2, 6, 1, 5, 3, 7 }; return cor[rgb]; } // Sets font attributes on Windows. inline void set_attributes(redbud::io::fg color, WORD& state) { if (color == redbud::io::fg::reserve) { return; } state &= 0xFFF0; if (color == redbud::io::fg::reset) { state |= default_state; return; } state |= get_rgb(static_cast(color) - 30); } inline void set_attributes(redbud::io::bg color, WORD& state) { if (color == redbud::io::bg::reserve) { return; } state &= 0xFF0F; if (color == redbud::io::bg::reset) { return; } state |= get_rgb(static_cast(color) - 40) << 4; } inline void set_attributes(redbud::io::hfg color, WORD& state) { state &= 0xFFF0; state |= (static_cast(0x8) | get_rgb(static_cast(color) - 90)); } inline void set_attributes(redbud::io::hbg color, WORD& state) { state &= 0xFF0F; state |= (static_cast(0x80) | get_rgb(static_cast(color) - 100) << 4); } inline void set_attributes(redbud::io::format format, WORD& state) { if (format == redbud::io::format::reset) { state = default_state; } } inline WORD& current_state() { static WORD state = default_state; return state; } inline HANDLE get_console_handle() { static HANDLE h = GetStdHandle(STD_OUTPUT_HANDLE); return h; } template inline color_return_t set_color(std::ostream& os, const T& value) { HANDLE h = get_console_handle(); if (h && is_terminal(os.rdbuf())) { set_attributes(value, current_state()); SetConsoleTextAttribute(h, current_state()); return os; } return os; } #endif } // namespace details // ---------------------------------------------------------------------------- // Overloads standard output stream to control the color of text. template inline details::color_return_t operator<<(std::ostream& os, const T& value) { return (os.iword(details::get_iword()) || (details::is_modifiable() && details::is_terminal(os.rdbuf()))) ? details::set_color(os, value) : os; } template inline details::state_return_t operator<<(std::ostream& os, const T& value) { if (value == redbud::io::state::automatic) { os.iword(details::get_iword()) = 0; } else if (value == redbud::io::state::manual) { os.iword(details::get_iword()) = 1; } return os; } } // namespace io } // namespace redbud #endif // !ALINSHANS_REDBUD_IO_COLOR_H_ ================================================ FILE: Test/Lib/redbud/platform.h ================================================ // ============================================================================ // Copyright (c) 2017 Alinshans. All rights reserved. // Licensed under the MIT License. See LICENSE for details. // // Header File : redbud/platform.h // // This file contains some preprocessing macros related to the platform. // ============================================================================ #ifndef ALINSHANS_REDBUD_PLATFORM_H_ #define ALINSHANS_REDBUD_PLATFORM_H_ // ---------------------------------------------------------------------------- // os #if defined(WIN32) || defined(_WIN32) || defined(_WIN64) #define REDBUD_WIN 1 #elif defined(__unix__) || defined(__unix) || defined(__linux__) #define REDBUD_LINUX 1 #elif defined(__APPLE__) || defined(__MACH__) #define REDBUD_OSX 1 #else #error "System that is not supported yet." #endif // ---------------------------------------------------------------------------- // complier #if defined(__clang__) #define REDBUD_CLANG __clang__ #elif defined(__GNUC__) #define REDBUD_GNUC __GNUC__ #elif defined(_MSC_VER) #define REDBUD_MSVC _MSC_VER #else #error "Complier that is not supported yet." #endif // ---------------------------------------------------------------------------- // stringify #define REDBUD_TO_STRING(x) #x #define REDBUD_STRING(x) REDBUD_TO_STRING(x) // ---------------------------------------------------------------------------- // join #define REDBUD_DO_JOIN(x ,y) x##y #define REDBUD_JOIN(x, y) REDBUD_DO_JOIN(x, y) // ---------------------------------------------------------------------------- // version #define REDBUD_MAJOR 1 #define REDBUD_MINOR 0 #define REDBUD_PATCH 0 #define REDBUD_VERSION \ REDBUD_STRING(REDBUD_MAJOR.REDBUD_MINOR.REDBUD_PATCH) #define _VERSION_CODE(x,y,z) \ (((x)*100000) + ((y)*100) + (z)) #define GNUC_VERSION \ _VERSION_CODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__) #define CLANG_VERSION \ _VERSION_CODE(__clang_major__, __clang_minor__, __clang_patchlevel__) // ---------------------------------------------------------------------------- // redbud API #ifndef _REDBUD_API #define _REDBUD_API ::redbud:: #endif // ---------------------------------------------------------------------------- // C++11 required #ifndef REDBUD_HAS_CXX11 #if defined(REDBUD_MSVC) && (REDBUD_MSVC >= 1900) #define REDBUD_HAS_CXX11 1 #elif defined(REDBUD_GNUC) && (GNUC_VERSION >= _VERSION_CODE(4,8,0)) && \ defined(__GXX_EXPERIMENTAL_CXX0X__) #define REDBUD_HAS_CXX11 1 #elif defined(REDBUD_CLANG) && (CLANG_VERSION >= _VERSION_CODE(3,3,0)) #define REDBUD_HAS_CXX11 1 #else #define REDBUD_HAS_CXX11 0 #endif #endif // !REDBUD_HAS_CXX11 #if REDBUD_HAS_CXX11 == 0 #error "C++11 required." #endif // ---------------------------------------------------------------------------- // Undefines macro min and max in MSVC. namespace redbud { #if REDBUD_MSVC #define NOMINMAX #endif } #endif // !ALINSHANS_REDBUD_PLATFORM_H_ ================================================ FILE: Test/README.md ================================================ 单元测试 (Unit test) ===== ## 测试环境 (Test environment) 测试直接在 `Travis CI` 和 `AppVeyor` 上构建并运行，已在以下环境中做过测试： Tests were built and run directly on `Tracis CI` and `AppVeyor` and had been tested in the following environments: * linux, ubuntu 14.04, gcc5/6/7 * osx, xcode5/6/7/8 * windows, VS2015/VS2017, [x64|x86], [Release|Debug] ## 测试框架 (Test frame) 在 [test.h](https://github.com/Alinshans/MyTinySTL/blob/master/Test/test.h) 中，用了两个类实现了一个简单的测试框架，并定义了大量宏来封装测试过程。
In this file [test.h](https://github.com/Alinshans/MyTinySTL/blob/master/Test/test.h), I used two class to implement a simple test framework, and defined a lot of macros to package testing process. ## 测试内容 (Test content) 在 [test.h](https://github.com/Alinshans/MyTinySTL/blob/master/Test/test.h) 中定义了两个宏，`PERFORMANCE_TEST_ON` 和 `LARGER_TEST_DATA_ON`。`PERFORMANCE_TEST_ON` 代表开启性能测试，默认定义为 `1`。`LARGER_TEST_DATA_ON` 代表增大测试数据，默认定义为 `0`。**如果你想把 `LARGER_TEST_DATA_ON` 设置为 `1`，建议电脑配置为：处理器 i5 或以上，内存 8G 以上。**
In this file [test.h](https://github.com/Alinshans/MyTinySTL/blob/master/Test/test.h), I defined two marcos: `PERFORMANCE_TEST_ON` and `LARGER_TEST_DATA_ON`. `PERFORMANCE_TEST_ON` means to run performance test, the default is defined as `1`. `LARGER_TEST_DATA_ON` means to increase the test data, the default is defined as `0`. **If you want to set `LARGER_TEST_DATA_ON` to `1`, the proposed computer configuration is: CPU i5 or above, memory 8G or more.** 测试案例如下：
The test cases are as follows: * [algorithm](https://github.com/Alinshans/MyTinySTL/blob/master/Test/algorithm_test.h) *(100%/100%)* * [algorithm_performance](https://github.com/Alinshans/MyTinySTL/blob/master/Test/algorithm_performance_test.h) *(100%/100%)* * [deque](https://github.com/Alinshans/MyTinySTL/blob/master/Test/deque_test.h) *(100%/100%)* * [list](https://github.com/Alinshans/MyTinySTL/blob/master/Test/list_test.h) *(100%/100%)* * [map](https://github.com/Alinshans/MyTinySTL/blob/master/Test/map_test.h) *(100%/100%)* * map * multimap * [queue](https://github.com/Alinshans/MyTinySTL/blob/master/Test/queue_test.h) *(100%/100%)* * queue * priority_queue * [set](https://github.com/Alinshans/MyTinySTL/blob/master/Test/set_test.h) *(100%/100%)* * set * multiset * [stack](https://github.com/Alinshans/MyTinySTL/blob/master/Test/stack_test.h) *(100%/100%)* * [string_test](https://github.com/Alinshans/MyTinySTL/blob/master/Test/string_test.h) *(100%/100%)* * [unordered_map](https://github.com/Alinshans/MyTinySTL/blob/master/Test/unordered_map_test.h) *(100%/100%)* * unordered_map * unordered_multimap * [unordered_set](https://github.com/Alinshans/MyTinySTL/blob/master/Test/unordered_set_test.h) *(100%/100%)* * unordered_set * unordered_multiset * [vector](https://github.com/Alinshans/MyTinySTL/blob/master/Test/vector_test.h) *(100%/100%)* ## 测试结果 (Test result) 见 [Travis CI](https://travis-ci.org/Alinshans/MyTinySTL) 和 [AppVeyor](https://ci.appveyor.com/project/Alinshans/mytinystl)。 See [Travis CI](https://travis-ci.org/Alinshans/MyTinySTL) and [AppVeyor](https://ci.appveyor.com/project/Alinshans/mytinystl). ================================================ FILE: Test/algorithm_performance_test.h ================================================ #ifndef MYTINYSTL_ALGORITHM_PERFORMANCE_TEST_H_ #define MYTINYSTL_ALGORITHM_PERFORMANCE_TEST_H_ // 仅仅针对 sort, binary_search 做了性能测试 #include #include "../MyTinySTL/algorithm.h" #include "test.h" namespace mystl { namespace test { namespace algorithm_performance_test { // 函数性能测试宏定义 #define FUN_TEST1(mode, fun, count) do { \ std::string fun_name = #fun; \ srand((int)time(0)); \ char buf[10]; \ clock_t start, end; \ int *arr = new int[count]; \ for(size_t i = 0; i < count; ++i) *(arr + i) = rand(); \ start = clock(); \ mode::fun(arr, arr + count); \ end = clock(); \ int n = static_cast(static_cast(end - start) \ / CLOCKS_PER_SEC * 1000); \ std::snprintf(buf, sizeof(buf), "%d", n); \ std::string t = buf; \ t += "ms |"; \ std::cout << std::setw(WIDE) << t; \ delete []arr; \ } while(0) #define FUN_TEST2(mode, fun, count) do { \ std::string fun_name = #fun; \ srand((int)time(0)); \ char buf[10]; \ clock_t start, end; \ int *arr = new int[count]; \ for(size_t i = 0; i < count; ++i) *(arr + i) = rand(); \ start = clock(); \ for(size_t i = 0; i < count; ++i) \ mode::fun(arr, arr + count, rand()); \ end = clock(); \ int n = static_cast(static_cast(end - start) \ / CLOCKS_PER_SEC * 1000); \ std::snprintf(buf, sizeof(buf), "%d", n); \ std::string t = buf; \ t += "ms |"; \ std::cout << std::setw(WIDE) << t; \ delete []arr; \ } while(0) void binary_search_test() { std::cout << "[------------------- function : binary_search ------------------]" << std::endl; std::cout << "| orders of magnitude |"; TEST_LEN(LEN1, LEN2, LEN3, WIDE); std::cout << "| std |"; FUN_TEST2(std, binary_search, LEN1); FUN_TEST2(std, binary_search, LEN2); FUN_TEST2(std, binary_search, LEN3); std::cout << std::endl << "| mystl |"; FUN_TEST2(mystl, binary_search, LEN1); FUN_TEST2(mystl, binary_search, LEN2); FUN_TEST2(mystl, binary_search, LEN3); std::cout << std::endl; } void sort_test() { std::cout << "[----------------------- function : sort -----------------------]" << std::endl; std::cout << "| orders of magnitude |"; TEST_LEN(LEN1, LEN2, LEN3, WIDE); std::cout << "| std |"; FUN_TEST1(std, sort, LEN1); FUN_TEST1(std, sort, LEN2); FUN_TEST1(std, sort, LEN3); std::cout << std::endl << "| mystl |"; FUN_TEST1(mystl, sort, LEN1); FUN_TEST1(mystl, sort, LEN2); FUN_TEST1(mystl, sort, LEN3); std::cout << std::endl; } void algorithm_performance_test() { #if PERFORMANCE_TEST_ON std::cout << "[===============================================================]" << std::endl; std::cout << "[--------------- Run algorithm performance test ----------------]" << std::endl; sort_test(); binary_search_test(); std::cout << "[--------------- End algorithm performance test ----------------]" << std::endl; std::cout << "[===============================================================]" << std::endl; #endif // PERFORMANCE_TEST_ON } } // namespace algorithm_performance_test } // namespace test } // namespace mystl #endif // !MYTINYSTL_ALGORITHM_PERFORMANCE_TEST_H_ ================================================ FILE: Test/algorithm_test.h ================================================ #ifndef MYTINYSTL_ALGORITHM_TEST_H_ #define MYTINYSTL_ALGORITHM_TEST_H_ // 算法测试: 包含了 mystl 的 81 个算法测试 #include #include #include #include "../MyTinySTL/algorithm.h" #include "../MyTinySTL/vector.h" #include "test.h" namespace mystl { namespace test { #ifdef max #pragma message("#undefing marco max") #undef max #endif // max #ifdef min #pragma message("#undefing marco min") #undef min #endif // min #ifdef _MSC_VER #pragma warning(push) #pragma warning(disable: 4389) #endif // _MSC_VER namespace algorithm_test { // 一些可能会用到的辅助数据和函数 int for_each_sum = 0; int gen() { return 5; } int r(int i) { return (i * 5 + 1) % 9; } bool is_odd(int i) { return i & 1; } bool is_even(int i) { return !(i & 1); } void arr_sum(int i) { for_each_sum += i; } bool cmp(const int& a, const int& b) { return b < a; } int unary_op(const int& x) { return x + 1; } int binary_op(const int& x, const int& y) { return x + y; } // 以下为 80 个函数的简单测试 // algobase test: TEST(copy_test) { int arr1[] = { 1,2,3,4,5,6,7,8,9,10 }; int exp[5], act[5]; std::copy(arr1, arr1 + 5, exp); mystl::copy(arr1, arr1 + 5, act); EXPECT_CON_EQ(exp, act); std::copy(arr1 + 5, arr1 + 10, exp); mystl::copy(arr1 + 5, arr1 + 10, act); EXPECT_CON_EQ(exp, act); } TEST(copy_backward_test) { int arr1[] = { 1,2,3,4,5 }; std::vector exp{ 0,0,0,0,0,6,7,8,9,10 }; int act[] = { 0,0,0,0,0,6,7,8,9,10 }; std::copy_backward(arr1, arr1 + 5, exp.begin() + 5); mystl::copy_backward(arr1, arr1 + 5, act + 5); EXPECT_CON_EQ(exp, act); std::copy_backward(exp.begin(), exp.begin() + 8, exp.begin() + 9); mystl::copy_backward(act, act + 8, act + 9); EXPECT_CON_EQ(exp, act); } TEST(copy_if_test) { int arr1[] = { 1,2,3,4,5,6,7,8,9,10 }; int exp[5], act[5]; std::copy_if(arr1, arr1 + 10, exp, is_odd); mystl::copy_if(arr1, arr1 + 10, act, is_odd); EXPECT_CON_EQ(exp, act); std::copy_if(arr1, arr1 + 10, exp, is_even); mystl::copy_if(arr1, arr1 + 10, act, is_even); EXPECT_CON_EQ(exp, act); } TEST(copy_n_test) { int arr1[] = { 1,2,3,4,5,6,7,8,9,10 }; int exp[10], act[10]; std::copy_n(arr1, 10, exp); mystl::copy_n(arr1, 10, act); EXPECT_CON_EQ(exp, act); std::copy_n(arr1 + 5, 5, exp); mystl::copy_n(arr1 + 5, 5, act); EXPECT_CON_EQ(exp, act); } TEST(move_test) { int arr1[] = { 1,2,3,4,5 }; int arr2[] = { 1,2,3,4,5 }; int exp[5], act[5]; std::move(arr1, arr1 + 5, exp); mystl::move(arr2, arr2 + 5, act); EXPECT_CON_EQ(exp, act); EXPECT_CON_EQ(arr1, arr2); } TEST(move_backward_test) { int arr1[] = { 1,2,3,4,5 }; int arr2[] = { 1,2,3,4,5 }; int exp[5], act[5]; std::move_backward(arr1, arr1 + 5, exp + 5); mystl::move_backward(arr2, arr2 + 5, act + 5); EXPECT_CON_EQ(exp, act); EXPECT_CON_EQ(arr1, arr2); } TEST(equal_test) { std::vector v1{ 1,2,3,4,5 }; std::vector v2{ 1,2,3,4,5,6 }; int arr1[] = { 1,2,3,4,5 }; int arr2[] = { 1,2,3,4,6 }; EXPECT_EQ(std::equal(v1.begin(), v1.end(), v2.begin()), mystl::equal(v1.begin(), v1.end(), v2.begin())); EXPECT_EQ(std::equal(arr1, arr1 + 5, arr2), mystl::equal(arr1, arr1 + 5, arr2)); EXPECT_EQ(std::equal(v1.begin(), v1.end(), arr1), mystl::equal(v1.begin(), v1.end(), arr1)); EXPECT_EQ(std::equal(v1.begin(), v1.end(), arr2, std::equal_to()), mystl::equal(v1.begin(), v1.end(), arr2, std::equal_to())); } TEST(fill_test) { int exp[10], act[10]; mystl::vector v1(10, 1); mystl::vector v2(10, 2); std::fill(exp, exp + 10, 1); mystl::fill(act, act + 10, 1); EXPECT_CON_EQ(exp, act); std::fill(v1.begin(), v1.end(), 3); mystl::fill(v2.begin(), v2.end(), 3); EXPECT_CON_EQ(v1, v2); } TEST(fill_n_test) { int arr1[5]; int arr2[5]; std::fill_n(arr2, 5, 1); mystl::fill_n(arr1, 5, 1); EXPECT_CON_EQ(arr1, arr2); std::fill_n(arr1 + 2, 3, 2); mystl::fill_n(arr2 + 2, 3, 2); EXPECT_CON_EQ(arr1, arr2); } TEST(iter_swap_test) { int a = 1; int b = 2; int *p1 = &a; int *p2 = &b; int *p3 = &a; int *p4 = &b; std::iter_swap(p1, p2); mystl::iter_swap(p3, p4); EXPECT_PTR_EQ(p1, p3); EXPECT_PTR_EQ(p2, p4); EXPECT_EQ(p1, p3); EXPECT_EQ(p2, p4); } TEST(lexicographical_compare_test) { int arr1[] = { 1,2,3,4,5 }; int arr2[] = { 0,2,4,6,8 }; int arr3[] = { 1,2,3,4,5 }; int arr4[] = { 1,2,3,4,5,6 }; int arr5[] = { 2,3,4 }; EXPECT_EQ(std::lexicographical_compare(arr1, arr1 + 5, arr2, arr2 + 5), mystl::lexicographical_compare(arr1, arr1 + 5, arr2, arr2 + 5)); EXPECT_EQ(std::lexicographical_compare(arr1, arr1 + 5, arr3, arr3 + 5), mystl::lexicographical_compare(arr1, arr1 + 5, arr3, arr3 + 5)); EXPECT_EQ(std::lexicographical_compare(arr1, arr1 + 5, arr4, arr4 + 6, std::less()), mystl::lexicographical_compare(arr1, arr1 + 5, arr4, arr4 + 6, std::less())); EXPECT_EQ(std::lexicographical_compare(arr1, arr1 + 5, arr5, arr5 + 3, std::less()), mystl::lexicographical_compare(arr1, arr1 + 5, arr5, arr5 + 3, std::less())); } TEST(max_test) { int i1 = 1, i2 = 2; double d1 = 1.1, d2 = 2.2; char c1 = 'a', c2 = 'b'; EXPECT_EQ(std::max(i1, i2), mystl::max(i1, i2)); EXPECT_EQ(std::max(d1, d2), mystl::max(d1, d2)); EXPECT_EQ(std::max(c1, c2), mystl::max(c1, c2)); } TEST(min_test) { int i1 = 1, i2 = 2; double d1 = 1.1, d2 = 2.2; char c1 = 'a', c2 = 'b'; EXPECT_EQ(std::min(i1, i2), mystl::min(i1, i2)); EXPECT_EQ(std::min(d1, d2), mystl::min(d1, d2)); EXPECT_EQ(std::min(c1, c2), mystl::min(c1, c2)); } TEST(mismatch_test) { int arr1[] = { 1,1,2,2,3,4,5 }; int arr2[] = { 1,1,2,2,3,3,3 }; int arr3[] = { 0,1,2,2,3,4,5 }; int arr4[] = { 1,1,2,2,3,4,5 }; auto p1 = std::mismatch(arr1, arr1 + 7, arr2); auto p2 = mystl::mismatch(arr1, arr1 + 7, arr2); auto p3 = std::mismatch(arr1, arr1 + 7, arr3); auto p4 = mystl::mismatch(arr1, arr1 + 7, arr3); auto p5 = std::mismatch(arr1, arr1 + 7, arr4, std::equal_to()); auto p6 = mystl::mismatch(arr1, arr1 + 7, arr4, std::equal_to()); EXPECT_EQ(p1.first, p2.first); EXPECT_EQ(p1.second, p2.second); EXPECT_EQ(p3.first, p4.first); EXPECT_EQ(p3.second, p4.second); EXPECT_EQ(p5.first, p6.first); EXPECT_EQ(p5.second, p6.second); } // heap_algo test TEST(make_heap_test) { int arr1[] = { 1,2,3,4,5,6,7,8,9 }; int arr2[] = { 1,2,3,4,5,6,7,8,9 }; int arr3[] = { 2,1,6,5,4,9,8,7,6 }; int arr4[] = { 2,1,6,5,4,9,8,7,6 }; int arr5[] = { 1,1,2,2,3,3,4,4,5,5 }; int arr6[] = { 1,1,2,2,3,3,4,4,5,5 }; std::make_heap(arr1, arr1 + 9); mystl::make_heap(arr2, arr2 + 9); std::make_heap(arr3, arr3 + 9); mystl::make_heap(arr4, arr4 + 9); std::make_heap(arr5, arr5 + 10, std::greater()); mystl::make_heap(arr6, arr6 + 10, std::greater()); EXPECT_CON_EQ(arr1, arr2); EXPECT_CON_EQ(arr3, arr4); EXPECT_CON_EQ(arr5, arr6); } TEST(pop_heap_test) { int arr1[] = { 1,2,3,4,5,6,7,8,9 }; int arr2[] = { 1,2,3,4,5,6,7,8,9 }; std::make_heap(arr1, arr1 + 9); std::make_heap(arr2, arr2 + 9); for (int i = 9; i > 0; --i) { std::pop_heap(arr1, arr1 + i); mystl::pop_heap(arr2, arr2 + i); EXPECT_CON_EQ(arr1, arr2); } int arr3[] = { 1,2,3,4,5,6,7,8,9 }; int arr4[] = { 1,2,3,4,5,6,7,8,9 }; std::make_heap(arr3, arr3 + 9, std::greater()); std::make_heap(arr4, arr4 + 9, std::greater()); std::pop_heap(arr3, arr3 + 9, std::greater()); mystl::pop_heap(arr4, arr4 + 9, std::greater()); EXPECT_CON_EQ(arr3, arr4); } TEST(push_heap_test) { int arr1[] = { 1,2,3,4,5,6,7,8,9 }; int arr2[] = { 1,2,3,4,5,6,7,8,9 }; std::make_heap(arr1, arr1 + 4); std::make_heap(arr2, arr2 + 4); for (int i = 4; i <= 9; ++i) { std::push_heap(arr1, arr1 + i); mystl::push_heap(arr2, arr2 + i); EXPECT_CON_EQ(arr1, arr2); } int arr3[] = { 1,2,3,4,5,6,7,8,9 }; int arr4[] = { 1,2,3,4,5,6,7,8,9 }; std::make_heap(arr3, arr3 + 9, std::greater()); std::make_heap(arr4, arr4 + 9, std::greater()); std::push_heap(arr3, arr3 + 9, std::greater()); mystl::push_heap(arr4, arr4 + 9, std::greater()); EXPECT_CON_EQ(arr3, arr4); } TEST(sort_heap_test) { int arr1[] = { 1,2,3,4,5,6,7,8,9 }; int arr2[] = { 1,2,3,4,5,6,7,8,9 }; int arr3[] = { 1,2,3,4,5,6,7,8,9 }; int arr4[] = { 1,2,3,4,5,6,7,8,9 }; std::make_heap(arr1, arr1 + 9); std::make_heap(arr2, arr2 + 9); std::make_heap(arr3, arr3 + 9, std::greater()); std::make_heap(arr4, arr4 + 9, std::greater()); std::sort_heap(arr1, arr1 + 9); mystl::sort_heap(arr2, arr2 + 9); std::sort_heap(arr3, arr3 + 9, std::greater()); mystl::sort_heap(arr4, arr4 + 9, std::greater()); EXPECT_CON_EQ(arr1, arr2); EXPECT_CON_EQ(arr3, arr4); } // set_algo test TEST(set_difference_test) { int arr1[] = { 1,2,3,4,5,6,7,8,9 }; int arr2[] = { 1,2,3,4,5,6 }; int arr3[] = { 1,2,3 }; int exp[6] = { 0 }, act[6] = { 0 }; std::set_difference(arr1, arr1 + 9, arr2, arr2 + 6, exp); mystl::set_difference(arr1, arr1 + 9, arr2, arr2 + 6, act); EXPECT_CON_EQ(exp, act); std::set_difference(arr2, arr2 + 6, arr3, arr3 + 3, exp); mystl::set_difference(arr2, arr2 + 6, arr3, arr3 + 3, act); EXPECT_CON_EQ(exp, act); std::set_difference(arr1, arr1 + 9, arr3, arr3 + 3, exp, std::less()); mystl::set_difference(arr1, arr1 + 9, arr3, arr3 + 3, act, std::less()); EXPECT_CON_EQ(exp, act); } TEST(set_intersection_test) { int arr1[] = { 1,2,3,4,5,6,7,8,9 }; int arr2[] = { 1,2,3,4,5,6 }; int arr3[] = { 1,2,3 }; int exp[9] = { 0 }, act[9] = { 0 }; std::set_intersection(arr1, arr1 + 9, arr2, arr2 + 6, exp); mystl::set_intersection(arr1, arr1 + 9, arr2, arr2 + 6, act); EXPECT_CON_EQ(exp, act); std::set_intersection(arr2, arr2 + 6, arr3, arr3 + 3, exp); mystl::set_intersection(arr2, arr2 + 6, arr3, arr3 + 3, act); EXPECT_CON_EQ(exp, act); std::set_intersection(arr1, arr1 + 9, arr3, arr3 + 3, exp, std::less()); mystl::set_intersection(arr1, arr1 + 9, arr3, arr3 + 3, act, std::less()); EXPECT_CON_EQ(exp, act); } TEST(set_symmetric_difference_test) { int arr1[] = { 1,2,3,4,5 }; int arr2[] = { 1,3,5,7,9 }; int arr3[] = { 2,4,6,8,10 }; int exp[10] = { 0 }, act[10] = { 0 }; std::set_symmetric_difference(arr1, arr1 + 5, arr2, arr2 + 5, exp); mystl::set_symmetric_difference(arr1, arr1 + 5, arr2, arr2 + 5, act); EXPECT_CON_EQ(exp, act); std::set_symmetric_difference(arr1, arr1 + 5, arr3, arr3 + 5, exp); mystl::set_symmetric_difference(arr1, arr1 + 5, arr3, arr3 + 5, act); EXPECT_CON_EQ(exp, act); std::set_symmetric_difference(arr2, arr2 + 5, arr3, arr3 + 5, exp, std::less()); mystl::set_symmetric_difference(arr2, arr2 + 5, arr3, arr3 + 5, act, std::less()); EXPECT_CON_EQ(exp, act); } TEST(set_union_test) { int arr1[] = { 1,2,3,4,5 }; int arr2[] = { 1,3,5,7,9 }; int arr3[] = { 2,4,6,8,10 }; int exp[10] = { 0 }, act[10] = { 0 }; std::set_union(arr1, arr1 + 5, arr2, arr2 + 5, exp); mystl::set_union(arr1, arr1 + 5, arr2, arr2 + 5, act); EXPECT_CON_EQ(exp, act); std::set_union(arr1, arr1 + 5, arr3, arr3 + 5, exp); mystl::set_union(arr1, arr1 + 5, arr3, arr3 + 5, act); EXPECT_CON_EQ(exp, act); std::set_union(arr2, arr2 + 5, arr3, arr3 + 5, exp, std::less()); mystl::set_union(arr2, arr2 + 5, arr3, arr3 + 5, act, std::less()); EXPECT_CON_EQ(exp, act); } // numeric test TEST(accumulate_test) { int arr1[] = { 1,2,3,4,5 }; EXPECT_EQ(std::accumulate(arr1, arr1 + 5, 0), mystl::accumulate(arr1, arr1 + 5, 0)); EXPECT_EQ(std::accumulate(arr1, arr1 + 5, 5), mystl::accumulate(arr1, arr1 + 5, 5)); EXPECT_EQ(std::accumulate(arr1, arr1 + 5, 0, std::minus()), mystl::accumulate(arr1, arr1 + 5, 0, std::minus())); } TEST(adjacent_difference_test) { int arr1[] = { 1,2,3,4,5 }; int arr2[] = { 1,1,1,1,1 }; int exp[5], act[5]; std::adjacent_difference(arr1, arr1 + 5, exp); mystl::adjacent_difference(arr1, arr1 + 5, act); EXPECT_CON_EQ(exp, act); std::adjacent_difference(arr2, arr2 + 5, exp, std::minus()); mystl::adjacent_difference(arr2, arr2 + 5, act, std::minus()); EXPECT_CON_EQ(exp, act); } TEST(inner_product_test) { int arr1[] = { 1,1,1,1,1 }; int arr2[] = { 2,2,2,2,2 }; int arr3[] = { 1,2,3,4,5 }; EXPECT_EQ(std::inner_product(arr1, arr1 + 5, arr3, 0), mystl::inner_product(arr1, arr1 + 5, arr3, 0)); EXPECT_EQ(std::inner_product(arr2, arr2 + 5, arr3, 0, std::minus(), std::multiplies()), mystl::inner_product(arr2, arr2 + 5, arr3, 0, std::minus(), std::multiplies())); } TEST(iota_test) { int arr1[10]; int arr2[10]; std::iota(arr1, arr1 + 10, 1); mystl::iota(arr2, arr2 + 10, 1); EXPECT_CON_EQ(arr1, arr2); std::iota(arr1, arr1 + 10, -1); mystl::iota(arr2, arr2 + 10, -1); EXPECT_CON_EQ(arr1, arr2); } TEST(partial_sum_test) { int arr1[] = { 1,2,3,4,5,6,7,8,9 }; int exp1[5], act1[5]; int exp2[9], act2[9]; std::partial_sum(arr1, arr1 + 5, exp1); mystl::partial_sum(arr1, arr1 + 5, act1); std::partial_sum(arr1, arr1 + 9, exp2); mystl::partial_sum(arr1, arr1 + 9, act2); EXPECT_CON_EQ(exp1, act1); EXPECT_CON_EQ(exp2, act2); std::partial_sum(arr1, arr1 + 9, exp2, std::multiplies()); mystl::partial_sum(arr1, arr1 + 9, act2, std::multiplies()); EXPECT_CON_EQ(exp2, act2); } // algo test TEST(adjacent_find_test) { int arr1[] = { 1,2,3,3,4 }; int arr2[] = { 1,2,3,4,5 }; EXPECT_EQ(std::adjacent_find(arr1, arr1 + 5), mystl::adjacent_find(arr1, arr1 + 5)); EXPECT_EQ(std::adjacent_find(arr2, arr2 + 5), mystl::adjacent_find(arr2, arr2 + 5)); EXPECT_EQ(std::adjacent_find(arr1, arr1 + 5, std::greater()), mystl::adjacent_find(arr1, arr1 + 5, std::greater())); } TEST(all_of_test) { int arr1[] = { 1,3,5,7,9 }; int arr2[] = { 1,3,5,7,8 }; EXPECT_EQ(std::all_of(arr1, arr1 + 5, is_odd), mystl::all_of(arr1, arr1 + 5, is_odd)); EXPECT_EQ(std::all_of(arr2, arr2 + 5, is_odd), mystl::all_of(arr2, arr2 + 5, is_odd)); } TEST(any_of_test) { int arr1[] = { 1,2,4,6,8 }; int arr2[] = { 2,4,6,8,10 }; EXPECT_EQ(std::any_of(arr1, arr1 + 5, is_odd), mystl::any_of(arr1, arr1 + 5, is_odd)); EXPECT_EQ(std::any_of(arr2, arr2 + 5, is_odd), mystl::any_of(arr2, arr2 + 5, is_odd)); } TEST(binary_search_test) { int arr1[] = { 1,2,3,4,5 }; EXPECT_EQ(std::binary_search(arr1, arr1 + 5, 1), mystl::binary_search(arr1, arr1 + 5, 1)); EXPECT_EQ(std::binary_search(arr1, arr1 + 5, 6), mystl::binary_search(arr1, arr1 + 5, 6)); } TEST(count_test) { int arr1[] = { 1,2,2,3,3,3,4,5,8 }; EXPECT_EQ(std::count(arr1, arr1 + 9, 2), mystl::count(arr1, arr1 + 9, 2)); EXPECT_EQ(std::count(arr1, arr1 + 9, 3), mystl::count(arr1, arr1 + 9, 3)); EXPECT_EQ(std::count(arr1, arr1 + 9, 6), mystl::count(arr1, arr1 + 9, 6)); } TEST(count_if_test) { int arr1[] = { 1,2,2,3,3,3,4,5,8 }; EXPECT_EQ(std::count_if(arr1, arr1 + 9, is_odd), mystl::count_if(arr1, arr1 + 9, is_odd)); EXPECT_EQ(std::count_if(arr1, arr1 + 9, is_even), mystl::count_if(arr1, arr1 + 9, is_even)); } TEST(equal_range_test) { int arr1[] = { 1,2,3,3,3,4,5 }; auto p1 = mystl::equal_range(arr1, arr1 + 7, 3); auto p2 = std::equal_range(arr1, arr1 + 7, 3); auto p3 = mystl::equal_range(arr1, arr1 + 7, 6, std::equal_to()); auto p4 = std::equal_range(arr1, arr1 + 7, 6, std::equal_to()); EXPECT_EQ(p2.first, p1.first); EXPECT_EQ(p2.second, p1.second); EXPECT_EQ(p4.first, p3.first); EXPECT_EQ(p4.second, p3.second); } TEST(find_test) { int arr1[] = { 1,2,3,4,5 }; EXPECT_EQ(std::find(arr1, arr1 + 5, 3), mystl::find(arr1, arr1 + 5, 3)); EXPECT_EQ(std::find(arr1, arr1 + 5, 6), mystl::find(arr1, arr1 + 5, 6)); } TEST(find_end_test) { int arr1[] = { 1,2,3,2,2,3,4,5 }; int arr2[] = { 2,3 }; int arr3[] = { 4,5,6 }; EXPECT_EQ(std::find_end(arr1, arr1 + 8, arr2, arr2 + 1), mystl::find_end(arr1, arr1 + 8, arr2, arr2 + 1)); EXPECT_EQ(std::find_end(arr1, arr1 + 8, arr3, arr3 + 2), mystl::find_end(arr1, arr1 + 8, arr3, arr3 + 2)); EXPECT_EQ(std::find_end(arr1, arr1 + 8, arr3, arr3 + 2), mystl::find_end(arr1, arr1 + 8, arr3, arr3 + 2)); EXPECT_EQ(std::find_end(arr1, arr1 + 8, arr3, arr3, std::less()), mystl::find_end(arr1, arr1 + 8, arr3, arr3, std::less())); } TEST(find_first_of_test) { int arr1[] = { 1,2,3,4,5 }; int arr2[] = { 2,3,4 }; int arr3[] = { 6,7,8 }; EXPECT_EQ(std::find_first_of(arr1, arr1 + 5, arr2, arr2 + 3), mystl::find_first_of(arr1, arr1 + 5, arr2, arr2 + 3)); EXPECT_EQ(std::find_first_of(arr1, arr1 + 5, arr3, arr3 + 3, std::equal_to()), mystl::find_first_of(arr1, arr1 + 5, arr3, arr3 + 3, std::equal_to())); } TEST(find_if_test) { int arr1[] = { 1,2,3,4,5 }; EXPECT_EQ(std::find_if(arr1, arr1 + 5, is_odd), mystl::find_if(arr1, arr1 + 5, is_odd)); EXPECT_EQ(std::find_if(arr1, arr1 + 5, is_even), mystl::find_if(arr1, arr1 + 5, is_even)); } TEST(find_if_not_test) { int arr1[] = { 1,2,3,4,5 }; EXPECT_EQ(std::find_if_not(arr1, arr1 + 5, is_odd), mystl::find_if_not(arr1, arr1 + 5, is_odd)); EXPECT_EQ(std::find_if_not(arr1, arr1 + 5, is_even), mystl::find_if_not(arr1, arr1 + 5, is_even)); } TEST(for_each_test) { std::vector v1{ 1,2,3,4,5 }; std::for_each(v1.begin(), v1.end(), arr_sum); EXPECT_EQ(15, for_each_sum); mystl::for_each(v1.begin(), v1.end(), arr_sum); EXPECT_EQ(30, for_each_sum); } TEST(generate_test) { int arr1[5]; int arr2[5]; std::generate(arr1, arr1 + 5, gen); mystl::generate(arr2, arr2 + 5, gen); EXPECT_CON_EQ(arr1, arr2); } TEST(generate_n_test) { int arr1[] = { 1,1,1,1,1,6,7,8,9,10 }; int arr2[] = { 2,2,2,2,2,6,7,8,9,10 }; std::generate_n(arr1, 5, gen); mystl::generate_n(arr2, 5, gen); EXPECT_CON_EQ(arr1, arr2); } TEST(includes_test) { std::vector v1{ 1,2,3,4,5,6,7,8,9 }; std::vector v2{ 2,3,5,6,9 }; std::vector v3{ 0,1,2,3,4 }; std::vector v4{ 1,2,5,7,10 }; std::vector v5; EXPECT_EQ(std::includes(v1.begin(), v1.end(), v2.begin(), v2.end()), mystl::includes(v1.begin(), v1.end(), v2.begin(), v2.end())); EXPECT_EQ(std::includes(v1.begin(), v1.end(), v3.begin(), v3.end()), mystl::includes(v1.begin(), v1.end(), v3.begin(), v3.end())); EXPECT_EQ(std::includes(v1.begin(), v1.end(), v4.begin(), v4.end()), mystl::includes(v1.begin(), v1.end(), v4.begin(), v4.end())); EXPECT_EQ(std::includes(v1.begin(), v1.end(), v5.begin(), v5.end(), std::less()), mystl::includes(v1.begin(), v1.end(), v5.begin(), v5.end(), std::less())); } TEST(inplace_merge_test) { int arr1[] = { 1,3,5,7,9,2,4,6,8,10 }; int arr2[] = { 1,3,5,7,9,2,4,6,8,10 }; int arr3[] = { 1,2,3,1,2,3,4,5 }; int arr4[] = { 1,2,3,1,2,3,4,5 }; std::inplace_merge(arr1, arr1 + 5, arr1 + 10); mystl::inplace_merge(arr2, arr2 + 5, arr2 + 10); std::inplace_merge(arr3, arr3 + 3, arr3 + 8, std::less()); mystl::inplace_merge(arr4, arr4 + 3, arr4 + 8, std::less()); EXPECT_CON_EQ(arr1, arr2); EXPECT_CON_EQ(arr3, arr4); } TEST(is_heap_test) { int arr1[] = { 0,1,2,3,4,5,6,7,8,9 }; int arr2[] = { 9,8,7,6,5,4,3,2,1,0 }; int arr3[] = { 1,3,5,7,9,0,2,4,6,8 }; int arr4[] = { 0,1,2,3,4,5,6,7,8,9 }; std::make_heap(arr4, arr4 + 10); EXPECT_EQ(std::is_heap(arr1, arr1 + 10), mystl::is_heap(arr1, arr1 + 10)); EXPECT_EQ(std::is_heap(arr2, arr2 + 10, std::less()), mystl::is_heap(arr2, arr2 + 10, std::less())); EXPECT_EQ(std::is_heap(arr3, arr3 + 10), mystl::is_heap(arr3, arr3 + 10)); EXPECT_EQ(std::is_heap(arr4, arr4 + 10), mystl::is_heap(arr4, arr4 + 10)); } TEST(is_sorted_test) { int arr1[] = { 1,2,3,4,5 }; int arr2[] = { 1,2,3,5,4 }; int arr3[] = { 5,4,3,2,1 }; int arr4[] = { 1,2,5,4,3 }; EXPECT_EQ(std::is_sorted(arr1, arr1 + 5), mystl::is_sorted(arr1, arr1 + 5)); EXPECT_EQ(std::is_sorted(arr2, arr2 + 5), mystl::is_sorted(arr2, arr2 + 5)); EXPECT_EQ(std::is_sorted(arr3, arr3 + 5, std::less()), mystl::is_sorted(arr3, arr3 + 5, std::less())); EXPECT_EQ(std::is_sorted(arr4, arr4 + 5, std::less()), mystl::is_sorted(arr4, arr4 + 5, std::less())); } TEST(lower_bound_test) { int arr1[] = { 1,2,3,3,3,4,5 }; EXPECT_EQ(std::lower_bound(arr1, arr1 + 7, 1), mystl::lower_bound(arr1, arr1 + 7, 1)); EXPECT_EQ(std::lower_bound(arr1, arr1 + 7, 2), mystl::lower_bound(arr1, arr1 + 7, 2)); EXPECT_EQ(std::lower_bound(arr1, arr1 + 7, 3), mystl::lower_bound(arr1, arr1 + 7, 3)); EXPECT_EQ(std::lower_bound(arr1, arr1 + 7, 5, std::less()), mystl::lower_bound(arr1, arr1 + 7, 5, std::less())); } TEST(max_elememt_test) { int arr1[] = { 1,2,3,4,5,4,3,2,1 }; double arr2[] = { 1.0,2.2,6.6,8.8,8.81,2.4 }; EXPECT_PTR_EQ(std::max_element(arr1, arr1 + 9), mystl::max_element(arr1, arr1 + 9)); EXPECT_PTR_EQ(std::max_element(arr2, arr2 + 6, std::less()), mystl::max_element(arr2, arr2 + 6, std::less())); } TEST(median_test) { int ia = 2, ib = 1, ic = 3; double da = 3.1, db = 3.0, dc = 3.2; EXPECT_EQ(2, mystl::median(ia, ib, ic)); EXPECT_EQ(3.1, mystl::median(da, db, dc, std::greater())); } TEST(merge_test) { int arr1[] = { 1,2,5,9,10 }; int arr2[] = { 3,7,8,8,9 }; int arr3[] = { 1,2,5,9,10 }; int arr4[] = { 3,7,8,8,9 }; int exp[10], act[10]; std::merge(arr1, arr1 + 5, arr2, arr2 + 5, exp); mystl::merge(arr3, arr3 + 5, arr4, arr4 + 5, act); EXPECT_CON_EQ(exp, act); std::merge(arr1, arr1 + 5, arr2, arr2 + 5, exp, std::less()); mystl::merge(arr3, arr3 + 5, arr4, arr4 + 5, act, std::less()); EXPECT_CON_EQ(exp, act); } TEST(min_elememt_test) { int arr1[] = { 2,4,8,1,6,5,8,9,3 }; double arr2[] = { 1.5,2.2,1.4,1.33,1.333,2.33 }; EXPECT_PTR_EQ(std::max_element(arr1, arr1 + 9), mystl::max_element(arr1, arr1 + 9)); EXPECT_PTR_EQ(std::max_element(arr2, arr2 + 6, std::less()), mystl::max_element(arr2, arr2 + 6, std::less())); } TEST(is_permutation_test) { int arr1[] = { 1,2,3,4,5 }; int arr2[] = { 3,4,5,2,1 }; int arr3[] = { 1,2,3,4,6 }; // 因为提供的是 C++11 的支持，std::is_permutation 可能没有 C++14 的接口 EXPECT_EQ(std::is_permutation(arr1, arr1 + 5, arr2), mystl::is_permutation(arr1, arr1 + 5, arr2, arr2 + 5)); EXPECT_EQ(std::is_permutation(arr1, arr1 + 5, arr3), mystl::is_permutation(arr1, arr1 + 5, arr3, arr3 + 5)); EXPECT_EQ(std::is_permutation(arr1, arr1 + 5, arr2, std::equal_to()), mystl::is_permutation(arr1, arr1 + 5, arr2, arr2 + 5, std::equal_to())); EXPECT_EQ(std::is_permutation(arr1, arr1 + 5, arr3, std::equal_to()), mystl::is_permutation(arr1, arr1 + 5, arr3, arr3 + 5, std::equal_to())); } TEST(next_permutation_test) { int arr1[] = { 1,2,3,3 }; int arr2[] = { 1,2,3,3 }; int n1 = 0, n2 = 0; while (std::next_permutation(arr1, arr1 + 4)) n1++; while (mystl::next_permutation(arr1, arr1 + 4)) n2++; EXPECT_EQ(n1, n2); for (; n1 > 0; n1--) { std::next_permutation(arr1, arr1 + 4); mystl::next_permutation(arr2, arr2 + 4); EXPECT_CON_EQ(arr1, arr2); } std::next_permutation(arr1, arr1 + 4, std::greater()); mystl::next_permutation(arr2, arr2 + 4, std::greater()); EXPECT_CON_EQ(arr1, arr2); } TEST(none_of_test) { int arr1[] = { 1,3,5,7,9 }; int arr2[] = { 1,3,5,7,8 }; int arr3[] = { 2,4,6,8,10 }; EXPECT_EQ(std::none_of(arr1, arr1 + 5, is_even), mystl::none_of(arr1, arr1 + 5, is_even)); EXPECT_EQ(std::none_of(arr2, arr2 + 5, is_even), mystl::none_of(arr2, arr2 + 5, is_even)); EXPECT_EQ(std::none_of(arr3, arr3 + 5, is_even), mystl::none_of(arr3, arr3 + 5, is_even)); } TEST(nth_element_test) { int arr1[] = { 9,8,7,6,5,4,3,2,1 }; int arr2[] = { 1,2,3,4,5,6,3,2,1 }; int arr3[] = { 1,2,8,9,6,5,3,4,7 }; int arr4[] = { 1,5,1,5,8,4,9,6,8,4,10,13,20,4,2,1 }; mystl::nth_element(arr1, arr1 + 4, arr1 + 9); mystl::nth_element(arr2, arr2 + 2, arr2 + 9); mystl::nth_element(arr3, arr3 + 8, arr3 + 9, std::less()); mystl::nth_element(arr4, arr4 + 3, arr4 + 16, std::less()); bool arr1_left_less = true, arr1_right_greater = true; bool arr2_left_less = true, arr2_right_greater = true; bool arr3_left_less = true, arr3_right_greater = true; bool arr4_left_less = true, arr4_right_greater = true; for (int i = 0; i < 9; ++i) { if (i < 4 && arr1[i] > arr1[4]) arr1_left_less = false; else if (i > 4 && arr1[i] < arr1[4]) arr1_right_greater = false; } for (int i = 0; i < 9; ++i) { if (i < 2 && arr2[i] > arr2[2]) arr2_left_less = false; else if (i > 2 && arr2[i] < arr2[2]) arr2_right_greater = false; } for (int i = 0; i < 9; ++i) { if (i < 8 && arr3[i] > arr3[8]) arr3_left_less = false; } for (int i = 0; i < 16; ++i) { if (i < 3 && arr4[i] > arr4[3]) arr4_left_less = false; else if (i > 3 && arr4[i] < arr4[3]) arr4_right_greater = false; } EXPECT_TRUE(arr1_left_less); EXPECT_TRUE(arr1_right_greater); EXPECT_TRUE(arr2_left_less); EXPECT_TRUE(arr2_right_greater); EXPECT_TRUE(arr3_left_less); EXPECT_TRUE(arr3_right_greater); EXPECT_TRUE(arr4_left_less); EXPECT_TRUE(arr4_right_greater); } TEST(partial_sort_test) { int arr1[] = { 3,2,1,9,8,7,6,5,4 }; int arr2[] = { 3,2,1,9,8,7,6,5,4 }; int arr3[] = { 5,1,5,8,6,4,8,4,1,3,5,8,4 }; int arr4[] = { 5,1,5,8,6,4,8,4,1,3,5,8,4 }; std::partial_sort(arr1, arr1 + 2, arr1 + 9); mystl::partial_sort(arr2, arr2 + 2, arr2 + 9); std::partial_sort(arr3, arr3 + 5, arr3 + 13, std::greater()); mystl::partial_sort(arr4, arr4 + 5, arr4 + 13, std::greater()); EXPECT_CON_EQ(arr1, arr2); EXPECT_CON_EQ(arr3, arr4); } TEST(partial_sort_copy_test) { int arr1[] = { 3,2,1,9,8,7,6,5,4 }; int arr2[] = { 1,2,3,4,5,6,7,8,9 }; int arr3[] = { 1,6,8,4,2,1,6,8,4,7,6,2,1,3,6 }; int exp[5], act[5]; std::partial_sort_copy(arr1, arr1 + 9, exp, exp + 5); mystl::partial_sort_copy(arr1, arr1 + 9, act, act + 5); EXPECT_CON_EQ(exp, act); std::partial_sort_copy(arr2, arr2 + 9, exp, exp + 5); mystl::partial_sort_copy(arr2, arr2 + 9, act, act + 5); EXPECT_CON_EQ(exp, act); std::partial_sort_copy(arr3, arr3 + 15, exp, exp + 5, std::greater()); mystl::partial_sort_copy(arr3, arr3 + 15, act, act + 5, std::greater()); EXPECT_CON_EQ(exp, act); } TEST(partition_test) { int arr1[] = { 1,2,3,4,5,6,7,8,9 }; int arr2[] = { 1,2,3,4,5,6,7,8,9 }; std::partition(arr1, arr1 + 9, is_odd); mystl::partition(arr2, arr2 + 9, is_odd); EXPECT_CON_EQ(arr1, arr2); std::partition(arr1, arr1 + 9, is_even); mystl::partition(arr2, arr2 + 9, is_even); EXPECT_CON_EQ(arr1, arr2); } TEST(partition_copy_test) { int arr1[] = { 1,2,3,4,5,6,7,8,9,10 }; int exp_true[5], exp_false[5]; int act_true[5], act_false[5]; std::partition_copy(arr1, arr1 + 10, exp_true, exp_false, is_odd); mystl::partition_copy(arr1, arr1 + 10, act_true, act_false, is_odd); EXPECT_CON_EQ(exp_true, act_true); EXPECT_CON_EQ(exp_false, act_false); } TEST(prev_permutation_test) { int arr1[] = { 3,2,1,1 }; int arr2[] = { 3,2,1,1 }; int n1 = 0, n2 = 0; while (std::prev_permutation(arr1, arr1 + 4)) n1++; while (mystl::prev_permutation(arr1, arr1 + 4)) n2++; EXPECT_EQ(n1, n2); for (; n1 > 0; n1--) { std::prev_permutation(arr1, arr1 + 4); mystl::prev_permutation(arr2, arr2 + 4); EXPECT_CON_EQ(arr1, arr2); } std::prev_permutation(arr1, arr1 + 4, std::greater()); mystl::prev_permutation(arr2, arr2 + 4, std::greater()); EXPECT_CON_EQ(arr1, arr2); } TEST(random_shuffle_test) { int arr1[] = { 1,2,3,4,5,6,7,8,9 }; int arr2[9]; for (int i = 0; i < 9; ++i) { std::copy(arr1, arr1 + 9, arr2); mystl::random_shuffle(arr1, arr1 + 9); EXPECT_CON_NE(arr1, arr2); } std::copy(arr1, arr1 + 9, arr2); mystl::random_shuffle(arr1, arr1 + 9, r); EXPECT_CON_NE(arr1, arr2); } TEST(remove_test) { std::vector v1{ 1,2,3,4,5,6,6,6 }; std::vector v2(v1); std::remove(v1.begin(), v1.end(), 3); mystl::remove(v2.begin(), v2.end(), 3); EXPECT_CON_EQ(v1, v2); std::remove(v1.begin(), v1.end(), 6); mystl::remove(v2.begin(), v2.end(), 6); EXPECT_CON_EQ(v1, v2); } TEST(remove_copy_test) { int arr1[] = { 1,2,3,4,5,6,6,6 }; int arr2[] = { 1,2,3,4,5,6,6,6 }; int exp[5], act[5]; std::remove_copy(arr1, arr1 + 8, exp, 6); mystl::remove_copy(arr2, arr2 + 8, act, 6); EXPECT_CON_EQ(exp, act); std::remove_copy(arr1, arr1 + 5, exp, 3); mystl::remove_copy(arr2, arr2 + 5, act, 3); EXPECT_CON_EQ(exp, act); } TEST(remove_copy_if_test) { int arr1[] = { 1,2,3,4,5,6,7,8,9,10 }; int exp[5], act[5]; std::remove_copy_if(arr1, arr1 + 10, exp, is_odd); mystl::remove_copy_if(arr1, arr1 + 10, act, is_odd); EXPECT_CON_EQ(exp, act); std::remove_copy_if(arr1, arr1 + 10, exp, is_even); mystl::remove_copy_if(arr1, arr1 + 10, act, is_even); EXPECT_CON_EQ(exp, act); } TEST(remove_if_test) { std::vector v1{ 1,2,3,4,5,6,7,8,9,10 }; std::vector v2(v1); std::remove_if(v1.begin(), v1.end(), is_odd); mystl::remove_if(v2.begin(), v2.end(), is_odd); EXPECT_CON_EQ(v1, v2); } TEST(replace_test) { int arr1[] = { 1,1,1,2,2,2,3,3,3 }; int arr2[] = { 1,1,1,2,2,2,3,3,3 }; std::replace(arr1, arr1 + 9, 1, 4); mystl::replace(arr2, arr2 + 9, 1, 4); EXPECT_CON_EQ(arr1, arr2); std::replace(arr1, arr1 + 9, 2, 5); mystl::replace(arr2, arr2 + 9, 2, 5); EXPECT_CON_EQ(arr1, arr2); std::replace(arr1, arr1 + 9, 3, 6); mystl::replace(arr2, arr2 + 9, 3, 6); EXPECT_CON_EQ(arr1, arr2); } TEST(replace_copy_test) { int arr1[] = { 1,1,1,2,2,2,3,3,3 }; int exp[9], act[9]; std::replace_copy(arr1, arr1 + 9, exp, 1, 4); mystl::replace_copy(arr1, arr1 + 9, act, 1, 4); EXPECT_CON_EQ(exp, act); std::replace_copy(arr1, arr1 + 9, exp, 2, 5); mystl::replace_copy(arr1, arr1 + 9, act, 2, 5); EXPECT_CON_EQ(exp, act); std::replace_copy(arr1, arr1 + 9, exp, 3, 6); mystl::replace_copy(arr1, arr1 + 9, act, 3, 6); EXPECT_CON_EQ(exp, act); } TEST(replace_copy_if_test) { int arr1[] = { 1,2,3,4,5,6,7,8,9,10 }; int exp[10] = { 0 }, act[10] = { 0 }; std::replace_copy_if(arr1, arr1 + 10, exp, is_odd, 1); mystl::replace_copy_if(arr1, arr1 + 10, act, is_odd, 1); EXPECT_CON_EQ(exp, act); std::replace_copy_if(arr1, arr1 + 10, exp, is_even, 2); mystl::replace_copy_if(arr1, arr1 + 10, act, is_even, 2); EXPECT_CON_EQ(exp, act); } TEST(replace_if_test) { std::vector v1{ 1,2,3,4,5,6,7,8,9,10 }; std::vector v2(v1); std::replace_if(v1.begin(), v1.end(), is_odd, 1); mystl::replace_if(v2.begin(), v2.end(), is_odd, 1); EXPECT_CON_EQ(v1, v2); std::replace_if(v1.begin(), v1.end(), is_even, 2); mystl::replace_if(v2.begin(), v2.end(), is_even, 2); EXPECT_CON_EQ(v1, v2); } TEST(reverse_test) { int arr1[] = { 1,2,3,4,5,6,7,8,9 }; int arr2[] = { 1,2,3,4,5,6,7,8,9 }; std::reverse(arr1, arr1 + 9); mystl::reverse(arr2, arr2 + 9); EXPECT_CON_EQ(arr1, arr2); std::reverse(arr1, arr1 + 5); mystl::reverse(arr2, arr2 + 5); EXPECT_CON_EQ(arr1, arr2); } TEST(reverse_copy_test) { int arr1[] = { 1,2,3,4,5,6,7,8,9 }; int exp[5], act[5]; std::reverse_copy(arr1, arr1 + 5, exp); mystl::reverse_copy(arr1, arr1 + 5, act); EXPECT_CON_EQ(exp, act); std::reverse_copy(arr1 + 4, arr1 + 9, exp); mystl::reverse_copy(arr1 + 4, arr1 + 9, act); EXPECT_CON_EQ(exp, act); } TEST(rotate_test) { int arr1[] = { 1,2,3,4,5,6,7,8,9 }; int arr2[] = { 1,2,3,4,5,6,7,8,9 }; std::rotate(arr1, arr1 + 3, arr1 + 9); mystl::rotate(arr2, arr2 + 3, arr2 + 9); EXPECT_CON_EQ(arr1, arr2); std::rotate(arr1 + 3, arr1 + 5, arr1 + 9); mystl::rotate(arr2 + 3, arr2 + 5, arr2 + 9); EXPECT_CON_EQ(arr1, arr2); std::rotate(arr1, arr1 + 9, arr1 + 9); mystl::rotate(arr2, arr2 + 9, arr2 + 9); EXPECT_CON_EQ(arr1, arr2); } TEST(rotate_copy_test) { int arr1[] = { 1,2,3,4,5,6,7,8,9 }; int exp[9], act[9]; std::rotate_copy(arr1, arr1 + 5, arr1 + 9, exp); mystl::rotate_copy(arr1, arr1 + 5, arr1 + 9, act); EXPECT_CON_EQ(exp, act); std::rotate_copy(arr1, arr1, arr1 + 9, exp); mystl::rotate_copy(arr1, arr1, arr1 + 9, act); EXPECT_CON_EQ(exp, act); std::rotate_copy(arr1, arr1 + 9, arr1 + 9, exp); mystl::rotate_copy(arr1, arr1 + 9, arr1 + 9, act); EXPECT_CON_EQ(exp, act); } TEST(search_test) { int arr1[] = { 1,2,3,3,3,4,5,6,6, }; int arr2[] = { 1 }; int arr3[] = { 3,3 }; int arr4[] = { 5,6,6,6 }; EXPECT_EQ(std::search(arr1, arr1 + 9, arr2, arr2 + 1), mystl::search(arr1, arr1 + 9, arr2, arr2 + 1)); EXPECT_EQ(std::search(arr1, arr1 + 9, arr3, arr3 + 2), mystl::search(arr1, arr1 + 9, arr3, arr3 + 2)); EXPECT_EQ(std::search(arr1, arr1 + 9, arr4, arr4 + 3, std::less()), mystl::search(arr1, arr1 + 9, arr4, arr4 + 3, std::less())); EXPECT_EQ(std::search(arr1, arr1 + 9, arr4, arr4 + 4, std::less()), mystl::search(arr1, arr1 + 9, arr4, arr4 + 4, std::less())); } TEST(search_n_test) { int arr1[] = { 1,2,2,3,3,3,6,6,9 }; EXPECT_EQ(std::search_n(arr1, arr1 + 9, 1, 0), mystl::search_n(arr1, arr1 + 9, 1, 0)); EXPECT_EQ(std::search_n(arr1, arr1 + 9, 2, 2), mystl::search_n(arr1, arr1 + 9, 2, 2)); EXPECT_EQ(std::search_n(arr1, arr1 + 9, 1, 3), mystl::search_n(arr1, arr1 + 9, 1, 3)); EXPECT_EQ(std::search_n(arr1, arr1 + 9, 3, 6, std::less()), mystl::search_n(arr1, arr1 + 9, 3, 6, std::less())); EXPECT_EQ(std::search_n(arr1, arr1 + 9, 2, 10, std::less()), mystl::search_n(arr1, arr1 + 9, 2, 10, std::less())); } TEST(sort_test) { int arr1[] = { 6,1,2,5,4,8,3,2,4,6,10,2,1,9 }; int arr2[] = { 6,1,2,5,4,8,3,2,4,6,10,2,1,9 }; int arr3[] = { 80,30,51,65,12,10,24,87,62,51,32,45,1,33,66,20,35,84,62,14 }; int arr4[] = { 80,30,51,65,12,10,24,87,62,51,32,45,1,33,66,20,35,84,62,14 }; int arr5[] = { 9,9,9,8,8,8,7,7,7 }; int arr6[] = { 9,9,9,8,8,8,7,7,7 }; std::sort(arr1, arr1 + 14); mystl::sort(arr2, arr2 + 14); std::sort(arr3, arr3 + 20); mystl::sort(arr4, arr4 + 20); std::sort(arr5, arr5 + 9, std::greater()); mystl::sort(arr6, arr6 + 9, std::greater()); EXPECT_CON_EQ(arr1, arr2); EXPECT_CON_EQ(arr3, arr4); EXPECT_CON_EQ(arr5, arr6); } TEST(swap_ranges_test) { int arr1[] = { 4,5,6,1,2,3 }; int arr2[] = { 4,5,6,1,2,3 }; int arr3[] = { 1,2,3,4,5,6 }; int arr4[] = { 1,2,3,4,5,6 }; int arr5[] = { 1,1,1 }; int arr6[] = { 1,1,1 }; std::swap_ranges(arr1, arr1 + 6, arr3); mystl::swap_ranges(arr2, arr2 + 6, arr4); std::swap_ranges(arr1, arr1 + 3, arr5); mystl::swap_ranges(arr2, arr2 + 3, arr6); EXPECT_CON_EQ(arr1, arr2); EXPECT_CON_EQ(arr1, arr2); } TEST(transform_test) { int arr1[] = { 1,2,3,4,5,6,7,8,9 }; int arr2[] = { 9,8,7,6,5,4,3,2,1 }; int exp[9], act[9]; std::transform(arr1, arr1 + 9, exp, unary_op); mystl::transform(arr1, arr1 + 9, act, unary_op); EXPECT_CON_EQ(exp, act); std::transform(arr1, arr1 + 9, arr2, exp, binary_op); mystl::transform(arr1, arr1 + 9, arr2, act, binary_op); EXPECT_CON_EQ(exp, act); } TEST(unique_test) { int arr1[] = { 1,1,1,2,2,3,4,4,5,6 }; int arr2[] = { 1,1,1,2,2,3,4,4,5,6 }; int arr3[] = { 1,2,3,6,6,6,8,8,9 }; int arr4[] = { 1,2,3,6,6,6,8,8,9 }; std::unique(arr1, arr1 + 10); mystl::unique(arr2, arr2 + 10); std::unique(arr3, arr3 + 9, std::equal_to()); mystl::unique(arr4, arr4 + 9, std::equal_to()); EXPECT_CON_EQ(arr1, arr2); EXPECT_CON_EQ(arr3, arr4); } TEST(unique_copy_test) { int arr1[] = { 1,1,1,2,2,3,4,4,5,6 }; int arr2[] = { 1,2,3,6,6,6,8,8,9 }; int exp[6], act[6]; std::unique_copy(arr1, arr1 + 10, exp); mystl::unique_copy(arr1, arr1 + 10, act); EXPECT_CON_EQ(exp, act); std::unique_copy(arr2, arr2 + 9, exp, std::equal_to()); mystl::unique_copy(arr2, arr2 + 9, act, std::equal_to()); EXPECT_CON_EQ(exp, act); } TEST(upper_bound_test) { int arr1[] = { 1,2,3,3,3,4,5,6,6 }; EXPECT_EQ(std::upper_bound(arr1, arr1 + 9, 0), mystl::upper_bound(arr1, arr1 + 9, 0)); EXPECT_EQ(std::upper_bound(arr1, arr1 + 9, 1), mystl::upper_bound(arr1, arr1 + 9, 1)); EXPECT_EQ(std::upper_bound(arr1, arr1 + 9, 3), mystl::upper_bound(arr1, arr1 + 9, 3)); EXPECT_EQ(std::upper_bound(arr1, arr1 + 9, 6, std::less()), mystl::upper_bound(arr1, arr1 + 9, 6, std::less())); EXPECT_EQ(std::upper_bound(arr1, arr1 + 9, 7, std::less()), mystl::upper_bound(arr1, arr1 + 9, 7, std::less())); } } // namespace algorithm_test #ifdef _MSC_VER #pragma warning(pop) #endif // _MSC_VER } // namespace test } // namespace mystl #endif // !MYTINYSTL_ALGORITHM_TEST_H_ ================================================ FILE: Test/deque_test.h ================================================ #ifndef MYTINYSTL_DEQUE_TEST_H_ #define MYTINYSTL_DEQUE_TEST_H_ // deque test : 测试 deque 的接口和 push_front/push_back 的性能 #include #include "../MyTinySTL/deque.h" #include "test.h" namespace mystl { namespace test { namespace deque_test { void deque_test() { std::cout << "[===============================================================]" << std::endl; std::cout << "[----------------- Run container test : deque ------------------]" << std::endl; std::cout << "[-------------------------- API test ---------------------------]" << std::endl; int a[] = { 1,2,3,4,5 }; mystl::deque d1; mystl::deque d2(5); mystl::deque d3(5, 1); mystl::deque d4(a, a + 5); mystl::deque d5(d2); mystl::deque d6(std::move(d2)); mystl::deque d7; d7 = d3; mystl::deque d8; d8 = std::move(d3); mystl::deque d9{ 1,2,3,4,5,6,7,8,9 }; mystl::deque d10; d10 = { 1,2,3,4,5,6,7,8,9 }; FUN_AFTER(d1, d1.assign(5, 1)); FUN_AFTER(d1, d1.assign(8, 8)); FUN_AFTER(d1, d1.assign(a, a + 5)); FUN_AFTER(d1, d1.assign({ 1,2,3,4,5 })); FUN_AFTER(d1, d1.insert(d1.end(), 6)); FUN_AFTER(d1, d1.insert(d1.end() - 1, 2, 7)); FUN_AFTER(d1, d1.insert(d1.begin(), a, a + 5)); FUN_AFTER(d1, d1.erase(d1.begin())); FUN_AFTER(d1, d1.erase(d1.begin(), d1.begin() + 4)); FUN_AFTER(d1, d1.emplace_back(8)); FUN_AFTER(d1, d1.emplace_front(8)); FUN_AFTER(d1, d1.emplace(d1.begin() + 1, 9)); FUN_AFTER(d1, d1.push_front(1)); FUN_AFTER(d1, d1.push_back(2)); FUN_AFTER(d1, d1.pop_back()); FUN_AFTER(d1, d1.pop_front()); FUN_AFTER(d1, d1.shrink_to_fit()); FUN_AFTER(d1, d1.resize(5)); FUN_AFTER(d1, d1.resize(8, 8)); FUN_AFTER(d1, d1.clear()); FUN_AFTER(d1, d1.shrink_to_fit()); FUN_AFTER(d1, d1.swap(d4)); FUN_VALUE(*(d1.begin())); FUN_VALUE(*(d1.end() - 1)); FUN_VALUE(*(d1.rbegin())); FUN_VALUE(*(d1.rend() - 1)); FUN_VALUE(d1.front()); FUN_VALUE(d1.back()); FUN_VALUE(d1.at(1)); FUN_VALUE(d1[2]); std::cout << std::boolalpha; FUN_VALUE(d1.empty()); std::cout << std::noboolalpha; FUN_VALUE(d1.size()); FUN_VALUE(d1.max_size()); PASSED; #if PERFORMANCE_TEST_ON std::cout << "[--------------------- Performance Testing ---------------------]" << std::endl; std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl; std::cout << "| push_front |"; #if LARGER_TEST_DATA_ON CON_TEST_P1(deque, push_front, rand(), SCALE_LL(LEN1), SCALE_LL(LEN2), SCALE_LL(LEN3)); #else CON_TEST_P1(deque, push_front, rand(), SCALE_L(LEN1), SCALE_L(LEN2), SCALE_L(LEN3)); #endif std::cout << std::endl; std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl; std::cout << "| push_back |"; #if LARGER_TEST_DATA_ON CON_TEST_P1(deque, push_back, rand(), SCALE_LL(LEN1), SCALE_LL(LEN2), SCALE_LL(LEN3)); #else CON_TEST_P1(deque, push_back, rand(), SCALE_L(LEN1), SCALE_L(LEN2), SCALE_L(LEN3)); #endif std::cout << std::endl; std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl; PASSED; #endif std::cout << "[----------------- End container test : deque ------------------]" << std::endl; } } // namespace deque_test } // namespace test } // namespace mystl #endif // !MYTINYSTL_DEQUE_TEST_H_ ================================================ FILE: Test/iterator_test.h ================================================ #ifndef MYTINYSTL_ITERATOR_TEST_H_ #define MYTINYSTL_ITERATOR_TEST_H_ #include "test.h" #include "../MyTinySTL/iterator.h" #include "../MyTinySTL/stream_iterator.h" namespace mystl { namespace test { namespace iterator_test { void stream_iterator_test() { std::cout << "[===============================================================]\n"; std::cout << "[------------- Run iterator test : stream_iterator--------------]\n"; std::cout << "[-------------------------- API test ---------------------------]\n"; static_assert(mystl::is_exactly_input_iterator>::value, "istream_iterator must have input_iterator_tag)"); std::istringstream is("1 2 3"); mystl::istream_iterator first{is}, last; std::cout << mystl::distance(first, last) << '\n'; std::istringstream istream("1 2 3 4 5 6"); mystl::istream_iterator beg{istream}, end; for (; beg != end; ++beg) { std::cout << *beg << " "; } std::cout << '\n'; PASSED; } } // namespace stream_iterator_test } // namespace test } // namespace mystl #endif // !MYTINYSTL_STREAM_ITERATOR_TEST_H_ ================================================ FILE: Test/list_test.h ================================================ #ifndef MYTINYSTL_LIST_TEST_H_ #define MYTINYSTL_LIST_TEST_H_ // list test : 测试 list 的接口与 insert, sort 的性能 #include #include "../MyTinySTL/list.h" #include "test.h" namespace mystl { namespace test { namespace list_test { // 一个辅助测试函数 bool is_odd(int x) { return x & 1; } void list_test() { std::cout << "[===============================================================]" << std::endl; std::cout << "[------------------ Run container test : list ------------------]" << std::endl; std::cout << "[-------------------------- API test ---------------------------]" << std::endl; int a[] = { 1,2,3,4,5 }; mystl::list l1; mystl::list l2(5); mystl::list l3(5, 1); mystl::list l4(a, a + 5); mystl::list l5(l2); mystl::list l6(std::move(l2)); mystl::list l7{ 1,2,3,4,5,6,7,8,9 }; mystl::list l8; l8 = l3; mystl::list l9; l9 = std::move(l3); mystl::list l10; l10 = { 1, 2, 2, 3, 5, 6, 7, 8, 9 }; FUN_AFTER(l1, l1.assign(8, 8)); FUN_AFTER(l1, l1.assign(a, a + 5)); FUN_AFTER(l1, l1.assign({ 1,2,3,4,5,6 })); FUN_AFTER(l1, l1.insert(l1.end(), 6)); FUN_AFTER(l1, l1.insert(l1.end(), 2, 7)); FUN_AFTER(l1, l1.insert(l1.begin(), a, a + 5)); FUN_AFTER(l1, l1.push_back(2)); FUN_AFTER(l1, l1.push_front(1)); FUN_AFTER(l1, l1.emplace(l1.begin(),1)); FUN_AFTER(l1, l1.emplace_front(0)); FUN_AFTER(l1, l1.emplace_back(10)); FUN_VALUE(l1.size()); FUN_AFTER(l1, l1.pop_front()); FUN_AFTER(l1, l1.pop_back()); FUN_AFTER(l1, l1.erase(l1.begin())); FUN_AFTER(l1, l1.erase(l1.begin(), l1.end())); FUN_VALUE(l1.size()); FUN_AFTER(l1, l1.resize(10)); FUN_AFTER(l1, l1.resize(5, 1)); FUN_AFTER(l1, l1.resize(8, 2)); FUN_VALUE(l1.size()); FUN_AFTER(l1, l1.splice(l1.end(), l4)); FUN_AFTER(l1, l1.splice(l1.begin(), l5, l5.begin())); FUN_AFTER(l1, l1.splice(l1.end(), l6, l6.begin(), ++l6.begin())); FUN_VALUE(l1.size()); FUN_AFTER(l1, l1.remove(0)); FUN_AFTER(l1, l1.remove_if(is_odd)); FUN_VALUE(l1.size()); FUN_AFTER(l1, l1.assign({ 9,5,3,3,7,1,3,2,2,0,10 })); FUN_VALUE(l1.size()); FUN_AFTER(l1, l1.sort()); FUN_AFTER(l1, l1.unique()); FUN_AFTER(l1, l1.unique([&](int a, int b) {return b == a + 1; })); FUN_AFTER(l1, l1.merge(l7)); FUN_AFTER(l1, l1.sort(mystl::greater())); FUN_AFTER(l1, l1.merge(l8, mystl::greater())); FUN_AFTER(l1, l1.reverse()); FUN_AFTER(l1, l1.clear()); FUN_AFTER(l1, l1.swap(l9)); FUN_VALUE(*l1.begin()); FUN_VALUE(*l1.rbegin()); FUN_VALUE(l1.front()); FUN_VALUE(l1.back()); std::cout << std::boolalpha; FUN_VALUE(l1.empty()); std::cout << std::noboolalpha; FUN_VALUE(l1.size()); FUN_VALUE(l1.max_size()); PASSED; #if PERFORMANCE_TEST_ON std::cout << "[--------------------- Performance Testing ---------------------]" << std::endl; std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl; std::cout << "| insert |"; #if LARGER_TEST_DATA_ON CON_TEST_P2(list, insert, end, rand(), SCALE_L(LEN1), SCALE_L(LEN2), SCALE_L(LEN3)); #else CON_TEST_P2(list, insert, end, rand(), SCALE_M(LEN1), SCALE_M(LEN2), SCALE_M(LEN3)); #endif std::cout << std::endl; std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl; std::cout << "| sort |"; #if LARGER_TEST_DATA_ON LIST_SORT_TEST(SCALE_M(LEN1), SCALE_M(LEN2), SCALE_M(LEN3)); #else LIST_SORT_TEST(SCALE_S(LEN1), SCALE_S(LEN2), SCALE_S(LEN3)); #endif std::cout << std::endl; std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl; PASSED; #endif std::cout << "[------------------ End container test : list ------------------]" << std::endl; } } // namespace list_test } // namespace test } // namespace mystl #endif // !MYTINYSTL_LIST_TEST_H_ ================================================ FILE: Test/map_test.h ================================================ #ifndef MYTINYSTL_MAP_TEST_H_ #define MYTINYSTL_MAP_TEST_H_ // map test : 测试 map, multimap 的接口与它们 insert 的性能 #include #include "../MyTinySTL/map.h" #include "../MyTinySTL/vector.h" #include "test.h" namespace mystl { namespace test { namespace map_test { // pair 的宏定义 #define PAIR mystl::pair // map 的遍历输出 #define MAP_COUT(m) do { \ std::string m_name = #m; \ std::cout << " " << m_name << " :"; \ for (auto it : m) std::cout << " <" << it.first << "," << it.second << ">"; \ std::cout << std::endl; \ } while(0) // map 的函数操作 #define MAP_FUN_AFTER(con, fun) do { \ std::string str = #fun; \ std::cout << " After " << str << " :" << std::endl; \ fun; \ MAP_COUT(con); \ } while(0) // map 的函数值 #define MAP_VALUE(fun) do { \ std::string str = #fun; \ auto it = fun; \ std::cout << " " << str << " : <" << it.first << "," << it.second << ">\n"; \ } while(0) void map_test() { std::cout << "[===============================================================]" << std::endl; std::cout << "[------------------ Run container test : map -------------------]" << std::endl; std::cout << "[-------------------------- API test ---------------------------]" << std::endl; mystl::vector v; for (int i = 0; i < 5; ++i) v.push_back(PAIR(i, i)); mystl::map m1; mystl::map> m2; mystl::map m3(v.begin(), v.end()); mystl::map m4(v.begin(), v.end()); mystl::map m5(m3); mystl::map m6(std::move(m3)); mystl::map m7; m7 = m4; mystl::map m8; m8 = std::move(m4); mystl::map m9{ PAIR(1,1),PAIR(3,2),PAIR(2,3) }; mystl::map m10; m10 = { PAIR(1,1),PAIR(3,2),PAIR(2,3) }; for (int i = 5; i > 0; --i) { MAP_FUN_AFTER(m1, m1.emplace(i, i)); } MAP_FUN_AFTER(m1, m1.emplace_hint(m1.begin(), 0, 0)); MAP_FUN_AFTER(m1, m1.erase(m1.begin())); MAP_FUN_AFTER(m1, m1.erase(0)); MAP_FUN_AFTER(m1, m1.erase(1)); MAP_FUN_AFTER(m1, m1.erase(m1.begin(), m1.end())); for (int i = 0; i < 5; ++i) { MAP_FUN_AFTER(m1, m1.insert(PAIR(i, i))); } MAP_FUN_AFTER(m1, m1.insert(v.begin(), v.end())); MAP_FUN_AFTER(m1, m1.insert(m1.end(), PAIR(5, 5))); FUN_VALUE(m1.count(1)); MAP_VALUE(*m1.find(3)); MAP_VALUE(*m1.lower_bound(3)); MAP_VALUE(*m1.upper_bound(2)); auto first = *m1.equal_range(2).first; auto second = *m1.equal_range(2).second; std::cout << " m1.equal_range(2) : from <" << first.first << ", " << first.second << "> to <" << second.first << ", " << second.second << ">" << std::endl; MAP_FUN_AFTER(m1, m1.erase(m1.begin())); MAP_FUN_AFTER(m1, m1.erase(1)); MAP_FUN_AFTER(m1, m1.erase(m1.begin(), m1.find(3))); MAP_FUN_AFTER(m1, m1.clear()); MAP_FUN_AFTER(m1, m1.swap(m9)); MAP_VALUE(*m1.begin()); MAP_VALUE(*m1.rbegin()); FUN_VALUE(m1[1]); MAP_FUN_AFTER(m1, m1[1] = 3); FUN_VALUE(m1.at(1)); std::cout << std::boolalpha; FUN_VALUE(m1.empty()); std::cout << std::noboolalpha; FUN_VALUE(m1.size()); FUN_VALUE(m1.max_size()); PASSED; #if PERFORMANCE_TEST_ON std::cout << "[--------------------- Performance Testing ---------------------]" << std::endl; std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl; std::cout << "| emplace |"; #if LARGER_TEST_DATA_ON MAP_EMPLACE_TEST(map, SCALE_L(LEN1), SCALE_L(LEN2), SCALE_L(LEN3)); #else MAP_EMPLACE_TEST(map, SCALE_M(LEN1), SCALE_M(LEN2), SCALE_M(LEN3)); #endif std::cout << std::endl; std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl; PASSED; #endif std::cout << "[------------------ End container test : map -------------------]" << std::endl; } void multimap_test() { std::cout << "[===============================================================]" << std::endl; std::cout << "[---------------- Run container test : multimap ----------------]" << std::endl; std::cout << "[-------------------------- API test ---------------------------]" << std::endl; mystl::vector v; for (int i = 0; i < 5; ++i) v.push_back(PAIR(i, i)); mystl::multimap m1; mystl::multimap> m2; mystl::multimap m3(v.begin(), v.end()); mystl::multimap m4(v.begin(), v.end()); mystl::multimap m5(m3); mystl::multimap m6(std::move(m3)); mystl::multimap m7; m7 = m4; mystl::multimap m8; m8 = std::move(m4); mystl::multimap m9{ PAIR(1,1),PAIR(3,2),PAIR(2,3) }; mystl::multimap m10; m10 = { PAIR(1,1),PAIR(3,2),PAIR(2,3) }; for (int i = 5; i > 0; --i) { MAP_FUN_AFTER(m1, m1.emplace(i, i)); } MAP_FUN_AFTER(m1, m1.emplace_hint(m1.begin(), 0, 0)); MAP_FUN_AFTER(m1, m1.erase(m1.begin())); MAP_FUN_AFTER(m1, m1.erase(0)); MAP_FUN_AFTER(m1, m1.erase(1)); MAP_FUN_AFTER(m1, m1.erase(m1.begin(), m1.end())); for (int i = 0; i < 5; ++i) { MAP_FUN_AFTER(m1, m1.insert(mystl::make_pair(i, i))); } MAP_FUN_AFTER(m1, m1.insert(v.begin(), v.end())); MAP_FUN_AFTER(m1, m1.insert(PAIR(5, 5))); MAP_FUN_AFTER(m1, m1.insert(m1.end(), PAIR(5, 5))); FUN_VALUE(m1.count(3)); MAP_VALUE(*m1.find(3)); MAP_VALUE(*m1.lower_bound(3)); MAP_VALUE(*m1.upper_bound(2)); auto first = *m1.equal_range(2).first; auto second = *m1.equal_range(2).second; std::cout << " m1.equal_range(2) : from <" << first.first << ", " << first.second << "> to <" << second.first << ", " << second.second << ">" << std::endl; MAP_FUN_AFTER(m1, m1.erase(m1.begin())); MAP_FUN_AFTER(m1, m1.erase(1)); MAP_FUN_AFTER(m1, m1.erase(m1.begin(), m1.find(3))); MAP_FUN_AFTER(m1, m1.clear()); MAP_FUN_AFTER(m1, m1.swap(m9)); MAP_FUN_AFTER(m1, m1.insert(PAIR(3, 3))); MAP_VALUE(*m1.begin()); MAP_VALUE(*m1.rbegin()); std::cout << std::boolalpha; FUN_VALUE(m1.empty()); std::cout << std::noboolalpha; FUN_VALUE(m1.size()); FUN_VALUE(m1.max_size()); PASSED; #if PERFORMANCE_TEST_ON std::cout << "[--------------------- Performance Testing ---------------------]" << std::endl; std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl; std::cout << "| emplace |"; #if LARGER_TEST_DATA_ON MAP_EMPLACE_TEST(multimap, SCALE_M(LEN1), SCALE_M(LEN2), SCALE_M(LEN3)); #else MAP_EMPLACE_TEST(multimap, SCALE_S(LEN1), SCALE_S(LEN2), SCALE_S(LEN3)); #endif std::cout << std::endl; std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl; PASSED; #endif std::cout << "[---------------- End container test : multimap ----------------]" << std::endl; } } // namespace map_test } // namespace test } // namespace mystl #endif // !MYTINYSTL_MAP_TEST_H_ ================================================ FILE: Test/queue_test.h ================================================ #ifndef MYTINYSTL_QUEUE_TEST_H_ #define MYTINYSTL_QUEUE_TEST_H_ // queue test : 测试 queue, priority_queue 的接口和它们 push 的性能 #include #include "../MyTinySTL/queue.h" #include "test.h" namespace mystl { namespace test { namespace queue_test { void queue_print(mystl::queue q) { while (!q.empty()) { std::cout << " " << q.front(); q.pop(); } std::cout << std::endl; } void p_queue_print(mystl::priority_queue p) { while (!p.empty()) { std::cout << " " << p.top(); p.pop(); } std::cout << std::endl; } // queue 的遍历输出 #define QUEUE_COUT(q) do { \ std::string q_name = #q; \ std::cout << " " << q_name << " :"; \ queue_print(q); \ } while(0) // priority_queue 的遍历输出 #define P_QUEUE_COUT(p) do { \ std::string p_name = #p; \ std::cout << " " << p_name << " :"; \ p_queue_print(p); \ } while(0) #define QUEUE_FUN_AFTER(con, fun) do { \ std::string fun_name = #fun; \ std::cout << " After " << fun_name << " :\n"; \ fun; \ QUEUE_COUT(con); \ } while(0) #define P_QUEUE_FUN_AFTER(con, fun) do { \ std::string fun_name = #fun; \ std::cout << " After " << fun_name << " :\n"; \ fun; \ P_QUEUE_COUT(con); \ } while(0) void queue_test() { std::cout << "[===============================================================]" << std::endl; std::cout << "[----------------- Run container test : queue ------------------]" << std::endl; std::cout << "[-------------------------- API test ---------------------------]" << std::endl; int a[] = { 1,2,3,4,5 }; mystl::deque d1(5); mystl::queue q1; mystl::queue q2(5); mystl::queue q3(5, 1); mystl::queue q4(a, a + 5); mystl::queue q5(d1); mystl::queue q6(std::move(d1)); mystl::queue q7(q2); mystl::queue q8(std::move(q2)); mystl::queue q9; q9 = q3; mystl::queue q10; q10 = std::move(q3); mystl::queue q11{ 1,2,3,4,5 }; mystl::queue q12; q12 = { 1,2,3,4,5 }; QUEUE_FUN_AFTER(q1, q1.push(1)); QUEUE_FUN_AFTER(q1, q1.push(2)); QUEUE_FUN_AFTER(q1, q1.push(3)); QUEUE_FUN_AFTER(q1, q1.pop()); QUEUE_FUN_AFTER(q1, q1.emplace(4)); QUEUE_FUN_AFTER(q1, q1.emplace(5)); std::cout << std::boolalpha; FUN_VALUE(q1.empty()); std::cout << std::noboolalpha; FUN_VALUE(q1.size()); FUN_VALUE(q1.front()); FUN_VALUE(q1.back()); while (!q1.empty()) { QUEUE_FUN_AFTER(q1, q1.pop()); } QUEUE_FUN_AFTER(q1, q1.swap(q4)); QUEUE_FUN_AFTER(q1, q1.clear()); PASSED; #if PERFORMANCE_TEST_ON std::cout << "[--------------------- Performance Testing ---------------------]" << std::endl; std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl; std::cout << "| push |"; #if LARGER_TEST_DATA_ON CON_TEST_P1(queue, push, rand(), SCALE_LL(LEN1), SCALE_LL(LEN2), SCALE_LL(LEN3)); #else CON_TEST_P1(queue, push, rand(), SCALE_L(LEN1), SCALE_L(LEN2), SCALE_L(LEN3)); #endif std::cout << std::endl; std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl; PASSED; #endif std::cout << "[----------------- End container test : queue ------------------]" << std::endl; } void priority_test() { std::cout << "[===============================================================]" << std::endl; std::cout << "[------------- Run container test : priority_queue -------------]" << std::endl; std::cout << "[-------------------------- API test ---------------------------]" << std::endl; int a[] = { 1,2,3,4,5 }; mystl::vector v1(5); mystl::priority_queue p1; mystl::priority_queue p2(5); mystl::priority_queue p3(5, 1); mystl::priority_queue p4(a, a + 5); mystl::priority_queue p5(v1); mystl::priority_queue p6(std::move(v1)); mystl::priority_queue p7(p2); mystl::priority_queue p8(std::move(p2)); mystl::priority_queue p9; p9 = p3; mystl::priority_queue p10; p10 = std::move(p3); mystl::priority_queue p11{ 1,2,3,4,5 }; mystl::priority_queue p12; p12 = { 1,2,3,4,5 }; P_QUEUE_FUN_AFTER(p1, p1.push(1)); P_QUEUE_FUN_AFTER(p1, p1.push(5)); P_QUEUE_FUN_AFTER(p1, p1.push(3)); P_QUEUE_FUN_AFTER(p1, p1.pop()); P_QUEUE_FUN_AFTER(p1, p1.emplace(7)); P_QUEUE_FUN_AFTER(p1, p1.emplace(2)); P_QUEUE_FUN_AFTER(p1, p1.emplace(8)); std::cout << std::boolalpha; FUN_VALUE(p1.empty()); std::cout << std::noboolalpha; FUN_VALUE(p1.size()); FUN_VALUE(p1.top()); while (!p1.empty()) { P_QUEUE_FUN_AFTER(p1, p1.pop()); } P_QUEUE_FUN_AFTER(p1, p1.swap(p4)); P_QUEUE_FUN_AFTER(p1, p1.clear()); PASSED; #if PERFORMANCE_TEST_ON std::cout << "[--------------------- Performance Testing ---------------------]" << std::endl; std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl; std::cout << "| push |"; #if LARGER_TEST_DATA_ON CON_TEST_P1(priority_queue, push, rand(), SCALE_LL(LEN1), SCALE_LL(LEN2), SCALE_LL(LEN3)); #else CON_TEST_P1(priority_queue, push, rand(), SCALE_L(LEN1), SCALE_L(LEN2), SCALE_L(LEN3)); #endif std::cout << std::endl; std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl; PASSED; #endif std::cout << "[------------- End container test : priority_queue -------------]" << std::endl; } } // namespace queue_test } // namespace test } // namespace mystl #endif // !MYTINYSTL_QUEUE_TEST_H_ ================================================ FILE: Test/set_test.h ================================================ #ifndef MYTINYSTL_SET_TEST_H_ #define MYTINYSTL_SET_TEST_H_ // set test : 测试 set, multiset 的接口与它们 insert 的性能 #include #include "../MyTinySTL/set.h" #include "test.h" namespace mystl { namespace test { namespace set_test { void set_test() { std::cout << "[===============================================================]" << std::endl; std::cout << "[------------------ Run container test : set -------------------]" << std::endl; std::cout << "[-------------------------- API test ---------------------------]" << std::endl; int a[] = { 5,4,3,2,1 }; mystl::set s1; mystl::set> s2; mystl::set s3(a, a + 5); mystl::set s4(a, a + 5); mystl::set s5(s3); mystl::set s6(std::move(s3)); mystl::set s7; s7 = s4; mystl::set s8; s8 = std::move(s4); mystl::set s9{ 1,2,3,4,5 }; mystl::set s10; s10 = { 1,2,3,4,5 }; for (int i = 5; i > 0; --i) { FUN_AFTER(s1, s1.emplace(i)); } FUN_AFTER(s1, s1.emplace_hint(s1.begin(), 0)); FUN_AFTER(s1, s1.erase(s1.begin())); FUN_AFTER(s1, s1.erase(0)); FUN_AFTER(s1, s1.erase(1)); FUN_AFTER(s1, s1.erase(s1.begin(), s1.end())); for (int i = 0; i < 5; ++i) { FUN_AFTER(s1, s1.insert(i)); } FUN_AFTER(s1, s1.insert(a, a + 5)); FUN_AFTER(s1, s1.insert(5)); FUN_AFTER(s1, s1.insert(s1.end(), 5)); FUN_VALUE(s1.count(5)); FUN_VALUE(*s1.find(3)); FUN_VALUE(*s1.lower_bound(3)); FUN_VALUE(*s1.upper_bound(3)); auto first = *s1.equal_range(3).first; auto second = *s1.equal_range(3).second; std::cout << " s1.equal_range(3) : from " << first << " to " << second << std::endl; FUN_AFTER(s1, s1.erase(s1.begin())); FUN_AFTER(s1, s1.erase(1)); FUN_AFTER(s1, s1.erase(s1.begin(), s1.find(3))); FUN_AFTER(s1, s1.clear()); FUN_AFTER(s1, s1.swap(s5)); FUN_VALUE(*s1.begin()); FUN_VALUE(*s1.rbegin()); std::cout << std::boolalpha; FUN_VALUE(s1.empty()); std::cout << std::noboolalpha; FUN_VALUE(s1.size()); FUN_VALUE(s1.max_size()); PASSED; #if PERFORMANCE_TEST_ON std::cout << "[--------------------- Performance Testing ---------------------]" << std::endl; std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl; std::cout << "| emplace |"; #if LARGER_TEST_DATA_ON CON_TEST_P1(set, emplace, rand(), SCALE_L(LEN1), SCALE_L(LEN2), SCALE_L(LEN3)); #else CON_TEST_P1(set, emplace, rand(), SCALE_M(LEN1), SCALE_M(LEN2), SCALE_M(LEN3)); #endif std::cout << std::endl; std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl; PASSED; #endif std::cout << "[------------------ End container test : set -------------------]" << std::endl; } void multiset_test() { std::cout << "[===============================================================]" << std::endl; std::cout << "[---------------- Run container test : multiset ----------------]" << std::endl; std::cout << "[-------------------------- API test ---------------------------]" << std::endl; int a[] = { 5,4,3,2,1 }; mystl::multiset s1; mystl::multiset> s2; mystl::multiset s3(a, a + 5); mystl::multiset s4(a, a + 5); mystl::multiset s5(s3); mystl::multiset s6(std::move(s3)); mystl::multiset s7; s7 = s4; mystl::multiset s8; s8 = std::move(s4); mystl::multiset s9{ 1,2,3,4,5 }; mystl::multiset s10; s10 = { 1,2,3,4,5 }; for (int i = 5; i > 0; --i) { FUN_AFTER(s1, s1.emplace(i)); } FUN_AFTER(s1, s1.emplace_hint(s1.begin(), 0)); FUN_AFTER(s1, s1.erase(s1.begin())); FUN_AFTER(s1, s1.erase(0)); FUN_AFTER(s1, s1.erase(1)); FUN_AFTER(s1, s1.erase(s1.begin(), s1.end())); for (int i = 0; i < 5; ++i) { FUN_AFTER(s1, s1.insert(i)); } FUN_AFTER(s1, s1.insert(a, a + 5)); FUN_AFTER(s1, s1.insert(5)); FUN_AFTER(s1, s1.insert(s1.end(), 5)); FUN_VALUE(s1.count(5)); FUN_VALUE(*s1.find(3)); FUN_VALUE(*s1.lower_bound(3)); FUN_VALUE(*s1.upper_bound(3)); auto first = *s1.equal_range(3).first; auto second = *s1.equal_range(3).second; std::cout << " s1.equal_range(3) : from " << first << " to " << second << std::endl; FUN_AFTER(s1, s1.erase(s1.begin())); FUN_AFTER(s1, s1.erase(1)); FUN_AFTER(s1, s1.erase(s1.begin(), s1.find(3))); FUN_AFTER(s1, s1.clear()); FUN_AFTER(s1, s1.swap(s5)); FUN_VALUE(*s1.begin()); FUN_VALUE(*s1.rbegin()); std::cout << std::boolalpha; FUN_VALUE(s1.empty()); std::cout << std::noboolalpha; FUN_VALUE(s1.size()); FUN_VALUE(s1.max_size()); PASSED; #if PERFORMANCE_TEST_ON std::cout << "[--------------------- Performance Testing ---------------------]" << std::endl; std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl; std::cout << "| emplace |"; #if LARGER_TEST_DATA_ON CON_TEST_P1(multiset, emplace, rand(), SCALE_M(LEN1), SCALE_M(LEN2), SCALE_M(LEN3)); #else CON_TEST_P1(multiset, emplace, rand(), SCALE_S(LEN1), SCALE_S(LEN2), SCALE_S(LEN3)); #endif std::cout << std::endl; std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl; PASSED; #endif std::cout << "[---------------- End container test : multiset ----------------]" << std::endl; } } // namespace set_test } // namespace test } // namespace mystl #endif // !MYTINYSTL_SET_TEST_H_ ================================================ FILE: Test/stack_test.h ================================================ #ifndef MYTINYSTL_STACK_TEST_H_ #define MYTINYSTL_STACK_TEST_H_ // stack test : 测试 stack 的接口 和 push 的性能 #include #include "../MyTinySTL/stack.h" #include "test.h" namespace mystl { namespace test { namespace stack_test { void stack_print(mystl::stack s) { while (!s.empty()) { std::cout << " " << s.top(); s.pop(); } std::cout << std::endl; } // stack 的遍历输出 #define STACK_COUT(s) do { \ std::string s_name = #s; \ std::cout << " " << s_name << " :"; \ stack_print(s); \ } while(0) #define STACK_FUN_AFTER(con, fun) do { \ std::string fun_name = #fun; \ std::cout << " After " << fun_name << " :\n"; \ fun; \ STACK_COUT(con); \ } while(0) void stack_test() { std::cout << "[===============================================================]" << std::endl; std::cout << "[----------------- Run container test : stack ------------------]" << std::endl; std::cout << "[-------------------------- API test ---------------------------]" << std::endl; int a[] = { 1,2,3,4,5 }; mystl::deque d1(5); mystl::stack s1; mystl::stack s2(5); mystl::stack s3(5, 1); mystl::stack s4(a, a + 5); mystl::stack s5(d1); mystl::stack s6(std::move(d1)); mystl::stack s7(s2); mystl::stack s8(std::move(s2)); mystl::stack s9; s9 = s3; mystl::stack s10; s10 = std::move(s3); mystl::stack s11{ 1,2,3,4,5 }; mystl::stack s12; s12 = { 1,2,3,4,5 }; STACK_FUN_AFTER(s1, s1.push(1)); STACK_FUN_AFTER(s1, s1.push(2)); STACK_FUN_AFTER(s1, s1.push(3)); STACK_FUN_AFTER(s1, s1.pop()); STACK_FUN_AFTER(s1, s1.emplace(4)); STACK_FUN_AFTER(s1, s1.emplace(5)); std::cout << std::boolalpha; FUN_VALUE(s1.empty()); std::cout << std::noboolalpha; FUN_VALUE(s1.size()); FUN_VALUE(s1.top()); while (!s1.empty()) { STACK_FUN_AFTER(s1, s1.pop()); } STACK_FUN_AFTER(s1, s1.swap(s4)); STACK_FUN_AFTER(s1, s1.clear()); PASSED; #if PERFORMANCE_TEST_ON std::cout << "[--------------------- Performance Testing ---------------------]" << std::endl; std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl; std::cout << "| push |"; #if LARGER_TEST_DATA_ON CON_TEST_P1(stack, push, rand(), SCALE_LL(LEN1), SCALE_LL(LEN2), SCALE_LL(LEN3)); #else CON_TEST_P1(stack, push, rand(), SCALE_L(LEN1), SCALE_L(LEN2), SCALE_L(LEN3)); #endif std::cout << std::endl; std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl; PASSED; #endif std::cout << "[----------------- End container test : stack ------------------]" << std::endl; } } // namespace stack_test } // namespace test } // namespace mystl #endif // !MYTINYSTL_STACK_TEST_H_ ================================================ FILE: Test/string_test.h ================================================ #ifndef MYTINYSTL_STRING_TEST_H_ #define MYTINYSTL_STRING_TEST_H_ // string test : 测试 string 的接口和 insert 的性能 #include #include "../MyTinySTL/astring.h" #include "test.h" namespace mystl { namespace test { namespace string_test { void string_test() { std::cout << "[===============================================================]" << std::endl; std::cout << "[----------------- Run container test : string -----------------]" << std::endl; std::cout << "[-------------------------- API test ---------------------------]" << std::endl; const char* s = "abcdefg"; mystl::string str; mystl::string str1(5, 'a'); mystl::string str2(str1, 3); mystl::string str3(str1, 0, 3); mystl::string str4("abc"); mystl::string str5("abcde",3); mystl::string str6(s, s + 5); mystl::string str7(str1); mystl::string str8(std::move(str1)); mystl::string str9; str9 = str2; mystl::string str10; str10 = std::move(str2); mystl::string str11; str11 = "123"; mystl::string str12; str12 = 'A'; STR_FUN_AFTER(str, str = 'a'); STR_FUN_AFTER(str, str = "string"); FUN_VALUE(*str.begin()); FUN_VALUE(*str.rbegin()); FUN_VALUE(*(str.end() - 1)); FUN_VALUE(*(str.rend() - 1)); FUN_VALUE(str.front()); FUN_VALUE(str.back()); FUN_VALUE(str[1]); FUN_VALUE(str.at(2)); STR_COUT(str.data()); STR_COUT(str.c_str()); std::cout << std::boolalpha; FUN_VALUE(str.empty()); std::cout << std::noboolalpha; FUN_VALUE(str.size()); FUN_VALUE(str.length()); FUN_VALUE(str.capacity()); FUN_VALUE(str.max_size()); STR_FUN_AFTER(str, str.shrink_to_fit()); FUN_VALUE(str.capacity()); STR_FUN_AFTER(str, str.insert(str.begin(), 'a')); STR_FUN_AFTER(str, str.insert(str.end(), 3, 'x')); STR_FUN_AFTER(str, str.insert(str.end(), s, s + 3)); STR_FUN_AFTER(str, str.erase(str.begin())); STR_FUN_AFTER(str, str.erase(str.begin(), str.begin() + 3)); STR_FUN_AFTER(str, str.clear()); STR_FUN_AFTER(str, str.push_back('s')); STR_FUN_AFTER(str, str.push_back('t')); STR_FUN_AFTER(str, str.pop_back()); STR_FUN_AFTER(str, str.append(1, 't')); STR_FUN_AFTER(str, str.append(str4)); STR_FUN_AFTER(str, str.append(str4, 1)); STR_FUN_AFTER(str, str.append(str4, 2, 1)); STR_FUN_AFTER(str, str.append("str")); STR_FUN_AFTER(str, str.append("inging", 3)); STR_FUN_AFTER(str, str.append(s, s + 3)); STR_FUN_AFTER(str, str.resize(10)); FUN_VALUE(str.size()); STR_FUN_AFTER(str, str.resize(20, 'x')); FUN_VALUE(str.size()); STR_FUN_AFTER(str, str.clear()); STR_FUN_AFTER(str, str = "string"); STR_FUN_AFTER(str3, str3 = "astrings"); FUN_VALUE(str.compare(str3)); FUN_VALUE(str.compare(0, 6, str3)); FUN_VALUE(str.compare(0, 6, str3, 1, 6)); FUN_VALUE(str.compare("atringgg")); FUN_VALUE(str.compare("zzz")); FUN_VALUE(str.compare(0, 3, "str")); FUN_VALUE(str.compare(0, 3, "stri", 4)); FUN_VALUE(str.compare(0, 3, "s", 2)); FUN_VALUE(str.compare(0, 9, "stringabc", 9)); FUN_VALUE(str.substr(0)); FUN_VALUE(str.substr(3)); FUN_VALUE(str.substr(0, 3)); FUN_VALUE(str.substr(0, 10)); STR_FUN_AFTER(str, str.replace(0, 6, str3)); STR_FUN_AFTER(str, str.replace(str.end() - 1, str.end(), str3)); STR_FUN_AFTER(str, str.replace(0, 1, "my ")); STR_FUN_AFTER(str, str.replace(str.end() - 8, str.end(), " test")); STR_FUN_AFTER(str, str.replace(10, 4, "replace")); STR_FUN_AFTER(str, str.replace(str.end(), str.end(), " test")); STR_FUN_AFTER(str, str.replace(0, 2, 3, '6')); STR_FUN_AFTER(str, str.replace(str.begin(), str.begin() + 3, 6, '6')); STR_FUN_AFTER(str, str.replace(0, 3, str3, 1, 3)); STR_FUN_AFTER(str, str.replace(str.begin(), str.begin() + 6, s, s + 3)); STR_FUN_AFTER(str, str.reverse()); STR_FUN_AFTER(str, str.reverse()); STR_FUN_AFTER(str, str = "abcabc stringgg"); STR_FUN_AFTER(str3, str3 = "abc"); FUN_VALUE(str.find('a')); FUN_VALUE(str.find('a', 3)); FUN_VALUE(str.find('a', 4)); FUN_VALUE(str.find("abc")); FUN_VALUE(str.find("abc", 1)); FUN_VALUE(str.find("abc", 1, 1)); FUN_VALUE(str.find(str3)); FUN_VALUE(str.find(str3, 1)); FUN_VALUE(str.rfind('g')); FUN_VALUE(str.rfind('g', 3)); FUN_VALUE(str.rfind("gg")); FUN_VALUE(str.rfind("bc", 10)); FUN_VALUE(str.rfind(str3)); FUN_VALUE(str.rfind(str3, 3)); FUN_VALUE(str.find_first_of('g')); FUN_VALUE(str.find_first_of('k')); FUN_VALUE(str.find_first_of("bca")); FUN_VALUE(str.find_first_of("defg", 10)); FUN_VALUE(str.find_first_of("gnirts")); FUN_VALUE(str.find_first_of("abc", 6)); FUN_VALUE(str.find_first_of("abcdf", 2, 3)); FUN_VALUE(str.find_first_of(str3, 1)); FUN_VALUE(str.find_first_of(str3, 10)); FUN_VALUE(str.find_first_not_of('a')); FUN_VALUE(str.find_first_not_of('d')); FUN_VALUE(str.find_first_not_of('g', 14)); FUN_VALUE(str.find_first_not_of("abc")); FUN_VALUE(str.find_first_not_of("ggggg", 14, 4)); FUN_VALUE(str.find_first_not_of(str3)); FUN_VALUE(str.find_first_not_of(str3, 3)); FUN_VALUE(str.find_last_of('a')); FUN_VALUE(str.find_last_of('a', 4)); FUN_VALUE(str.find_last_of('g')); FUN_VALUE(str.find_last_of("gg")); FUN_VALUE(str.find_last_of("gg", 14)); FUN_VALUE(str.find_last_of("ggg", 14, 1)); FUN_VALUE(str.find_last_of(str3)); FUN_VALUE(str.find_last_of(str3, 3)); FUN_VALUE(str.find_last_not_of('g')); FUN_VALUE(str.find_last_not_of('a')); FUN_VALUE(str.find_last_not_of('a', 1)); FUN_VALUE(str.find_last_not_of("ggg")); FUN_VALUE(str.find_last_not_of("ggg", 14)); FUN_VALUE(str.find_last_not_of("abc", 3, 1)); FUN_VALUE(str.find_last_not_of(str3)); FUN_VALUE(str.find_last_not_of(str3, 2)); FUN_VALUE(str.count('a')); FUN_VALUE(str.count('a', 2)); FUN_VALUE(str.count('d', 10)); STR_FUN_AFTER(str, str.swap(str3)); FUN_VALUE(str.size()); FUN_VALUE(str.length()); FUN_VALUE(str.capacity()); STR_FUN_AFTER(str, str += str); STR_FUN_AFTER(str, str += 'a'); STR_FUN_AFTER(str, str += "bc"); FUN_VALUE(str.size()); FUN_VALUE(str.length()); FUN_VALUE(str.capacity()); STR_FUN_AFTER(str, str.shrink_to_fit()); FUN_VALUE(str.capacity()); STR_FUN_AFTER(str, str.reserve(50)); FUN_VALUE(str.capacity()); STR_FUN_AFTER(str3, str3 = "test"); STR_FUN_AFTER(str4, str4 = " ok!"); std::cout << " str3 + '!' : " << str3 + '!' << std::endl; std::cout << " '#' + str3 : " << '#' + str3 << std::endl; std::cout << " str3 + \" success\" : " << str3 + " success" << std::endl; std::cout << " \"My \" + str3 : " << "My " + str3 << std::endl; std::cout << " str3 + str4 : " << str3 + str4 << std::endl; PASSED; #if PERFORMANCE_TEST_ON std::cout << "[--------------------- Performance Testing ---------------------]" << std::endl; std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl; std::cout << "| append |"; #if LARGER_TEST_DATA_ON CON_TEST_P1(string, append, "s", SCALE_LL(LEN1), SCALE_LL(LEN2), SCALE_LL(LEN3)); #else CON_TEST_P1(string, append, "s", SCALE_L(LEN1), SCALE_L(LEN2), SCALE_L(LEN3)); #endif std::cout << std::endl; std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl; PASSED; #endif std::cout << "[----------------- End container test : string -----------------]" << std::endl; } } // namespace string_test } // namespace test } // namespace mystl #endif // !MYTINYSTL_STRING_TEST_H_ ================================================ FILE: Test/test.cpp ================================================ #ifdef _MSC_VER #define _SCL_SECURE_NO_WARNINGS #endif #if defined(_MSC_VER) && defined(_DEBUG) #define _CRTDBG_MAP_ALLOC #include #include #endif // check memory leaks #include "algorithm_performance_test.h" #include "algorithm_test.h" #include "vector_test.h" #include "list_test.h" #include "deque_test.h" #include "queue_test.h" #include "stack_test.h" #include "map_test.h" #include "set_test.h" #include "unordered_map_test.h" #include "unordered_set_test.h" #include "string_test.h" #include "iterator_test.h" int main() { using namespace mystl::test; std::cout.sync_with_stdio(false); RUN_ALL_TESTS(); algorithm_performance_test::algorithm_performance_test(); iterator_test::stream_iterator_test(); vector_test::vector_test(); list_test::list_test(); deque_test::deque_test(); queue_test::queue_test(); queue_test::priority_test(); stack_test::stack_test(); map_test::map_test(); map_test::multimap_test(); set_test::set_test(); set_test::multiset_test(); unordered_map_test::unordered_map_test(); unordered_map_test::unordered_multimap_test(); unordered_set_test::unordered_set_test(); unordered_set_test::unordered_multiset_test(); string_test::string_test(); #if defined(_MSC_VER) && defined(_DEBUG) _CrtDumpMemoryLeaks(); #endif // check memory leaks } ================================================ FILE: Test/test.h ================================================ #ifndef MYTINYSTL_TEST_H_ #define MYTINYSTL_TEST_H_ // 一个简单的单元测试框架，定义了两个类 TestCase 和 UnitTest，以及一系列用于测试的宏 #include #include #include #include #include #include #include #include #include "Lib/redbud/io/color.h" namespace mystl { namespace test { #define green redbud::io::state::manual << redbud::io::hfg::green #define red redbud::io::state::manual << redbud::io::hfg::red #if defined(_MSC_VER) #pragma warning(disable : 4244) #pragma warning(disable : 4996) #endif } // namespace test namespace test { // TestCase 类 // 封装单个测试案例 class TestCase { public: // 构造函数，接受一个字符串代表案例名称 TestCase(const char* case_name) : testcase_name(case_name) {} // 一个纯虚函数，用于测试案例 virtual void Run() = 0; public: const char* testcase_name; // 测试案例的名称 int nTestResult; // 测试案例的执行结果 double nFailed; // 测试失败的案例数 double nPassed; // 测试通过的案例数 }; // UnitTest 类 // 单元测试，把所有测试案例加入到 vector 中，依次执行测试案例 class UnitTest { public: // 获取一个案例 static UnitTest* GetInstance(); // 将案例依次加入 vector TestCase* RegisterTestCase(TestCase* testcase); void Run(); public: TestCase* CurrentTestCase; // 当前执行的测试案例 double nPassed; // 通过案例数 double nFailed; // 失败案例数 protected: std::vector testcases_; // 保存案例集合 }; UnitTest* UnitTest::GetInstance() { static UnitTest instance; return &instance; } TestCase* UnitTest::RegisterTestCase(TestCase* testcase) { testcases_.push_back(testcase); return testcase; } void UnitTest::Run() { for (auto it : testcases_) { TestCase* testcase = it; CurrentTestCase = testcase; testcase->nTestResult = 1; testcase->nFailed = 0; testcase->nPassed = 0; std::cout << green << "============================================\n"; std::cout << green << " Run TestCase:" << testcase->testcase_name << "\n"; testcase->Run(); if (testcase->nFailed == 0) std::cout << green; else std::cout << red; std::cout << " " << testcase->nPassed << " / " << testcase->nFailed + testcase->nPassed << " Cases passed. ( " << testcase->nPassed / (testcase->nFailed + testcase->nPassed) * 100 << "% )\n"; std::cout << green << " End TestCase:" << testcase->testcase_name << "\n"; if (testcase->nTestResult) ++nPassed; else ++nFailed; } std::cout << green << "============================================\n"; std::cout << green << " Total TestCase : " << nPassed + nFailed << "\n"; std::cout << green << " Total Passed : " << nPassed << "\n"; std::cout << red << " Total Failed : " << nFailed << "\n"; std::cout << green << " " << nPassed << " / " << nFailed + nPassed << " TestCases passed. ( " << nPassed / (nFailed + nPassed) * 100 << "% )\n"; } /*****************************************************************************************/ // 测试案例的类名，替换为 test_cast_TEST #define TESTCASE_NAME(testcase_name) \ testcase_name##_TEST // 使用宏定义掩盖复杂的测试样例封装过程，把 TEXT 中的测试案例放到单元测试中 #define MYTINYSTL_TEST_(testcase_name) \ class TESTCASE_NAME(testcase_name) : public TestCase { \ public: \ TESTCASE_NAME(testcase_name)(const char* case_name) \ : TestCase(case_name) {}; \ virtual void Run(); \ private: \ static TestCase* const testcase_; \ }; \ \ TestCase* const TESTCASE_NAME(testcase_name) \ ::testcase_ = UnitTest::GetInstance()->RegisterTestCase( \ new TESTCASE_NAME(testcase_name)(#testcase_name)); \ void TESTCASE_NAME(testcase_name)::Run() /* Run()后边没有写实现，是为了用宏定义将测试用例放入到 Run 的实现里，例如： TEST(AddTestDemo) { EXPECT_EQ(3, Add(1, 2)); EXPECT_EQ(2, Add(1, 1)); } 上述代码将 { EXPECT_EQ(3, Add(1, 2)); EXPECT_EQ(2, Add(1, 1)); } 接到 Run() 的后面 */ /*****************************************************************************************/ // 简单测试的宏定义 // 断言 : 宏定义形式为 EXPECT_* ，符合验证条件的，案例测试通过，否则失败 // 使用一系列的宏来封装验证条件，分为以下几大类 : /* 真假断言 EXPECT_TRUE 验证条件: Condition 为 true EXPECT_FALSE 验证条件: Condition 为 false Example: bool isPrime(int n); 一个判断素数的函数 EXPECT_TRUE(isPrime(2)); 通过 EXPECT_FALSE(isPrime(4)); 通过 EXPECT_TRUE(isPrime(6)); 失败 EXPECT_FALSE(isPrime(3)); 失败 */ #define EXPECT_TRUE(Condition) do { \ if (Condition) { \ UnitTest::GetInstance()->CurrentTestCase->nPassed++; \ std::cout << green << " EXPECT_TRUE succeeded!\n"; \ } \ else { \ UnitTest::GetInstance()->CurrentTestCase->nTestResult = 0; \ UnitTest::GetInstance()->CurrentTestCase->nFailed++; \ std::cout << red << " EXPECT_TRUE failed!\n"; \ }} while(0) #define EXPECT_FALSE(Condition) do { \ if (!Condition) { \ UnitTest::GetInstance()->CurrentTestCase->nPassed++; \ std::cout << green << " EXPECT_FALSE succeeded!\n"; \ } \ else { \ UnitTest::GetInstance()->CurrentTestCase->nTestResult = 0; \ UnitTest::GetInstance()->CurrentTestCase->nFailed++; \ std::cout << red << " EXPECT_FALSE failed!\n"; \ }} while(0) /* 比较断言 EXPECT_EQ(v1, v2) 验证条件: v1 == v2 EXPECT_NE(v1, v2) 验证条件: v1 != v2 EXPECT_LT(v1, v2) 验证条件: v1 < v2 EXPECT_LE(v1, v2) 验证条件: v1 <= v2 EXPECT_GT(v1, v2) 验证条件: v1 > v2 EXPECT_GE(v1, v2) 验证条件: v1 >= v2 Note: 1. 参数应满足 EXPECT_*(Expect, Actual)的格式，左边是期望值，右边是实际值 2. 在断言失败时，会将期望值与实际值打印出来 3. 参数值必须是可通过断言的比较操作符进行比较的，参数值还必须支持 << 操作符来 将值输入到 ostream 中 4. 这些断言可以用于用户自定义型别，但必须重载相应的比较操作符（如 == 、< 等） 5. EXPECT_EQ 对指针进行的是地址比较。即比较的是它们是否指向相同的内存地址， 而不是它们指向的内容是否相等。如果想比较两个 C 字符串(const char*)的值， 请使用 EXPECT_STREQ 。特别一提的是，要验证一个 C 字符串是否为空(NULL)， 请使用 EXPECT_STREQ(NULL, c_str)。但是要比较两个 string 对象时， 应该使用 EXPECT_EQ Example: EXPECT_EQ(3, foo()); EXPECT_NE(NULL, pointer); EXPECT_LT(len, v.size()); */ #define EXPECT_EQ(v1, v2) do { \ if (v1 == v2) { \ UnitTest::GetInstance()->CurrentTestCase->nPassed++; \ std::cout << green << " EXPECT_EQ succeeded!\n"; \ } \ else { \ UnitTest::GetInstance()->CurrentTestCase->nTestResult = 0; \ UnitTest::GetInstance()->CurrentTestCase->nFailed++; \ std::cout << red << " EXPECT_EQ failed!\n"; \ std::cout << red << " Expect:" << v1 << "\n"; \ std::cout << red << " Actual:" << v2 << "\n"; \ }} while(0) #define EXPECT_NE(v1, v2) do { \ if (v1 != v2) { \ UnitTest::GetInstance()->CurrentTestCase->nPassed++; \ std::cout << green << " EXPECT_NE succeeded!\n"; \ } \ else { \ UnitTest::GetInstance()->CurrentTestCase->nTestResult = 0; \ UnitTest::GetInstance()->CurrentTestCase->nFailed++; \ std::cout << red << " EXPECT_NE failed!\n"; \ std::cout << red << " Expect:" << v1 << "\n"; \ std::cout << red << " Actual:" << v2 << "\n"; \ }} while(0) #define EXPECT_LT(v1, v2) do { \ if (v1 < v2) { \ UnitTest::GetInstance()->CurrentTestCase->nPassed++; \ std::cout << green << " EXPECT_LT succeeded!\n"; \ } \ else { \ UnitTest::GetInstance()->CurrentTestCase->nTestResult = 0; \ UnitTest::GetInstance()->CurrentTestCase->nFailed++; \ std::cout << red << " EXPECT_LT failed!\n"; \ std::cout << red << " Expect:" << v1 << "\n"; \ std::cout << red << " Actual:" << v2 << "\n"; \ }} while(0) #define EXPECT_LE(v1, v2) do { \ if (v1 <= v2) { \ UnitTest::GetInstance()->CurrentTestCase->nPassed++; \ std::cout << green << " EXPECT_LE succeeded!\n"; \ } \ else { \ UnitTest::GetInstance()->CurrentTestCase->nTestResult = 0; \ UnitTest::GetInstance()->CurrentTestCase->nFailed++; \ std::cout << red << " EXPECT_LE failed!\n"; \ std::cout << red << " Expect:" << v1 << "\n"; \ std::cout << red << " Actual:" << v2 << "\n"; \ }} while(0) #define EXPECT_GT(v1, v2) do { \ if (v1 > v2) { \ UnitTest::GetInstance()->CurrentTestCase->nPassed++; \ std::cout << green << " EXPECT_GT succeeded!\n"; \ } \ else { \ UnitTest::GetInstance()->CurrentTestCase->nTestResult = 0; \ UnitTest::GetInstance()->CurrentTestCase->nFailed++; \ std::cout << red << " EXPECT_GT failed!\n"; \ std::cout << red << " Expect:" << v1 << "\n"; \ std::cout << red << " Actual:" << v2 << "\n"; \ }} while(0) #define EXPECT_GE(v1, v2) do { \ if (v1 >= v2) { \ UnitTest::GetInstance()->CurrentTestCase->nPassed++; \ std::cout << green << " EXPECT_GE succeeded!\n"; \ } \ else { \ UnitTest::GetInstance()->CurrentTestCase->nTestResult = 0; \ UnitTest::GetInstance()->CurrentTestCase->nFailed++; \ std::cout << red << " EXPECT_GE failed!\n"; \ std::cout << red << " Expect:" << v1 << "\n"; \ std::cout << red << " Actual:" << v2 << "\n"; \ }} while(0) /* 字符串比较 EXPECT_STREQ(s1, s2) 验证条件: 两个 C 字符串有相同的值 EXPECT_STRNE(s1, s2) 验证条件: 两个 C 字符串有不同的值 Note: 1. 参数应满足 EXPECT_STR*(Expect, Actual)的格式，左边是期望值，右边是实际值 2. 该组断言用于比较两个 C 字符串。如果你想要比较两个 string 对象，相应地使用 EXPECT_EQ、EXPECT_NE 等断言 3. EXPECT_STREQ 和 EXPECT_STRNE 不接受宽字符串（wchar_t*） 4. 一个 NULL 指针和一个空字符串会不是一样的 Example: char* s1 = "", char* s2 = "abc", char* s3 = NULL; EXPECT_STREQ("abc", s2); 通过 EXPECT_STREQ(s1, s3); 失败 EXPECT_STREQ(NULL, s3); 通过 EXPECT_STRNE(" ", s1); 通过 */ #define EXPECT_STREQ(s1, s2) do { \ if (s1 == NULL || s2 == NULL) { \ if (s1 == NULL && s2 == NULL) { \ UnitTest::GetInstance()->CurrentTestCase->nPassed++; \ std::cout << green << " EXPECT_STRED succeeded!\n"; \ } \ else { \ UnitTest::GetInstance()->CurrentTestCase->nTestResult = 0; \ UnitTest::GetInstance()->CurrentTestCase->nFailed++; \ std::cout << red << " EXPECT_STRED failed!\n"; \ if(s1 == NULL) std::cout << " Expect: NULL\n"; \ else std::cout << " Expect:\"" << s1 << "\"\n"; \ if(s2 == NULL) std::cout << " Actual: NULL\n"; \ else std::cout << " Actual:\"" << s2 << "\"\n"; \ } \ } \ else if (strcmp(s1, s2) == 0) { \ UnitTest::GetInstance()->CurrentTestCase->nPassed++; \ std::cout << green << " EXPECT_STRED succeeded!\n"; \ } \ else { \ UnitTest::GetInstance()->CurrentTestCase->nTestResult = 0; \ UnitTest::GetInstance()->CurrentTestCase->nFailed++; \ std::cout << red << " EXPECT_STRED failed!\n"; \ std::cout << red << " Expect:\"" << s1 << "\"\n"; \ std::cout << red << " Actual:\"" << s2 << "\"\n"; \ }} while(0) #define EXPECT_STRNE(s1, s2) do { \ if (s1 == NULL || s2 == NULL) { \ if (s1 != NULL || s2 != NULL) { \ UnitTest::GetInstance()->CurrentTestCase->nPassed++; \ std::cout << green << " EXPECT_STRNE succeeded!\n"; \ } \ else { \ UnitTest::GetInstance()->CurrentTestCase->nTestResult = 0; \ UnitTest::GetInstance()->CurrentTestCase->nFailed++; \ std::cout << red << " EXPECT_STRNE failed!\n"; \ if(s1 == NULL) std::cout << " Expect: NULL\n"; \ else std::cout << " Expect:\"" << s1 << "\"\n"; \ if(s2 == NULL) std::cout << " Actual: NULL\n"; \ else std::cout << " Actual:\"" << s2 << "\"\n"; \ } \ } \ else if (strcmp(s1, s2) != 0) { \ UnitTest::GetInstance()->CurrentTestCase->nPassed++; \ std::cout << green << " EXPECT_STRNE succeeded!\n"; \ } \ else { \ UnitTest::GetInstance()->CurrentTestCase->nTestResult = 0; \ UnitTest::GetInstance()->CurrentTestCase->nFailed++; \ std::cout << red << " EXPECT_STRNE failed!\n"; \ std::cout << red << " Expect:\"" << s1 << "\"\n"; \ std::cout << red << " Actual:\"" << s2 << "\"\n"; \ }} while(0) /* 指针比较 EXPECT_PTR_EQ(p1, p2) 验证条件: *p1 == *p2 EXPECT_PTR_NE(p1, p2) 验证条件: *p1 != *p2 EXPECT_PTR_RANGE_EQ(p1, p2, len) 验证条件: 任意 i (*p1 + i) == (*p2 + i) i∈[0,len) EXPECT_PTR_RANGE_NE(p1, p2, len) 验证条件: 存在 i (*p1 + i) != (*p2 + i) i∈[0,len) Note: 1. 参数应满足 EXPECT_PTR_*(Expect, Actual)、 EXPECT_PTR_RANGE_*(Expect, Actual, len)的格式， 即参数表中期望值在实际值左边 2. EXPECT_PTR_EQ 比较的是指针所指元素的值，如果要比较 指针指向的地址是否相等，请用 EXPECT_EQ 3. EXPECT_PTR_RANGE_* 比较的是从 p1，p2 开始， 长度为 len 的区间，请确保区间长度有效 Example: int a[] = {1,2,3,4,5}; int b[] = {1,2,3,4,6}; int *p1 = a, *p2 = b; EXPECT_PTR_EQ(p1, p2); 通过 p1 = a + 4, p2 = b + 4; EXPECT_PTR_EQ(p1, p2); 失败 EXPECT_PTR_EQ(p1, std::find(a, a + 5, 5)); 通过 EXPECT_PTR_RANGE_EQ(a, b, 5); 失败 EXPECT_PTR_RANGE_EQ(a, b, 4); 通过 */ #define EXPECT_PTR_EQ(p1, p2) do { \ if (*p1 == *p2) { \ UnitTest::GetInstance()->CurrentTestCase->nPassed++; \ std::cout << green << " EXPECT_PTR_EQ succeeded!\n"; \ } \ else { \ UnitTest::GetInstance()->CurrentTestCase->nTestResult = 0; \ UnitTest::GetInstance()->CurrentTestCase->nFailed++; \ std::cout << red << " EXPECT_PTR_EQ failed!\n"; \ std::cout << red << " Expect:" << *p1 << "\n"; \ std::cout << red << " Actual:" << *p2 << "\n"; \ }} while(0) #define EXPECT_PTR_NE(p1, p2) do { \ if (*p1 != *p2) { \ UnitTest::GetInstance()->CurrentTestCase->nPassed++; \ std::cout << green << " EXPECT_PTR_NE succeeded!\n"; \ } \ else { \ UnitTest::GetInstance()->CurrentTestCase->nTestResult = 0; \ UnitTest::GetInstance()->CurrentTestCase->nFailed++; \ std::cout << red << " EXPECT_PTR_NE failed!\n"; \ std::cout << red << " Expect:" << *p1 << "\n"; \ std::cout << red << " Actual:" << *p2 << "\n"; \ }} while(0) #define EXPECT_PTR_RANGE_EQ(p1, p2, len) do { \ if (std::equal(p1, p1 + len, p2)) { \ UnitTest::GetInstance()->CurrentTestCase->nPassed++; \ std::cout << green << " EXPECT_PTR_RANGE_EQ succeeded!\n"; \ } \ else { \ UnitTest::GetInstance()->CurrentTestCase->nTestResult = 0; \ UnitTest::GetInstance()->CurrentTestCase->nFailed++; \ std::cout << red << " EXPECT_PTR_RANGE_EQ failed!\n"; \ }} while(0) #define EXPECT_PTR_RANGE_NE(p1, p2, len) do { \ if (!std::equal(p1, p1 + len, p2)) { \ UnitTest::GetInstance()->CurrentTestCase->nPassed++; \ std::cout << green << " EXPECT_PTR_RANGE_NE succeeded!\n"; \ } \ else { \ UnitTest::GetInstance()->CurrentTestCase->nTestResult = 0; \ UnitTest::GetInstance()->CurrentTestCase->nFailed++; \ std::cout << red << " EXPECT_PTR_RANGE_NE failed!\n"; \ }} while(0) /* 容器比较 EXPECT_CON_EQ(c1, c2) 验证条件: c1 == c2 EXPECT_CON_NE(c1, c2) 验证条件: c1 != c2 Note: 1. 容器可以是 STL 容器，自定义的容器，或者数组，但不可以是指针 2. 容器的数据类型要能够进行比较，类型一致或可以发生隐式转换 3. EXPECT_CON_EQ 测试失败时，会打印首次不相等的两个值 Example: int arr[] = {1,2,3}; std::vector v1{1, 2, 3}; std::vector v2{2, 3, 4}; mystl::vector v3(arr, arr + 3); EXPECT_CON_NE(v1, v2) ok EXPECT_CON_EQ(arr, v1) ok EXPECT_CON_EQ(v1, v3) ok */ #define EXPECT_CON_EQ(c1, c2) do { \ auto first1 = std::begin(c1), last1 = std::end(c1); \ auto first2 = std::begin(c2), last2 = std::end(c2); \ for (; first1 != last1 && first2 != last2; ++first1, ++first2) { \ if (*first1 != *first2) break; \ } \ if (first1 == last1 && first2 == last2) { \ UnitTest::GetInstance()->CurrentTestCase->nPassed++; \ std::cout << green << " EXPECT_CON_EQ succeeded!\n"; \ } \ else { \ UnitTest::GetInstance()->CurrentTestCase->nTestResult = 0; \ UnitTest::GetInstance()->CurrentTestCase->nFailed++; \ std::cout << red << " EXPECT_CON_EQ failed!\n"; \ std::cout << red << " Expect:" << *first1 << "\n"; \ std::cout << red << " Actual:" << *first2 << "\n"; \ }} while(0) #define EXPECT_CON_NE(c1, c2) do { \ auto first1 = std::begin(c1), last1 = std::end(c1); \ auto first2 = std::begin(c2), last2 = std::end(c2); \ for (; first1 != last1 && first2 != last2; ++first1, ++first2) { \ if (*first1 != *first2) break; \ } \ if (first1 != last1 || first2 != last2) { \ UnitTest::GetInstance()->CurrentTestCase->nPassed++; \ std::cout << green << " EXPECT_CON_NE succeeded!\n"; \ } \ else { \ UnitTest::GetInstance()->CurrentTestCase->nTestResult = 0; \ UnitTest::GetInstance()->CurrentTestCase->nFailed++; \ std::cout << red << " EXPECT_CON_NE failed!\n"; \ }} while(0) /*****************************************************************************************/ // 常用的宏定义 // 不同情况的测试数量级 #if defined(_DEBUG) || defined(DEBUG) #define LEN1 10000 #define LEN2 100000 #define LEN3 1000000 #else #define LEN1 100000 #define LEN2 1000000 #define LEN3 10000000 #endif #define SCALE_LLL(N) (N * 20) #define SCALE_LL(N) (N * 10) #define SCALE_L(N) (N * 5) #define SCALE_M(N) (N) #define SCALE_S(N) (N / 5) #define SCALE_SS(N) (N / 10) #define SCALE_SSS(N) (N / 20) #define WIDE 14 // 输出通过提示 #define PASSED std::cout << "[ PASSED ]\n" // 遍历输出容器 #define COUT(container) do { \ std::string con_name = #container; \ std::cout << " " << con_name << " :"; \ for (auto it : container) \ std::cout << " " << it; \ std::cout << "\n"; \ } while(0) #define STR_COUT(str) do { \ std::string str_name = #str; \ std::cout << " " << str_name << " : " << str << "\n"; \ } while(0) // 输出容器调用函数后的结果 #define FUN_AFTER(con, fun) do { \ std::string fun_name = #fun; \ std::cout << " After " << fun_name << " :\n"; \ fun; \ COUT(con); \ } while(0) #define STR_FUN_AFTER(str, fun) do { \ std::string fun_name = #fun; \ std::cout << " After " << fun_name << " :\n"; \ fun; \ STR_COUT(str); \ } while(0) // 输出容器调用函数的值 #define FUN_VALUE(fun) do { \ std::string fun_name = #fun; \ std::cout << " " << fun_name << " : " << fun << "\n"; \ } while(0) // 输出测试数量级 void test_len(size_t len1, size_t len2, size_t len3, size_t wide) { std::string str1, str2, str3; std::stringstream ss; ss << len1 << " " << len2 << " " << len3; ss >> str1 >> str2 >> str3; str1 += " |"; std::cout << std::setw(wide) << str1; str2 += " |"; std::cout << std::setw(wide) << str2; str3 += " |"; std::cout << std::setw(wide) << str3 << "\n"; } #define TEST_LEN(len1, len2, len3, wide) \ test_len(len1, len2, len3, wide) // 常用测试性能的宏 #define FUN_TEST_FORMAT1(mode, fun, arg, count) do { \ srand((int)time(0)); \ clock_t start, end; \ mode c; \ char buf[10]; \ start = clock(); \ for (size_t i = 0; i < count; ++i) \ c.fun(arg); \ end = clock(); \ int n = static_cast(static_cast(end - start) \ / CLOCKS_PER_SEC * 1000); \ std::snprintf(buf, sizeof(buf), "%d", n); \ std::string t = buf; \ t += "ms |"; \ std::cout << std::setw(WIDE) << t; \ } while(0) #define FUN_TEST_FORMAT2(mode, fun, arg1, arg2, count) do { \ srand((int)time(0)); \ clock_t start, end; \ mode c; \ char buf[10]; \ start = clock(); \ for (size_t i = 0; i < count; ++i) \ c.fun(c.arg1(), arg2); \ end = clock(); \ int n = static_cast(static_cast(end - start) \ / CLOCKS_PER_SEC * 1000); \ std::snprintf(buf, sizeof(buf), "%d", n); \ std::string t = buf; \ t += "ms |"; \ std::cout << std::setw(WIDE) << t; \ } while(0) #define LIST_SORT_DO_TEST(mode, count) do { \ srand((int)time(0)); \ clock_t start, end; \ mode::list l; \ char buf[10]; \ for (size_t i = 0; i < count; ++i) \ l.insert(l.end(), rand()); \ start = clock(); \ l.sort(); \ end = clock(); \ int n = static_cast(static_cast(end - start) \ / CLOCKS_PER_SEC * 1000); \ std::snprintf(buf, sizeof(buf), "%d", n); \ std::string t = buf; \ t += "ms |"; \ std::cout << std::setw(WIDE) << t; \ } while(0) #define MAP_EMPLACE_DO_TEST(mode, con, count) do { \ srand((int)time(0)); \ clock_t start, end; \ mode::con c; \ char buf[10]; \ start = clock(); \ for (size_t i = 0; i < count; ++i) \ c.emplace(mode::make_pair(rand(), rand())); \ end = clock(); \ int n = static_cast(static_cast(end - start) \ / CLOCKS_PER_SEC * 1000); \ std::snprintf(buf, sizeof(buf), "%d", n); \ std::string t = buf; \ t += "ms |"; \ std::cout << std::setw(WIDE) << t; \ } while(0) // 重构重复代码 #define CON_TEST_P1(con, fun, arg, len1, len2, len3) \ TEST_LEN(len1, len2, len3, WIDE); \ std::cout << "| std |"; \ FUN_TEST_FORMAT1(std::con, fun, arg, len1); \ FUN_TEST_FORMAT1(std::con, fun, arg, len2); \ FUN_TEST_FORMAT1(std::con, fun, arg, len3); \ std::cout << "\n| mystl |"; \ FUN_TEST_FORMAT1(mystl::con, fun, arg, len1); \ FUN_TEST_FORMAT1(mystl::con, fun, arg, len2); \ FUN_TEST_FORMAT1(mystl::con, fun, arg, len3); #define CON_TEST_P2(con, fun, arg1, arg2, len1, len2, len3) \ TEST_LEN(len1, len2, len3, WIDE); \ std::cout << "| std |"; \ FUN_TEST_FORMAT2(std::con, fun, arg1, arg2, len1); \ FUN_TEST_FORMAT2(std::con, fun, arg1, arg2, len2); \ FUN_TEST_FORMAT2(std::con, fun, arg1, arg2, len3); \ std::cout << "\n| mystl |"; \ FUN_TEST_FORMAT2(mystl::con, fun, arg1, arg2, len1); \ FUN_TEST_FORMAT2(mystl::con, fun, arg1, arg2, len2); \ FUN_TEST_FORMAT2(mystl::con, fun, arg1, arg2, len3); #define MAP_EMPLACE_TEST(con, len1, len2, len3) \ TEST_LEN(len1, len2, len3, WIDE); \ std::cout << "| std |"; \ MAP_EMPLACE_DO_TEST(std, con, len1); \ MAP_EMPLACE_DO_TEST(std, con, len2); \ MAP_EMPLACE_DO_TEST(std, con, len3); \ std::cout << "\n| mystl |"; \ MAP_EMPLACE_DO_TEST(mystl, con, len1); \ MAP_EMPLACE_DO_TEST(mystl, con, len2); \ MAP_EMPLACE_DO_TEST(mystl, con, len3); #define LIST_SORT_TEST(len1, len2, len3) \ TEST_LEN(len1, len2, len3, WIDE); \ std::cout << "| std |"; \ LIST_SORT_DO_TEST(std, len1); \ LIST_SORT_DO_TEST(std, len2); \ LIST_SORT_DO_TEST(std, len3); \ std::cout << "\n| mystl |"; \ LIST_SORT_DO_TEST(mystl, len1); \ LIST_SORT_DO_TEST(mystl, len2); \ LIST_SORT_DO_TEST(mystl, len3); // 简单测试的宏定义 #define TEST(testcase_name) \ MYTINYSTL_TEST_(testcase_name) // 运行所有测试案例 #define RUN_ALL_TESTS() \ mystl::test::UnitTest::GetInstance()->Run() // 是否开启性能测试 #ifndef PERFORMANCE_TEST_ON #define PERFORMANCE_TEST_ON 1 #endif // !PERFORMANCE_TEST_ON // 是否开启大数据量测试 #ifndef LARGER_TEST_DATA_ON #define LARGER_TEST_DATA_ON 0 #endif // !LARGER_TEST_DATA_ON } // namespace test } // namespace mystl #endif // !MYTINYSTL_TEST_H_ ================================================ FILE: Test/unordered_map_test.h ================================================ #ifndef MYTINYSTL_UNORDERED_MAP_TEST_H_ #define MYTINYSTL_UNORDERED_MAP_TEST_H_ // unordered_map test : 测试 unordered_map, unordered_multimap 的接口与它们 insert 的性能 #include #include "../MyTinySTL/unordered_map.h" #include "map_test.h" #include "test.h" namespace mystl { namespace test { namespace unordered_map_test { void unordered_map_test() { std::cout << "[===============================================================]" << std::endl; std::cout << "[-------------- Run container test : unordered_map -------------]" << std::endl; std::cout << "[-------------------------- API test ---------------------------]" << std::endl; mystl::vector v; for (int i = 0; i < 5; ++i) v.push_back(PAIR(5 - i, 5 - i)); mystl::unordered_map um1; mystl::unordered_map um2(520); mystl::unordered_map um3(520, mystl::hash()); mystl::unordered_map um4(520, mystl::hash(), mystl::equal_to()); mystl::unordered_map um5(v.begin(), v.end()); mystl::unordered_map um6(v.begin(), v.end(), 100); mystl::unordered_map um7(v.begin(), v.end(), 100, mystl::hash()); mystl::unordered_map um8(v.begin(), v.end(), 100, mystl::hash(), mystl::equal_to()); mystl::unordered_map um9(um5); mystl::unordered_map um10(std::move(um5)); mystl::unordered_map um11; um11 = um6; mystl::unordered_map um12; um12 = std::move(um6); mystl::unordered_map um13{ PAIR(1,1),PAIR(2,3),PAIR(3,3) }; mystl::unordered_map um14; um14 = { PAIR(1,1),PAIR(2,3),PAIR(3,3) }; MAP_FUN_AFTER(um1, um1.emplace(1, 1)); MAP_FUN_AFTER(um1, um1.emplace_hint(um1.begin(), 1, 2)); MAP_FUN_AFTER(um1, um1.insert(PAIR(2, 2))); MAP_FUN_AFTER(um1, um1.insert(um1.end(), PAIR(3, 3))); MAP_FUN_AFTER(um1, um1.insert(v.begin(), v.end())); MAP_FUN_AFTER(um1, um1.erase(um1.begin())); MAP_FUN_AFTER(um1, um1.erase(um1.begin(), um1.find(3))); MAP_FUN_AFTER(um1, um1.erase(1)); std::cout << std::boolalpha; FUN_VALUE(um1.empty()); std::cout << std::noboolalpha; FUN_VALUE(um1.size()); FUN_VALUE(um1.bucket_count()); FUN_VALUE(um1.max_bucket_count()); FUN_VALUE(um1.bucket(1)); FUN_VALUE(um1.bucket_size(um1.bucket(5))); MAP_FUN_AFTER(um1, um1.clear()); MAP_FUN_AFTER(um1, um1.swap(um7)); MAP_VALUE(*um1.begin()); FUN_VALUE(um1.at(1)); FUN_VALUE(um1[1]); std::cout << std::boolalpha; FUN_VALUE(um1.empty()); std::cout << std::noboolalpha; FUN_VALUE(um1.size()); FUN_VALUE(um1.max_size()); FUN_VALUE(um1.bucket_count()); FUN_VALUE(um1.max_bucket_count()); FUN_VALUE(um1.bucket(1)); FUN_VALUE(um1.bucket_size(um1.bucket(1))); MAP_FUN_AFTER(um1, um1.reserve(1000)); FUN_VALUE(um1.size()); FUN_VALUE(um1.bucket_count()); FUN_VALUE(um1.bucket_size(1)); FUN_VALUE(um1.bucket_size(2)); FUN_VALUE(um1.bucket_size(3)); MAP_FUN_AFTER(um1, um1.rehash(150)); FUN_VALUE(um1.bucket_count()); FUN_VALUE(um1.count(1)); MAP_VALUE(*um1.find(3)); auto first = *um1.equal_range(3).first; auto second = *um1.equal_range(3).second; std::cout << " um1.equal_range(3) : from <" << first.first << ", " << first.second << "> to <" << second.first << ", " << second.second << ">" << std::endl; FUN_VALUE(um1.load_factor()); FUN_VALUE(um1.max_load_factor()); MAP_FUN_AFTER(um1, um1.max_load_factor(1.5f)); FUN_VALUE(um1.max_load_factor()); PASSED; #if PERFORMANCE_TEST_ON std::cout << "[--------------------- Performance Testing ---------------------]" << std::endl; std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl; std::cout << "| emplace |"; #if LARGER_TEST_DATA_ON MAP_EMPLACE_TEST(unordered_map, SCALE_M(LEN1), SCALE_M(LEN2), SCALE_M(LEN3)); #else MAP_EMPLACE_TEST(unordered_map, SCALE_S(LEN1), SCALE_S(LEN2), SCALE_S(LEN3)); #endif std::cout << std::endl; std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl; PASSED; #endif std::cout << "[-------------- End container test : unordered_map -------------]" << std::endl; } void unordered_multimap_test() { std::cout << "[===============================================================]" << std::endl; std::cout << "[----------- Run container test : unordered_multimap -----------]" << std::endl; std::cout << "[-------------------------- API test ---------------------------]" << std::endl; mystl::vector v; for (int i = 0; i < 5; ++i) v.push_back(PAIR(5 - i, 5 - i)); mystl::unordered_multimap um1; mystl::unordered_multimap um2(520); mystl::unordered_multimap um3(520, mystl::hash()); mystl::unordered_multimap um4(520, mystl::hash(), mystl::equal_to()); mystl::unordered_multimap um5(v.begin(), v.end()); mystl::unordered_multimap um6(v.begin(), v.end(), 100); mystl::unordered_multimap um7(v.begin(), v.end(), 100, mystl::hash()); mystl::unordered_multimap um8(v.begin(), v.end(), 100, mystl::hash(), mystl::equal_to()); mystl::unordered_multimap um9(um5); mystl::unordered_multimap um10(std::move(um5)); mystl::unordered_multimap um11; um11 = um6; mystl::unordered_multimap um12; um12 = std::move(um6); mystl::unordered_multimap um13{ PAIR(1,1),PAIR(2,3),PAIR(3,3) }; mystl::unordered_multimap um14; um14 = { PAIR(1,1),PAIR(2,3),PAIR(3,3) }; MAP_FUN_AFTER(um1, um1.emplace(1, 1)); MAP_FUN_AFTER(um1, um1.emplace_hint(um1.begin(), 1, 2)); MAP_FUN_AFTER(um1, um1.insert(PAIR(2, 2))); MAP_FUN_AFTER(um1, um1.insert(um1.end(), PAIR(3, 3))); MAP_FUN_AFTER(um1, um1.insert(v.begin(), v.end())); MAP_FUN_AFTER(um1, um1.erase(um1.begin())); MAP_FUN_AFTER(um1, um1.erase(um1.begin(), um1.find(3))); MAP_FUN_AFTER(um1, um1.erase(1)); std::cout << std::boolalpha; FUN_VALUE(um1.empty()); std::cout << std::noboolalpha; FUN_VALUE(um1.size()); FUN_VALUE(um1.bucket_count()); FUN_VALUE(um1.max_bucket_count()); FUN_VALUE(um1.bucket(1)); FUN_VALUE(um1.bucket_size(um1.bucket(5))); MAP_FUN_AFTER(um1, um1.clear()); MAP_FUN_AFTER(um1, um1.swap(um7)); MAP_VALUE(*um1.begin()); std::cout << std::boolalpha; FUN_VALUE(um1.empty()); std::cout << std::noboolalpha; FUN_VALUE(um1.size()); FUN_VALUE(um1.max_size()); FUN_VALUE(um1.bucket_count()); FUN_VALUE(um1.max_bucket_count()); FUN_VALUE(um1.bucket(1)); FUN_VALUE(um1.bucket_size(um1.bucket(1))); MAP_FUN_AFTER(um1, um1.reserve(1000)); FUN_VALUE(um1.size()); FUN_VALUE(um1.bucket_count()); FUN_VALUE(um1.bucket_size(1)); FUN_VALUE(um1.bucket_size(2)); FUN_VALUE(um1.bucket_size(3)); MAP_FUN_AFTER(um1, um1.rehash(150)); FUN_VALUE(um1.bucket_count()); FUN_VALUE(um1.count(1)); MAP_VALUE(*um1.find(3)); auto first = *um1.equal_range(3).first; auto second = *um1.equal_range(3).second; std::cout << " um1.equal_range(3) : from <" << first.first << ", " << first.second << "> to <" << second.first << ", " << second.second << ">" << std::endl; FUN_VALUE(um1.load_factor()); FUN_VALUE(um1.max_load_factor()); MAP_FUN_AFTER(um1, um1.max_load_factor(1.5f)); FUN_VALUE(um1.max_load_factor()); PASSED; #if PERFORMANCE_TEST_ON std::cout << "[--------------------- Performance Testing ---------------------]" << std::endl; std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl; std::cout << "| emplace |"; #if LARGER_TEST_DATA_ON MAP_EMPLACE_TEST(unordered_multimap, SCALE_M(LEN1), SCALE_M(LEN2), SCALE_M(LEN3)); #else MAP_EMPLACE_TEST(unordered_multimap, SCALE_S(LEN1), SCALE_S(LEN2), SCALE_S(LEN3)); #endif std::cout << std::endl; std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl; PASSED; #endif std::cout << "[----------- End container test : unordered_multimap -----------]" << std::endl; } } // namespace unordered_map_test } // namespace test } // namespace mystl #endif // !MYTINYSTL_UNORDERED_MAP_TEST_H_ ================================================ FILE: Test/unordered_set_test.h ================================================ #ifndef MYTINYSTL_UNORDERED_SET_TEST_H_ #define MYTINYSTL_UNORDERED_SET_TEST_H_ // unordered_set test : 测试 unordered_set, unordered_multiset 的接口与它们 insert 的性能 #include #include "../MyTinySTL/unordered_set.h" #include "set_test.h" #include "test.h" namespace mystl { namespace test { namespace unordered_set_test { void unordered_set_test() { std::cout << "[===============================================================]" << std::endl; std::cout << "[-------------- Run container test : unordered_set -------------]" << std::endl; std::cout << "[-------------------------- API test ---------------------------]" << std::endl; int a[] = { 5,4,3,2,1 }; mystl::unordered_set us1; mystl::unordered_set us2(520); mystl::unordered_set us3(520, mystl::hash()); mystl::unordered_set us4(520, mystl::hash(), mystl::equal_to()); mystl::unordered_set us5(a, a + 5); mystl::unordered_set us6(a, a + 5, 100); mystl::unordered_set us7(a, a + 5, 100, mystl::hash()); mystl::unordered_set us8(a, a + 5, 100, mystl::hash(), mystl::equal_to()); mystl::unordered_set us9(us5); mystl::unordered_set us10(std::move(us5)); mystl::unordered_set us11; us11 = us6; mystl::unordered_set us12; us12 = std::move(us6); mystl::unordered_set us13{ 1,2,3,4,5 }; mystl::unordered_set us14; us13 = { 1,2,3,4,5 }; FUN_AFTER(us1, us1.emplace(1)); FUN_AFTER(us1, us1.emplace_hint(us1.end(), 2)); FUN_AFTER(us1, us1.insert(5)); FUN_AFTER(us1, us1.insert(us1.begin(), 5)); FUN_AFTER(us1, us1.insert(a, a + 5)); FUN_AFTER(us1, us1.erase(us1.begin())); FUN_AFTER(us1, us1.erase(us1.begin(), us1.find(3))); FUN_AFTER(us1, us1.erase(1)); std::cout << std::boolalpha; FUN_VALUE(us1.empty()); std::cout << std::noboolalpha; FUN_VALUE(us1.size()); FUN_VALUE(us1.bucket_count()); FUN_VALUE(us1.max_bucket_count()); FUN_VALUE(us1.bucket(1)); FUN_VALUE(us1.bucket_size(us1.bucket(5))); FUN_AFTER(us1, us1.clear()); FUN_AFTER(us1, us1.swap(us7)); FUN_VALUE(*us1.begin()); std::cout << std::boolalpha; FUN_VALUE(us1.empty()); std::cout << std::noboolalpha; FUN_VALUE(us1.size()); FUN_VALUE(us1.max_size()); FUN_VALUE(us1.bucket_count()); FUN_AFTER(us1, us1.reserve(1000)); FUN_VALUE(*us1.begin(us1.bucket(1))); FUN_VALUE(us1.size()); FUN_VALUE(us1.bucket_count()); FUN_VALUE(us1.bucket_size(1)); FUN_VALUE(us1.bucket_size(2)); FUN_VALUE(us1.bucket_size(3)); FUN_AFTER(us1, us1.rehash(150)); FUN_VALUE(us1.bucket_count()); FUN_VALUE(us1.count(1)); FUN_VALUE(*us1.find(3)); auto first = *us1.equal_range(3).first; auto second = *us1.equal_range(3).second; std::cout << " us1.equal_range(3) : from " << first << " to " << second << std::endl; FUN_VALUE(us1.load_factor()); FUN_VALUE(us1.max_load_factor()); FUN_AFTER(us1, us1.max_load_factor(1.5f)); FUN_VALUE(us1.max_load_factor()); PASSED; #if PERFORMANCE_TEST_ON std::cout << "[--------------------- Performance Testing ---------------------]" << std::endl; std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl; std::cout << "| emplace |"; #if LARGER_TEST_DATA_ON CON_TEST_P1(unordered_set, emplace, rand(), SCALE_L(LEN1), SCALE_L(LEN2), SCALE_L(LEN3)); #else CON_TEST_P1(unordered_set, emplace, rand(), SCALE_M(LEN1), SCALE_M(LEN2), SCALE_M(LEN3)); #endif std::cout << std::endl; std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl; PASSED; #endif std::cout << "[-------------- End container test : unordered_set -------------]" << std::endl; } void unordered_multiset_test() { std::cout << "[===============================================================]" << std::endl; std::cout << "[------------ Run container test : unordered_multiset ----------]" << std::endl; std::cout << "[-------------------------- API test ---------------------------]" << std::endl; int a[] = { 5,4,3,2,1 }; mystl::unordered_multiset us1; mystl::unordered_multiset us2(520); mystl::unordered_multiset us3(520, mystl::hash()); mystl::unordered_multiset us4(520, mystl::hash(), mystl::equal_to()); mystl::unordered_multiset us5(a, a + 5); mystl::unordered_multiset us6(a, a + 5, 100); mystl::unordered_multiset us7(a, a + 5, 100, mystl::hash()); mystl::unordered_multiset us8(a, a + 5, 100, mystl::hash(), mystl::equal_to()); mystl::unordered_multiset us9(us5); mystl::unordered_multiset us10(std::move(us5)); mystl::unordered_multiset us11; us11 = us6; mystl::unordered_multiset us12; us12 = std::move(us6); mystl::unordered_multiset us13{ 1,2,3,4,5 }; mystl::unordered_multiset us14; us14 = { 1,2,3,4,5 }; FUN_AFTER(us1, us1.emplace(1)); FUN_AFTER(us1, us1.emplace_hint(us1.end(), 2)); FUN_AFTER(us1, us1.insert(5)); FUN_AFTER(us1, us1.insert(us1.begin(), 5)); FUN_AFTER(us1, us1.insert(a, a + 5)); FUN_AFTER(us1, us1.erase(us1.begin())); FUN_AFTER(us1, us1.erase(us1.begin(), us1.find(3))); FUN_AFTER(us1, us1.erase(1)); std::cout << std::boolalpha; FUN_VALUE(us1.empty()); std::cout << std::noboolalpha; FUN_VALUE(us1.size()); FUN_VALUE(us1.bucket_count()); FUN_VALUE(us1.max_bucket_count()); FUN_VALUE(us1.bucket(1)); FUN_VALUE(us1.bucket_size(us1.bucket(5))); FUN_AFTER(us1, us1.clear()); FUN_AFTER(us1, us1.swap(us7)); FUN_VALUE(*us1.begin()); std::cout << std::boolalpha; FUN_VALUE(us1.empty()); std::cout << std::noboolalpha; FUN_VALUE(us1.size()); FUN_VALUE(us1.max_size()); FUN_VALUE(us1.bucket_count()); FUN_AFTER(us1, us1.reserve(1000)); FUN_VALUE(*us1.begin(us1.bucket(1))); FUN_VALUE(us1.size()); FUN_VALUE(us1.bucket_count()); FUN_VALUE(us1.bucket_size(1)); FUN_VALUE(us1.bucket_size(2)); FUN_VALUE(us1.bucket_size(3)); FUN_AFTER(us1, us1.rehash(150)); FUN_VALUE(us1.bucket_count()); FUN_VALUE(us1.count(1)); FUN_VALUE(*us1.find(3)); auto first = *us1.equal_range(3).first; auto second = *us1.equal_range(3).second; std::cout << " us1.equal_range(3) : from " << first << " to " << second << std::endl; FUN_VALUE(us1.load_factor()); FUN_VALUE(us1.max_load_factor()); FUN_AFTER(us1, us1.max_load_factor(1.5f)); FUN_VALUE(us1.max_load_factor()); PASSED; #if PERFORMANCE_TEST_ON std::cout << "[--------------------- Performance Testing ---------------------]" << std::endl; std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl; std::cout << "| emplace |"; #if LARGER_TEST_DATA_ON CON_TEST_P1(unordered_multiset, emplace, rand(), SCALE_M(LEN1), SCALE_M(LEN2), SCALE_M(LEN3)); #else CON_TEST_P1(unordered_multiset, emplace, rand(), SCALE_S(LEN1), SCALE_S(LEN2), SCALE_S(LEN3)); #endif std::cout << std::endl; std::cout << "|---------------------|-------------|-------------|-------------|" << std::endl; PASSED; #endif std::cout << "[------------ End container test : unordered_multiset ----------]" << std::endl; } } // namespace unordered_set_test } // namespace test } // namespace mystl #endif // !MYTINYSTL_UNORDERED_SET_TEST_H_ ================================================ FILE: Test/vector_test.h ================================================ #ifndef MYTINYSTL_VECTOR_TEST_H_ #define MYTINYSTL_VECTOR_TEST_H_ // vector test : 测试 vector 的接口与 push_back 的性能 #include #include "../MyTinySTL/vector.h" #include "test.h" namespace mystl { namespace test { namespace vector_test { void vector_test() { std::cout << "[===============================================================]\n"; std::cout << "[----------------- Run container test : vector -----------------]\n"; std::cout << "[-------------------------- API test ---------------------------]\n"; int a[] = { 1,2,3,4,5 }; mystl::vector v1; mystl::vector v2(10); mystl::vector v3(10, 1); mystl::vector v4(a, a + 5); mystl::vector v5(v2); mystl::vector v6(std::move(v2)); mystl::vector v7{ 1,2,3,4,5,6,7,8,9 }; mystl::vector v8, v9, v10; v8 = v3; v9 = std::move(v3); v10 = { 1,2,3,4,5,6,7,8,9 }; FUN_AFTER(v1, v1.assign(8, 8)); FUN_AFTER(v1, v1.assign(a, a + 5)); FUN_AFTER(v1, v1.emplace(v1.begin(), 0)); FUN_AFTER(v1, v1.emplace_back(6)); FUN_AFTER(v1, v1.push_back(6)); FUN_AFTER(v1, v1.insert(v1.end(), 7)); FUN_AFTER(v1, v1.insert(v1.begin() + 3, 2, 3)); FUN_AFTER(v1, v1.insert(v1.begin(), a, a + 5)); FUN_AFTER(v1, v1.pop_back()); FUN_AFTER(v1, v1.erase(v1.begin())); FUN_AFTER(v1, v1.erase(v1.begin(), v1.begin() + 2)); FUN_AFTER(v1, v1.reverse()); FUN_AFTER(v1, v1.swap(v4)); FUN_VALUE(*v1.begin()); FUN_VALUE(*(v1.end() - 1)); FUN_VALUE(*v1.rbegin()); FUN_VALUE(*(v1.rend() - 1)); FUN_VALUE(v1.front()); FUN_VALUE(v1.back()); FUN_VALUE(v1[0]); FUN_VALUE(v1.at(1)); int* p = v1.data(); *p = 10; *++p = 20; p[1] = 30; std::cout << " After change v1.data() :" << "\n"; COUT(v1); std::cout << std::boolalpha; FUN_VALUE(v1.empty()); std::cout << std::noboolalpha; FUN_VALUE(v1.size()); FUN_VALUE(v1.max_size()); FUN_VALUE(v1.capacity()); FUN_AFTER(v1, v1.resize(10)); FUN_VALUE(v1.size()); FUN_VALUE(v1.capacity()); FUN_AFTER(v1, v1.shrink_to_fit()); FUN_VALUE(v1.size()); FUN_VALUE(v1.capacity()); FUN_AFTER(v1, v1.resize(6, 6)); FUN_VALUE(v1.size()); FUN_VALUE(v1.capacity()); FUN_AFTER(v1, v1.shrink_to_fit()); FUN_VALUE(v1.size()); FUN_VALUE(v1.capacity()); FUN_AFTER(v1, v1.clear()); FUN_VALUE(v1.size()); FUN_VALUE(v1.capacity()); FUN_AFTER(v1, v1.reserve(5)); FUN_VALUE(v1.size()); FUN_VALUE(v1.capacity()); FUN_AFTER(v1, v1.reserve(20)); FUN_VALUE(v1.size()); FUN_VALUE(v1.capacity()); FUN_AFTER(v1, v1.shrink_to_fit()); FUN_VALUE(v1.size()); FUN_VALUE(v1.capacity()); PASSED; #if PERFORMANCE_TEST_ON std::cout << "[--------------------- Performance Testing ---------------------]\n"; std::cout << "|---------------------|-------------|-------------|-------------|\n"; std::cout << "| push_back |"; #if LARGER_TEST_DATA_ON CON_TEST_P1(vector, push_back, rand(), SCALE_LL(LEN1), SCALE_LL(LEN2), SCALE_LL(LEN3)); #else CON_TEST_P1(vector, push_back, rand(), SCALE_L(LEN1), SCALE_L(LEN2), SCALE_L(LEN3)); #endif std::cout << "\n"; std::cout << "|---------------------|-------------|-------------|-------------|\n"; PASSED; #endif std::cout << "[----------------- End container test : vector -----------------]\n"; } } // namespace vector_test } // namespace test } // namespace mystl #endif // !MYTINYSTL_VECTOR_TEST_H_ ================================================ FILE: appveyor.yml ================================================ version: 2.0.1{build} branches: only: - master image: - Visual Studio 2015 - Visual Studio 2017 configuration: - Release build: parallel: true project: MSVC\MyTinySTL_VS2015.sln test_script: - cmd: cd .\MSVC\x64\Release\ - cmd: MyTinySTL.exe