Compare commits

...

No commits in common. 'main' and '6347cb63fd43af4f35a9cc70c24aaa4bb1a400c9' have entirely different histories.

Binary file not shown.

Binary file not shown.

@ -1,3 +0,0 @@
{
"CurrentProjectSetting": "x64-Debug"
}

@ -1,11 +0,0 @@
{
"ExpandedNodes": [
"",
"\\doc",
"\\src",
"\\src\\MyTinySTL-master",
"\\src\\MyTinySTL-master\\MyTinySTL"
],
"SelectedNode": "\\src\\MyTinySTL-master\\MyTinySTL\\unordered_map.h",
"PreviewInSolutionExplorer": false
}

Binary file not shown.

@ -0,0 +1 @@
Subproject commit 4ed9c7641c9989f8d79c0b86c89327d5e987f610

@ -1,2 +0,0 @@
# https://bdgit.educoder.net/pfuc5ij8g/ciallo.git

Binary file not shown.

Binary file not shown.

Before

Width:  |  Height:  |  Size: 111 KiB

Binary file not shown.

@ -1,3 +0,0 @@
{
"CurrentProjectSetting": "x64-Debug"
}

@ -1,10 +0,0 @@
{
"ExpandedNodes": [
"",
"\\MyTinySTL-master",
"\\MyTinySTL-master\\MSVC",
"\\MyTinySTL-master\\MyTinySTL"
],
"SelectedNode": "\\MyTinySTL-master\\MSVC",
"PreviewInSolutionExplorer": false
}

Binary file not shown.

Binary file not shown.

Binary file not shown.

@ -1,35 +0,0 @@
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)

@ -1,11 +0,0 @@
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.

@ -1,28 +0,0 @@
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

@ -1,201 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Debug|x64">
<Configuration>Debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|x64">
<Configuration>Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<ProjectGuid>{E88807F6-B07C-4371-BD38-FB1569F894E4}</ProjectGuid>
<Keyword>Win32Proj</Keyword>
<RootNamespace>MyTinySTL</RootNamespace>
<WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
<ProjectName>MyTinySTL</ProjectName>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v140</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v140</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v140</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v140</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Label="Shared">
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<LinkIncremental>true</LinkIncremental>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<LinkIncremental>true</LinkIncremental>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<LinkIncremental>false</LinkIncremental>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<LinkIncremental>false</LinkIncremental>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level3</WarningLevel>
<Optimization>Disabled</Optimization>
<PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<SDLCheck>true</SDLCheck>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<ClCompile>
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<Optimization>Disabled</Optimization>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<SDLCheck>true</SDLCheck>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<PrecompiledHeader>
</PrecompiledHeader>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<SDLCheck>true</SDLCheck>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<ClCompile>
<WarningLevel>Level4</WarningLevel>
<PrecompiledHeader>
</PrecompiledHeader>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<SDLCheck>true</SDLCheck>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemGroup>
<ClInclude Include="..\Test\algorithm_performance_test.h" />
<ClInclude Include="..\Test\algorithm_test.h" />
<ClInclude Include="..\Test\deque_test.h" />
<ClInclude Include="..\Test\Lib\redbud\io\color.h" />
<ClInclude Include="..\Test\Lib\redbud\platform.h" />
<ClInclude Include="..\Test\list_test.h" />
<ClInclude Include="..\Test\map_test.h" />
<ClInclude Include="..\Test\queue_test.h" />
<ClInclude Include="..\Test\set_test.h" />
<ClInclude Include="..\Test\stack_test.h" />
<ClInclude Include="..\Test\string_test.h" />
<ClInclude Include="..\Test\test.h" />
<ClInclude Include="..\Test\unordered_map_test.h" />
<ClInclude Include="..\Test\unordered_set_test.h" />
<ClInclude Include="..\Test\vector_test.h" />
<ClInclude Include="..\MyTinySTL\algo.h" />
<ClInclude Include="..\MyTinySTL\algobase.h" />
<ClInclude Include="..\MyTinySTL\algorithm.h" />
<ClInclude Include="..\MyTinySTL\alloc.h" />
<ClInclude Include="..\MyTinySTL\allocator.h" />
<ClInclude Include="..\MyTinySTL\basic_string.h" />
<ClInclude Include="..\MyTinySTL\construct.h" />
<ClInclude Include="..\MyTinySTL\deque.h" />
<ClInclude Include="..\MyTinySTL\exceptdef.h" />
<ClInclude Include="..\MyTinySTL\functional.h" />
<ClInclude Include="..\MyTinySTL\hashtable.h" />
<ClInclude Include="..\MyTinySTL\unordered_map.h" />
<ClInclude Include="..\MyTinySTL\unordered_set.h" />
<ClInclude Include="..\MyTinySTL\heap_algo.h" />
<ClInclude Include="..\MyTinySTL\iterator.h" />
<ClInclude Include="..\MyTinySTL\list.h" />
<ClInclude Include="..\MyTinySTL\map.h" />
<ClInclude Include="..\MyTinySTL\memory.h" />
<ClInclude Include="..\MyTinySTL\numeric.h" />
<ClInclude Include="..\MyTinySTL\queue.h" />
<ClInclude Include="..\MyTinySTL\rb_tree.h" />
<ClInclude Include="..\MyTinySTL\set.h" />
<ClInclude Include="..\MyTinySTL\set_algo.h" />
<ClInclude Include="..\MyTinySTL\stack.h" />
<ClInclude Include="..\MyTinySTL\astring.h" />
<ClInclude Include="..\MyTinySTL\type_traits.h" />
<ClInclude Include="..\MyTinySTL\uninitialized.h" />
<ClInclude Include="..\MyTinySTL\util.h" />
<ClInclude Include="..\MyTinySTL\vector.h" />
</ItemGroup>
<ItemGroup>
<ClCompile Include="..\Test\test.cpp" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>

@ -1,162 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup>
<Filter Include="资源文件">
<UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
<Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
</Filter>
<Filter Include="include">
<UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
<Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
</Filter>
<Filter Include="source">
<UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
<Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
</Filter>
<Filter Include="test">
<UniqueIdentifier>{ec314ff3-dcde-4cac-a63a-4f6827750d0a}</UniqueIdentifier>
</Filter>
<Filter Include="test\Lib">
<UniqueIdentifier>{c6f24d77-e6f0-439e-954a-c0ca577689d5}</UniqueIdentifier>
</Filter>
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\MyTinySTL\type_traits.h">
<Filter>include</Filter>
</ClInclude>
<ClInclude Include="..\MyTinySTL\construct.h">
<Filter>include</Filter>
</ClInclude>
<ClInclude Include="..\MyTinySTL\alloc.h">
<Filter>include</Filter>
</ClInclude>
<ClInclude Include="..\MyTinySTL\allocator.h">
<Filter>include</Filter>
</ClInclude>
<ClInclude Include="..\MyTinySTL\uninitialized.h">
<Filter>include</Filter>
</ClInclude>
<ClInclude Include="..\MyTinySTL\iterator.h">
<Filter>include</Filter>
</ClInclude>
<ClInclude Include="..\MyTinySTL\numeric.h">
<Filter>include</Filter>
</ClInclude>
<ClInclude Include="..\MyTinySTL\algobase.h">
<Filter>include</Filter>
</ClInclude>
<ClInclude Include="..\MyTinySTL\heap_algo.h">
<Filter>include</Filter>
</ClInclude>
<ClInclude Include="..\MyTinySTL\set_algo.h">
<Filter>include</Filter>
</ClInclude>
<ClInclude Include="..\MyTinySTL\algo.h">
<Filter>include</Filter>
</ClInclude>
<ClInclude Include="..\MyTinySTL\algorithm.h">
<Filter>include</Filter>
</ClInclude>
<ClInclude Include="..\MyTinySTL\vector.h">
<Filter>include</Filter>
</ClInclude>
<ClInclude Include="..\MyTinySTL\memory.h">
<Filter>include</Filter>
</ClInclude>
<ClInclude Include="..\MyTinySTL\list.h">
<Filter>include</Filter>
</ClInclude>
<ClInclude Include="..\MyTinySTL\deque.h">
<Filter>include</Filter>
</ClInclude>
<ClInclude Include="..\MyTinySTL\stack.h">
<Filter>include</Filter>
</ClInclude>
<ClInclude Include="..\MyTinySTL\queue.h">
<Filter>include</Filter>
</ClInclude>
<ClInclude Include="..\MyTinySTL\functional.h">
<Filter>include</Filter>
</ClInclude>
<ClInclude Include="..\MyTinySTL\rb_tree.h">
<Filter>include</Filter>
</ClInclude>
<ClInclude Include="..\MyTinySTL\set.h">
<Filter>include</Filter>
</ClInclude>
<ClInclude Include="..\MyTinySTL\map.h">
<Filter>include</Filter>
</ClInclude>
<ClInclude Include="..\MyTinySTL\hashtable.h">
<Filter>include</Filter>
</ClInclude>
<ClInclude Include="..\MyTinySTL\basic_string.h">
<Filter>include</Filter>
</ClInclude>
<ClInclude Include="..\MyTinySTL\unordered_set.h">
<Filter>include</Filter>
</ClInclude>
<ClInclude Include="..\MyTinySTL\unordered_map.h">
<Filter>include</Filter>
</ClInclude>
<ClInclude Include="..\Test\algorithm_performance_test.h">
<Filter>test</Filter>
</ClInclude>
<ClInclude Include="..\Test\algorithm_test.h">
<Filter>test</Filter>
</ClInclude>
<ClInclude Include="..\Test\deque_test.h">
<Filter>test</Filter>
</ClInclude>
<ClInclude Include="..\Test\list_test.h">
<Filter>test</Filter>
</ClInclude>
<ClInclude Include="..\Test\map_test.h">
<Filter>test</Filter>
</ClInclude>
<ClInclude Include="..\Test\queue_test.h">
<Filter>test</Filter>
</ClInclude>
<ClInclude Include="..\Test\set_test.h">
<Filter>test</Filter>
</ClInclude>
<ClInclude Include="..\Test\stack_test.h">
<Filter>test</Filter>
</ClInclude>
<ClInclude Include="..\Test\string_test.h">
<Filter>test</Filter>
</ClInclude>
<ClInclude Include="..\Test\test.h">
<Filter>test</Filter>
</ClInclude>
<ClInclude Include="..\Test\unordered_map_test.h">
<Filter>test</Filter>
</ClInclude>
<ClInclude Include="..\Test\unordered_set_test.h">
<Filter>test</Filter>
</ClInclude>
<ClInclude Include="..\Test\vector_test.h">
<Filter>test</Filter>
</ClInclude>
<ClInclude Include="..\Test\Lib\redbud\platform.h">
<Filter>test\Lib</Filter>
</ClInclude>
<ClInclude Include="..\Test\Lib\redbud\io\color.h">
<Filter>test\Lib</Filter>
</ClInclude>
<ClInclude Include="..\MyTinySTL\astring.h">
<Filter>include</Filter>
</ClInclude>
<ClInclude Include="..\MyTinySTL\util.h">
<Filter>include</Filter>
</ClInclude>
<ClInclude Include="..\MyTinySTL\exceptdef.h">
<Filter>include</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ClCompile Include="..\Test\test.cpp">
<Filter>test</Filter>
</ClCompile>
</ItemGroup>
</Project>

@ -1,3 +0,0 @@
{
"CurrentProjectSetting": "无配置"
}

@ -1,9 +0,0 @@
{
"ExpandedNodes": [
"",
"\\bin",
"\\out\\build",
"\\out\\build\\x64-Debug"
],
"PreviewInSolutionExplorer": false
}

@ -1,7 +0,0 @@
{
"ExpandedNodes": [
""
],
"SelectedNode": "\\MyTinySTL_VS2015.sln",
"PreviewInSolutionExplorer": false
}

@ -1 +0,0 @@
{"requests":[{"kind":"cache","version":2},{"kind":"cmakeFiles","version":1},{"kind":"codemodel","version":2},{"kind":"toolchains","version":1}]}

@ -1,721 +0,0 @@
{
"inputs" :
[
{
"path" : "CMakeLists.txt"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeDetermineSystem.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeSystem.cmake.in"
},
{
"isGenerated" : true,
"path" : "out/build/x64-Debug/CMakeFiles/3.20.21032501-MSVC_2/CMakeSystem.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeSystemSpecificInitialize.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeDetermineCCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeDetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeDetermineCompilerId.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeCompilerIdDetection.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/ADSP-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/ARMCC-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/ARMClang-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/AppleClang-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Clang-DetermineCompilerInternal.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Borland-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Bruce-C-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Clang-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Clang-DetermineCompilerInternal.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Compaq-C-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Cray-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Embarcadero-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Fujitsu-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/GHS-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/GNU-C-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/HP-C-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/IAR-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Intel-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/IntelLLVM-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/MSVC-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/NVHPC-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/NVIDIA-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/OpenWatcom-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/PGI-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/PathScale-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/SCO-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/SDCC-C-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/SunPro-C-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/TI-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/TinyCC-C-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/VisualAge-C-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/IBMCPP-C-DetermineVersionInternal.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Watcom-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/XL-C-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/IBMCPP-C-DetermineVersionInternal.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/XLClang-C-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/zOS-C-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/IBMCPP-C-DetermineVersionInternal.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeFindBinUtils.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeCCompiler.cmake.in"
},
{
"isGenerated" : true,
"path" : "out/build/x64-Debug/CMakeFiles/3.20.21032501-MSVC_2/CMakeCCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeDetermineCXXCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeDetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Platform/Windows-Determine-CXX.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeDetermineCompilerId.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeCompilerIdDetection.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/ADSP-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/ARMCC-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/ARMClang-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/AppleClang-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Clang-DetermineCompilerInternal.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Borland-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Clang-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Clang-DetermineCompilerInternal.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Comeau-CXX-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Compaq-CXX-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Cray-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Embarcadero-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Fujitsu-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/GHS-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/GNU-CXX-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/HP-CXX-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/IAR-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Intel-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/IntelLLVM-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/MSVC-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/NVHPC-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/NVIDIA-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/OpenWatcom-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/PGI-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/PathScale-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/SCO-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/SunPro-CXX-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/TI-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/VisualAge-CXX-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/IBMCPP-CXX-DetermineVersionInternal.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Watcom-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/XL-CXX-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/IBMCPP-CXX-DetermineVersionInternal.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/XLClang-CXX-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/zOS-CXX-DetermineCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/IBMCPP-CXX-DetermineVersionInternal.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeFindBinUtils.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeCXXCompiler.cmake.in"
},
{
"isGenerated" : true,
"path" : "out/build/x64-Debug/CMakeFiles/3.20.21032501-MSVC_2/CMakeCXXCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeSystemSpecificInformation.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeGenericSystem.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeInitializeConfigs.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Platform/Windows.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Platform/WindowsPaths.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeCInformation.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeLanguageInformation.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/MSVC-C.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/CMakeCommonCompilerMacros.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Platform/Windows-MSVC-C.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Platform/Windows-MSVC.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeDetermineRCCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeRCCompiler.cmake.in"
},
{
"isGenerated" : true,
"path" : "out/build/x64-Debug/CMakeFiles/3.20.21032501-MSVC_2/CMakeRCCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeRCInformation.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeTestRCCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeCommonLanguageInclude.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeTestCCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeTestCompilerCommon.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeDetermineCompilerABI.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeParseImplicitIncludeInfo.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeParseImplicitLinkInfo.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeParseLibraryArchitecture.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeTestCompilerCommon.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeCCompilerABI.c"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeDetermineCompileFeatures.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Internal/FeatureTesting.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeCCompiler.cmake.in"
},
{
"isGenerated" : true,
"path" : "out/build/x64-Debug/CMakeFiles/3.20.21032501-MSVC_2/CMakeCCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeCXXInformation.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeLanguageInformation.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/MSVC-CXX.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/CMakeCommonCompilerMacros.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Platform/Windows-MSVC-CXX.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Platform/Windows-MSVC.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeCommonLanguageInclude.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeTestCXXCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeTestCompilerCommon.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeDetermineCompilerABI.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeParseImplicitIncludeInfo.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeParseImplicitLinkInfo.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeParseLibraryArchitecture.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeTestCompilerCommon.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeCXXCompilerABI.cpp"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeDetermineCompileFeatures.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Internal/FeatureTesting.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeCXXCompiler.cmake.in"
},
{
"isGenerated" : true,
"path" : "out/build/x64-Debug/CMakeFiles/3.20.21032501-MSVC_2/CMakeCXXCompiler.cmake"
},
{
"path" : "Test/CMakeLists.txt"
}
],
"kind" : "cmakeFiles",
"paths" :
{
"build" : "C:/Users/n/Desktop/软件工程/MyTinySTL/src/MyTinySTL-master/MyTinySTL-master/out/build/x64-Debug",
"source" : "C:/Users/n/Desktop/软件工程/MyTinySTL/src/MyTinySTL-master/MyTinySTL-master"
},
"version" :
{
"major" : 1,
"minor" : 0
}
}

@ -1,74 +0,0 @@
{
"configurations" :
[
{
"directories" :
[
{
"build" : ".",
"childIndexes" :
[
1
],
"minimumCMakeVersion" :
{
"string" : "2.8"
},
"projectIndex" : 0,
"source" : "."
},
{
"build" : "Test",
"minimumCMakeVersion" :
{
"string" : "2.8"
},
"parentIndex" : 0,
"projectIndex" : 0,
"source" : "Test",
"targetIndexes" :
[
0
]
}
],
"name" : "release",
"projects" :
[
{
"directoryIndexes" :
[
0,
1
],
"name" : "MyTinySTL",
"targetIndexes" :
[
0
]
}
],
"targets" :
[
{
"directoryIndex" : 1,
"id" : "stltest::@c0a5cca43b8aa79eb50e",
"jsonFile" : "target-stltest-release-72863af921c407507e94.json",
"name" : "stltest",
"projectIndex" : 0
}
]
}
],
"kind" : "codemodel",
"paths" :
{
"build" : "C:/Users/n/Desktop/软件工程/MyTinySTL/src/MyTinySTL-master/MyTinySTL-master/out/build/x64-Debug",
"source" : "C:/Users/n/Desktop/软件工程/MyTinySTL/src/MyTinySTL-master/MyTinySTL-master"
},
"version" :
{
"major" : 2,
"minor" : 2
}
}

@ -1,132 +0,0 @@
{
"cmake" :
{
"generator" :
{
"multiConfig" : false,
"name" : "Ninja"
},
"paths" :
{
"cmake" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/bin/cmake.exe",
"cpack" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/bin/cpack.exe",
"ctest" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/bin/ctest.exe",
"root" : "D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20"
},
"version" :
{
"isDirty" : false,
"major" : 3,
"minor" : 20,
"patch" : 21032501,
"string" : "3.20.21032501-MSVC_2",
"suffix" : ""
}
},
"objects" :
[
{
"jsonFile" : "codemodel-v2-d5444a4b555fee370c32.json",
"kind" : "codemodel",
"version" :
{
"major" : 2,
"minor" : 2
}
},
{
"jsonFile" : "cache-v2-cf1afb9dfb4270c41e61.json",
"kind" : "cache",
"version" :
{
"major" : 2,
"minor" : 0
}
},
{
"jsonFile" : "cmakeFiles-v1-4335941eceb0d7761c6f.json",
"kind" : "cmakeFiles",
"version" :
{
"major" : 1,
"minor" : 0
}
},
{
"jsonFile" : "toolchains-v1-ed4342441613ddf69605.json",
"kind" : "toolchains",
"version" :
{
"major" : 1,
"minor" : 0
}
}
],
"reply" :
{
"client-MicrosoftVS" :
{
"query.json" :
{
"requests" :
[
{
"kind" : "cache",
"version" : 2
},
{
"kind" : "cmakeFiles",
"version" : 1
},
{
"kind" : "codemodel",
"version" : 2
},
{
"kind" : "toolchains",
"version" : 1
}
],
"responses" :
[
{
"jsonFile" : "cache-v2-cf1afb9dfb4270c41e61.json",
"kind" : "cache",
"version" :
{
"major" : 2,
"minor" : 0
}
},
{
"jsonFile" : "cmakeFiles-v1-4335941eceb0d7761c6f.json",
"kind" : "cmakeFiles",
"version" :
{
"major" : 1,
"minor" : 0
}
},
{
"jsonFile" : "codemodel-v2-d5444a4b555fee370c32.json",
"kind" : "codemodel",
"version" :
{
"major" : 2,
"minor" : 2
}
},
{
"jsonFile" : "toolchains-v1-ed4342441613ddf69605.json",
"kind" : "toolchains",
"version" :
{
"major" : 1,
"minor" : 0
}
}
]
}
}
}
}

@ -1,112 +0,0 @@
{
"artifacts" :
[
{
"path" : "C:/Users/n/Desktop/软件工程/MyTinySTL/src/MyTinySTL-master/MyTinySTL-master/bin/stltest.exe"
},
{
"path" : "C:/Users/n/Desktop/软件工程/MyTinySTL/src/MyTinySTL-master/MyTinySTL-master/bin/stltest.pdb"
}
],
"backtrace" : 1,
"backtraceGraph" :
{
"commands" :
[
"add_executable",
"include_directories"
],
"files" :
[
"Test/CMakeLists.txt"
],
"nodes" :
[
{
"file" : 0
},
{
"command" : 0,
"file" : 0,
"line" : 4,
"parent" : 0
},
{
"command" : 1,
"file" : 0,
"line" : 1,
"parent" : 0
}
]
},
"compileGroups" :
[
{
"compileCommandFragments" :
[
{
"fragment" : "/DWIN32 /D_WINDOWS /W3 /GR /EHsc /MD /O2 /Ob2 /DNDEBUG"
}
],
"includes" :
[
{
"backtrace" : 2,
"path" : "C:/Users/n/Desktop/软件工程/MyTinySTL/src/MyTinySTL-master/MyTinySTL-master/MyTinySTL"
}
],
"language" : "CXX",
"sourceIndexes" :
[
0
]
}
],
"id" : "stltest::@c0a5cca43b8aa79eb50e",
"link" :
{
"commandFragments" :
[
{
"fragment" : "/DWIN32 /D_WINDOWS /W3 /GR /EHsc /MD /O2 /Ob2 /DNDEBUG",
"role" : "flags"
},
{
"fragment" : "/machine:x64 /INCREMENTAL:NO /subsystem:console",
"role" : "flags"
},
{
"fragment" : "kernel32.lib user32.lib gdi32.lib winspool.lib shell32.lib ole32.lib oleaut32.lib uuid.lib comdlg32.lib advapi32.lib",
"role" : "libraries"
}
],
"language" : "CXX"
},
"name" : "stltest",
"nameOnDisk" : "stltest.exe",
"paths" :
{
"build" : "Test",
"source" : "Test"
},
"sourceGroups" :
[
{
"name" : "Source Files",
"sourceIndexes" :
[
0
]
}
],
"sources" :
[
{
"backtrace" : 1,
"compileGroupIndex" : 0,
"path" : "Test/test.cpp",
"sourceGroupIndex" : 0
}
],
"type" : "EXECUTABLE"
}

@ -1,73 +0,0 @@
{
"kind" : "toolchains",
"toolchains" :
[
{
"compiler" :
{
"id" : "MSVC",
"implicit" :
{
"includeDirectories" : [],
"linkDirectories" : [],
"linkFrameworkDirectories" : [],
"linkLibraries" : []
},
"path" : "D:/VS2019/VC/Tools/MSVC/14.29.30133/bin/Hostx64/x64/cl.exe",
"version" : "19.29.30154.0"
},
"language" : "C",
"sourceFileExtensions" :
[
"c",
"m"
]
},
{
"compiler" :
{
"id" : "MSVC",
"implicit" :
{
"includeDirectories" : [],
"linkDirectories" : [],
"linkFrameworkDirectories" : [],
"linkLibraries" : []
},
"path" : "D:/VS2019/VC/Tools/MSVC/14.29.30133/bin/Hostx64/x64/cl.exe",
"version" : "19.29.30154.0"
},
"language" : "CXX",
"sourceFileExtensions" :
[
"C",
"M",
"c++",
"cc",
"cpp",
"cxx",
"mm",
"mpp",
"CPP"
]
},
{
"compiler" :
{
"implicit" : {},
"path" : "C:/Program Files (x86)/Windows Kits/10/bin/10.0.19041.0/x64/rc.exe"
},
"language" : "RC",
"sourceFileExtensions" :
[
"rc",
"RC"
]
}
],
"version" :
{
"major" : 1,
"minor" : 0
}
}

@ -1,338 +0,0 @@
# This is the CMakeCache file.
# For build in directory: c:/Users/n/Desktop/软件工程/MyTinySTL/src/MyTinySTL-master/MyTinySTL-master/out/build/x64-Debug
# It was generated by CMake: D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/bin/cmake.exe
# You can edit this file to change values found and used by cmake.
# If you do not want to change any of the values, simply exit the editor.
# If you do want to change a value, simply edit, save, and exit the editor.
# The syntax for the file is as follows:
# KEY:TYPE=VALUE
# KEY is the name of a variable in the cache.
# TYPE is a hint to GUIs for the type of VALUE, DO NOT EDIT TYPE!.
# VALUE is the current value for the KEY.
########################
# EXTERNAL cache entries
########################
//Path to a program.
CMAKE_AR:FILEPATH=D:/VS2019/VC/Tools/MSVC/14.29.30133/bin/Hostx64/x64/lib.exe
//No help, variable specified on the command line.
CMAKE_BUILD_TYPE:STRING=Debug
//CXX compiler
CMAKE_CXX_COMPILER:STRING=D:/VS2019/VC/Tools/MSVC/14.29.30133/bin/Hostx64/x64/cl.exe
//Flags used by the CXX compiler during all build types.
CMAKE_CXX_FLAGS:STRING=/DWIN32 /D_WINDOWS /W3 /GR /EHsc
//Flags used by the CXX compiler during DEBUG builds.
CMAKE_CXX_FLAGS_DEBUG:STRING=/MDd /Zi /Ob0 /Od /RTC1
//Flags used by the CXX compiler during MINSIZEREL builds.
CMAKE_CXX_FLAGS_MINSIZEREL:STRING=/MD /O1 /Ob1 /DNDEBUG
//Flags used by the CXX compiler during RELEASE builds.
CMAKE_CXX_FLAGS_RELEASE:STRING=/MD /O2 /Ob2 /DNDEBUG
//Flags used by the CXX compiler during RELWITHDEBINFO builds.
CMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING=/MD /Zi /O2 /Ob1 /DNDEBUG
//Libraries linked by default with all C++ applications.
CMAKE_CXX_STANDARD_LIBRARIES:STRING=kernel32.lib user32.lib gdi32.lib winspool.lib shell32.lib ole32.lib oleaut32.lib uuid.lib comdlg32.lib advapi32.lib
//C compiler
CMAKE_C_COMPILER:STRING=D:/VS2019/VC/Tools/MSVC/14.29.30133/bin/Hostx64/x64/cl.exe
//Flags used by the C compiler during all build types.
CMAKE_C_FLAGS:STRING=/DWIN32 /D_WINDOWS /W3
//Flags used by the C compiler during DEBUG builds.
CMAKE_C_FLAGS_DEBUG:STRING=/MDd /Zi /Ob0 /Od /RTC1
//Flags used by the C compiler during MINSIZEREL builds.
CMAKE_C_FLAGS_MINSIZEREL:STRING=/MD /O1 /Ob1 /DNDEBUG
//Flags used by the C compiler during RELEASE builds.
CMAKE_C_FLAGS_RELEASE:STRING=/MD /O2 /Ob2 /DNDEBUG
//Flags used by the C compiler during RELWITHDEBINFO builds.
CMAKE_C_FLAGS_RELWITHDEBINFO:STRING=/MD /Zi /O2 /Ob1 /DNDEBUG
//Libraries linked by default with all C applications.
CMAKE_C_STANDARD_LIBRARIES:STRING=kernel32.lib user32.lib gdi32.lib winspool.lib shell32.lib ole32.lib oleaut32.lib uuid.lib comdlg32.lib advapi32.lib
//Flags used by the linker during all build types.
CMAKE_EXE_LINKER_FLAGS:STRING=/machine:x64
//Flags used by the linker during DEBUG builds.
CMAKE_EXE_LINKER_FLAGS_DEBUG:STRING=/debug /INCREMENTAL
//Flags used by the linker during MINSIZEREL builds.
CMAKE_EXE_LINKER_FLAGS_MINSIZEREL:STRING=/INCREMENTAL:NO
//Flags used by the linker during RELEASE builds.
CMAKE_EXE_LINKER_FLAGS_RELEASE:STRING=/INCREMENTAL:NO
//Flags used by the linker during RELWITHDEBINFO builds.
CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO:STRING=/debug /INCREMENTAL
//Enable/Disable output of compile commands during generation.
CMAKE_EXPORT_COMPILE_COMMANDS:BOOL=
//No help, variable specified on the command line.
CMAKE_INSTALL_PREFIX:PATH=C:/Users/n/Desktop/软件工程/MyTinySTL/src/MyTinySTL-master/MyTinySTL-master/out/install/x64-Debug
//Path to a program.
CMAKE_LINKER:FILEPATH=D:/VS2019/VC/Tools/MSVC/14.29.30133/bin/Hostx64/x64/link.exe
//No help, variable specified on the command line.
CMAKE_MAKE_PROGRAM:UNINITIALIZED=D:\VS2019\COMMON7\IDE\COMMONEXTENSIONS\MICROSOFT\CMAKE\Ninja\ninja.exe
//Flags used by the linker during the creation of modules during
// all build types.
CMAKE_MODULE_LINKER_FLAGS:STRING=/machine:x64
//Flags used by the linker during the creation of modules during
// DEBUG builds.
CMAKE_MODULE_LINKER_FLAGS_DEBUG:STRING=/debug /INCREMENTAL
//Flags used by the linker during the creation of modules during
// MINSIZEREL builds.
CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL:STRING=/INCREMENTAL:NO
//Flags used by the linker during the creation of modules during
// RELEASE builds.
CMAKE_MODULE_LINKER_FLAGS_RELEASE:STRING=/INCREMENTAL:NO
//Flags used by the linker during the creation of modules during
// RELWITHDEBINFO builds.
CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO:STRING=/debug /INCREMENTAL
//Path to a program.
CMAKE_MT:FILEPATH=C:/Program Files (x86)/Windows Kits/10/bin/10.0.19041.0/x64/mt.exe
//Value Computed by CMake
CMAKE_PROJECT_DESCRIPTION:STATIC=
//Value Computed by CMake
CMAKE_PROJECT_HOMEPAGE_URL:STATIC=
//Value Computed by CMake
CMAKE_PROJECT_NAME:STATIC=MyTinySTL
//RC compiler
CMAKE_RC_COMPILER:FILEPATH=C:/Program Files (x86)/Windows Kits/10/bin/10.0.19041.0/x64/rc.exe
//Flags for Windows Resource Compiler during all build types.
CMAKE_RC_FLAGS:STRING=-DWIN32
//Flags for Windows Resource Compiler during DEBUG builds.
CMAKE_RC_FLAGS_DEBUG:STRING=-D_DEBUG
//Flags for Windows Resource Compiler during MINSIZEREL builds.
CMAKE_RC_FLAGS_MINSIZEREL:STRING=
//Flags for Windows Resource Compiler during RELEASE builds.
CMAKE_RC_FLAGS_RELEASE:STRING=
//Flags for Windows Resource Compiler during RELWITHDEBINFO builds.
CMAKE_RC_FLAGS_RELWITHDEBINFO:STRING=
//Flags used by the linker during the creation of shared libraries
// during all build types.
CMAKE_SHARED_LINKER_FLAGS:STRING=/machine:x64
//Flags used by the linker during the creation of shared libraries
// during DEBUG builds.
CMAKE_SHARED_LINKER_FLAGS_DEBUG:STRING=/debug /INCREMENTAL
//Flags used by the linker during the creation of shared libraries
// during MINSIZEREL builds.
CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL:STRING=/INCREMENTAL:NO
//Flags used by the linker during the creation of shared libraries
// during RELEASE builds.
CMAKE_SHARED_LINKER_FLAGS_RELEASE:STRING=/INCREMENTAL:NO
//Flags used by the linker during the creation of shared libraries
// during RELWITHDEBINFO builds.
CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO:STRING=/debug /INCREMENTAL
//If set, runtime paths are not added when installing shared libraries,
// but are added when building.
CMAKE_SKIP_INSTALL_RPATH:BOOL=NO
//If set, runtime paths are not added when using shared libraries.
CMAKE_SKIP_RPATH:BOOL=NO
//Flags used by the linker during the creation of static libraries
// during all build types.
CMAKE_STATIC_LINKER_FLAGS:STRING=/machine:x64
//Flags used by the linker during the creation of static libraries
// during DEBUG builds.
CMAKE_STATIC_LINKER_FLAGS_DEBUG:STRING=
//Flags used by the linker during the creation of static libraries
// during MINSIZEREL builds.
CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL:STRING=
//Flags used by the linker during the creation of static libraries
// during RELEASE builds.
CMAKE_STATIC_LINKER_FLAGS_RELEASE:STRING=
//Flags used by the linker during the creation of static libraries
// during RELWITHDEBINFO builds.
CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO:STRING=
//If this value is on, makefiles will be generated without the
// .SILENT directive, and all commands will be echoed to the console
// during the make. This is useful for debugging only. With Visual
// Studio IDE projects all commands are done without /nologo.
CMAKE_VERBOSE_MAKEFILE:BOOL=FALSE
//Value Computed by CMake
MyTinySTL_BINARY_DIR:STATIC=C:/Users/n/Desktop/软件工程/MyTinySTL/src/MyTinySTL-master/MyTinySTL-master/out/build/x64-Debug
//Value Computed by CMake
MyTinySTL_SOURCE_DIR:STATIC=C:/Users/n/Desktop/软件工程/MyTinySTL/src/MyTinySTL-master/MyTinySTL-master
########################
# INTERNAL cache entries
########################
//ADVANCED property for variable: CMAKE_AR
CMAKE_AR-ADVANCED:INTERNAL=1
//This is the directory where this CMakeCache.txt was created
CMAKE_CACHEFILE_DIR:INTERNAL=c:/Users/n/Desktop/软件工程/MyTinySTL/src/MyTinySTL-master/MyTinySTL-master/out/build/x64-Debug
//Major version of cmake used to create the current loaded cache
CMAKE_CACHE_MAJOR_VERSION:INTERNAL=3
//Minor version of cmake used to create the current loaded cache
CMAKE_CACHE_MINOR_VERSION:INTERNAL=20
//Patch version of cmake used to create the current loaded cache
CMAKE_CACHE_PATCH_VERSION:INTERNAL=21032501
//Path to CMake executable.
CMAKE_COMMAND:INTERNAL=D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/bin/cmake.exe
//Path to cpack program executable.
CMAKE_CPACK_COMMAND:INTERNAL=D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/bin/cpack.exe
//Path to ctest program executable.
CMAKE_CTEST_COMMAND:INTERNAL=D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/bin/ctest.exe
//ADVANCED property for variable: CMAKE_CXX_COMPILER
CMAKE_CXX_COMPILER-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_CXX_FLAGS
CMAKE_CXX_FLAGS-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_CXX_FLAGS_DEBUG
CMAKE_CXX_FLAGS_DEBUG-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_CXX_FLAGS_MINSIZEREL
CMAKE_CXX_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_CXX_FLAGS_RELEASE
CMAKE_CXX_FLAGS_RELEASE-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_CXX_FLAGS_RELWITHDEBINFO
CMAKE_CXX_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_CXX_STANDARD_LIBRARIES
CMAKE_CXX_STANDARD_LIBRARIES-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_C_COMPILER
CMAKE_C_COMPILER-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_C_FLAGS
CMAKE_C_FLAGS-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_C_FLAGS_DEBUG
CMAKE_C_FLAGS_DEBUG-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_C_FLAGS_MINSIZEREL
CMAKE_C_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_C_FLAGS_RELEASE
CMAKE_C_FLAGS_RELEASE-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_C_FLAGS_RELWITHDEBINFO
CMAKE_C_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_C_STANDARD_LIBRARIES
CMAKE_C_STANDARD_LIBRARIES-ADVANCED:INTERNAL=1
//Executable file format
CMAKE_EXECUTABLE_FORMAT:INTERNAL=Unknown
//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS
CMAKE_EXE_LINKER_FLAGS-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_DEBUG
CMAKE_EXE_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_MINSIZEREL
CMAKE_EXE_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_RELEASE
CMAKE_EXE_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO
CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_EXPORT_COMPILE_COMMANDS
CMAKE_EXPORT_COMPILE_COMMANDS-ADVANCED:INTERNAL=1
//Name of external makefile project generator.
CMAKE_EXTRA_GENERATOR:INTERNAL=
//Name of generator.
CMAKE_GENERATOR:INTERNAL=Ninja
//Generator instance identifier.
CMAKE_GENERATOR_INSTANCE:INTERNAL=
//Name of generator platform.
CMAKE_GENERATOR_PLATFORM:INTERNAL=
//Name of generator toolset.
CMAKE_GENERATOR_TOOLSET:INTERNAL=
//Source directory with the top level CMakeLists.txt file for this
// project
CMAKE_HOME_DIRECTORY:INTERNAL=C:/Users/n/Desktop/软件工程/MyTinySTL/src/MyTinySTL-master/MyTinySTL-master
//ADVANCED property for variable: CMAKE_LINKER
CMAKE_LINKER-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS
CMAKE_MODULE_LINKER_FLAGS-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_DEBUG
CMAKE_MODULE_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL
CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_RELEASE
CMAKE_MODULE_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO
CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_MT
CMAKE_MT-ADVANCED:INTERNAL=1
//number of local generators
CMAKE_NUMBER_OF_MAKEFILES:INTERNAL=2
//Platform information initialized
CMAKE_PLATFORM_INFO_INITIALIZED:INTERNAL=1
//noop for ranlib
CMAKE_RANLIB:INTERNAL=:
//ADVANCED property for variable: CMAKE_RC_COMPILER
CMAKE_RC_COMPILER-ADVANCED:INTERNAL=1
CMAKE_RC_COMPILER_WORKS:INTERNAL=1
//ADVANCED property for variable: CMAKE_RC_FLAGS
CMAKE_RC_FLAGS-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_RC_FLAGS_DEBUG
CMAKE_RC_FLAGS_DEBUG-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_RC_FLAGS_MINSIZEREL
CMAKE_RC_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_RC_FLAGS_RELEASE
CMAKE_RC_FLAGS_RELEASE-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_RC_FLAGS_RELWITHDEBINFO
CMAKE_RC_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
//Path to CMake installation.
CMAKE_ROOT:INTERNAL=D:/VS2019/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20
//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS
CMAKE_SHARED_LINKER_FLAGS-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_DEBUG
CMAKE_SHARED_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL
CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_RELEASE
CMAKE_SHARED_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO
CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_SKIP_INSTALL_RPATH
CMAKE_SKIP_INSTALL_RPATH-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_SKIP_RPATH
CMAKE_SKIP_RPATH-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS
CMAKE_STATIC_LINKER_FLAGS-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_DEBUG
CMAKE_STATIC_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL
CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_RELEASE
CMAKE_STATIC_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO
CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_VERBOSE_MAKEFILE
CMAKE_VERBOSE_MAKEFILE-ADVANCED:INTERNAL=1

@ -1,78 +0,0 @@
set(CMAKE_C_COMPILER "D:/VS2019/VC/Tools/MSVC/14.29.30133/bin/Hostx64/x64/cl.exe")
set(CMAKE_C_COMPILER_ARG1 "")
set(CMAKE_C_COMPILER_ID "MSVC")
set(CMAKE_C_COMPILER_VERSION "19.29.30154.0")
set(CMAKE_C_COMPILER_VERSION_INTERNAL "")
set(CMAKE_C_COMPILER_WRAPPER "")
set(CMAKE_C_STANDARD_COMPUTED_DEFAULT "90")
set(CMAKE_C_COMPILE_FEATURES "c_std_90;c_std_99;c_std_11;c_function_prototypes;c_variadic_macros;c_restrict;c_static_assert")
set(CMAKE_C90_COMPILE_FEATURES "c_std_90;c_function_prototypes")
set(CMAKE_C99_COMPILE_FEATURES "c_std_99;c_variadic_macros;c_restrict")
set(CMAKE_C11_COMPILE_FEATURES "c_std_11;c_static_assert")
set(CMAKE_C_PLATFORM_ID "Windows")
set(CMAKE_C_SIMULATE_ID "")
set(CMAKE_C_COMPILER_FRONTEND_VARIANT "")
set(CMAKE_C_SIMULATE_VERSION "")
set(CMAKE_C_COMPILER_ARCHITECTURE_ID x64)
set(MSVC_C_ARCHITECTURE_ID x64)
set(CMAKE_AR "D:/VS2019/VC/Tools/MSVC/14.29.30133/bin/Hostx64/x64/lib.exe")
set(CMAKE_C_COMPILER_AR "")
set(CMAKE_RANLIB ":")
set(CMAKE_C_COMPILER_RANLIB "")
set(CMAKE_LINKER "D:/VS2019/VC/Tools/MSVC/14.29.30133/bin/Hostx64/x64/link.exe")
set(CMAKE_MT "C:/Program Files (x86)/Windows Kits/10/bin/10.0.19041.0/x64/mt.exe")
set(CMAKE_COMPILER_IS_GNUCC )
set(CMAKE_C_COMPILER_LOADED 1)
set(CMAKE_C_COMPILER_WORKS TRUE)
set(CMAKE_C_ABI_COMPILED TRUE)
set(CMAKE_COMPILER_IS_MINGW )
set(CMAKE_COMPILER_IS_CYGWIN )
if(CMAKE_COMPILER_IS_CYGWIN)
set(CYGWIN 1)
set(UNIX 1)
endif()
set(CMAKE_C_COMPILER_ENV_VAR "CC")
if(CMAKE_COMPILER_IS_MINGW)
set(MINGW 1)
endif()
set(CMAKE_C_COMPILER_ID_RUN 1)
set(CMAKE_C_SOURCE_FILE_EXTENSIONS c;m)
set(CMAKE_C_IGNORE_EXTENSIONS h;H;o;O;obj;OBJ;def;DEF;rc;RC)
set(CMAKE_C_LINKER_PREFERENCE 10)
# Save compiler ABI information.
set(CMAKE_C_SIZEOF_DATA_PTR "8")
set(CMAKE_C_COMPILER_ABI "")
set(CMAKE_C_BYTE_ORDER "LITTLE_ENDIAN")
set(CMAKE_C_LIBRARY_ARCHITECTURE "")
if(CMAKE_C_SIZEOF_DATA_PTR)
set(CMAKE_SIZEOF_VOID_P "${CMAKE_C_SIZEOF_DATA_PTR}")
endif()
if(CMAKE_C_COMPILER_ABI)
set(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_C_COMPILER_ABI}")
endif()
if(CMAKE_C_LIBRARY_ARCHITECTURE)
set(CMAKE_LIBRARY_ARCHITECTURE "")
endif()
set(CMAKE_C_CL_SHOWINCLUDES_PREFIX "注意: 包含文件: ")
if(CMAKE_C_CL_SHOWINCLUDES_PREFIX)
set(CMAKE_CL_SHOWINCLUDES_PREFIX "${CMAKE_C_CL_SHOWINCLUDES_PREFIX}")
endif()
set(CMAKE_C_IMPLICIT_INCLUDE_DIRECTORIES "")
set(CMAKE_C_IMPLICIT_LINK_LIBRARIES "")
set(CMAKE_C_IMPLICIT_LINK_DIRECTORIES "")
set(CMAKE_C_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "")

@ -1,91 +0,0 @@
set(CMAKE_CXX_COMPILER "D:/VS2019/VC/Tools/MSVC/14.29.30133/bin/Hostx64/x64/cl.exe")
set(CMAKE_CXX_COMPILER_ARG1 "")
set(CMAKE_CXX_COMPILER_ID "MSVC")
set(CMAKE_CXX_COMPILER_VERSION "19.29.30154.0")
set(CMAKE_CXX_COMPILER_VERSION_INTERNAL "")
set(CMAKE_CXX_COMPILER_WRAPPER "")
set(CMAKE_CXX_STANDARD_COMPUTED_DEFAULT "14")
set(CMAKE_CXX_COMPILE_FEATURES "cxx_std_98;cxx_template_template_parameters;cxx_std_11;cxx_alias_templates;cxx_alignas;cxx_alignof;cxx_attributes;cxx_auto_type;cxx_constexpr;cxx_decltype;cxx_decltype_incomplete_return_types;cxx_default_function_template_args;cxx_defaulted_functions;cxx_defaulted_move_initializers;cxx_delegating_constructors;cxx_deleted_functions;cxx_enum_forward_declarations;cxx_explicit_conversions;cxx_extended_friend_declarations;cxx_extern_templates;cxx_final;cxx_func_identifier;cxx_generalized_initializers;cxx_inheriting_constructors;cxx_inline_namespaces;cxx_lambdas;cxx_local_type_template_args;cxx_long_long_type;cxx_noexcept;cxx_nonstatic_member_init;cxx_nullptr;cxx_override;cxx_range_for;cxx_raw_string_literals;cxx_reference_qualified_functions;cxx_right_angle_brackets;cxx_rvalue_references;cxx_sizeof_member;cxx_static_assert;cxx_strong_enums;cxx_thread_local;cxx_trailing_return_types;cxx_unicode_literals;cxx_uniform_initialization;cxx_unrestricted_unions;cxx_user_literals;cxx_variadic_macros;cxx_variadic_templates;cxx_std_14;cxx_aggregate_default_initializers;cxx_attribute_deprecated;cxx_binary_literals;cxx_contextual_conversions;cxx_decltype_auto;cxx_digit_separators;cxx_generic_lambdas;cxx_lambda_init_captures;cxx_relaxed_constexpr;cxx_return_type_deduction;cxx_variable_templates;cxx_std_17;cxx_std_20")
set(CMAKE_CXX98_COMPILE_FEATURES "cxx_std_98;cxx_template_template_parameters")
set(CMAKE_CXX11_COMPILE_FEATURES "cxx_std_11;cxx_alias_templates;cxx_alignas;cxx_alignof;cxx_attributes;cxx_auto_type;cxx_constexpr;cxx_decltype;cxx_decltype_incomplete_return_types;cxx_default_function_template_args;cxx_defaulted_functions;cxx_defaulted_move_initializers;cxx_delegating_constructors;cxx_deleted_functions;cxx_enum_forward_declarations;cxx_explicit_conversions;cxx_extended_friend_declarations;cxx_extern_templates;cxx_final;cxx_func_identifier;cxx_generalized_initializers;cxx_inheriting_constructors;cxx_inline_namespaces;cxx_lambdas;cxx_local_type_template_args;cxx_long_long_type;cxx_noexcept;cxx_nonstatic_member_init;cxx_nullptr;cxx_override;cxx_range_for;cxx_raw_string_literals;cxx_reference_qualified_functions;cxx_right_angle_brackets;cxx_rvalue_references;cxx_sizeof_member;cxx_static_assert;cxx_strong_enums;cxx_thread_local;cxx_trailing_return_types;cxx_unicode_literals;cxx_uniform_initialization;cxx_unrestricted_unions;cxx_user_literals;cxx_variadic_macros;cxx_variadic_templates")
set(CMAKE_CXX14_COMPILE_FEATURES "cxx_std_14;cxx_aggregate_default_initializers;cxx_attribute_deprecated;cxx_binary_literals;cxx_contextual_conversions;cxx_decltype_auto;cxx_digit_separators;cxx_generic_lambdas;cxx_lambda_init_captures;cxx_relaxed_constexpr;cxx_return_type_deduction;cxx_variable_templates")
set(CMAKE_CXX17_COMPILE_FEATURES "cxx_std_17")
set(CMAKE_CXX20_COMPILE_FEATURES "cxx_std_20")
set(CMAKE_CXX23_COMPILE_FEATURES "")
set(CMAKE_CXX_PLATFORM_ID "Windows")
set(CMAKE_CXX_SIMULATE_ID "")
set(CMAKE_CXX_COMPILER_FRONTEND_VARIANT "")
set(CMAKE_CXX_SIMULATE_VERSION "")
set(CMAKE_CXX_COMPILER_ARCHITECTURE_ID x64)
set(MSVC_CXX_ARCHITECTURE_ID x64)
set(CMAKE_AR "D:/VS2019/VC/Tools/MSVC/14.29.30133/bin/Hostx64/x64/lib.exe")
set(CMAKE_CXX_COMPILER_AR "")
set(CMAKE_RANLIB ":")
set(CMAKE_CXX_COMPILER_RANLIB "")
set(CMAKE_LINKER "D:/VS2019/VC/Tools/MSVC/14.29.30133/bin/Hostx64/x64/link.exe")
set(CMAKE_MT "C:/Program Files (x86)/Windows Kits/10/bin/10.0.19041.0/x64/mt.exe")
set(CMAKE_COMPILER_IS_GNUCXX )
set(CMAKE_CXX_COMPILER_LOADED 1)
set(CMAKE_CXX_COMPILER_WORKS TRUE)
set(CMAKE_CXX_ABI_COMPILED TRUE)
set(CMAKE_COMPILER_IS_MINGW )
set(CMAKE_COMPILER_IS_CYGWIN )
if(CMAKE_COMPILER_IS_CYGWIN)
set(CYGWIN 1)
set(UNIX 1)
endif()
set(CMAKE_CXX_COMPILER_ENV_VAR "CXX")
if(CMAKE_COMPILER_IS_MINGW)
set(MINGW 1)
endif()
set(CMAKE_CXX_COMPILER_ID_RUN 1)
set(CMAKE_CXX_SOURCE_FILE_EXTENSIONS C;M;c++;cc;cpp;cxx;m;mm;mpp;CPP)
set(CMAKE_CXX_IGNORE_EXTENSIONS inl;h;hpp;HPP;H;o;O;obj;OBJ;def;DEF;rc;RC)
foreach (lang C OBJC OBJCXX)
if (CMAKE_${lang}_COMPILER_ID_RUN)
foreach(extension IN LISTS CMAKE_${lang}_SOURCE_FILE_EXTENSIONS)
list(REMOVE_ITEM CMAKE_CXX_SOURCE_FILE_EXTENSIONS ${extension})
endforeach()
endif()
endforeach()
set(CMAKE_CXX_LINKER_PREFERENCE 30)
set(CMAKE_CXX_LINKER_PREFERENCE_PROPAGATES 1)
# Save compiler ABI information.
set(CMAKE_CXX_SIZEOF_DATA_PTR "8")
set(CMAKE_CXX_COMPILER_ABI "")
set(CMAKE_CXX_BYTE_ORDER "LITTLE_ENDIAN")
set(CMAKE_CXX_LIBRARY_ARCHITECTURE "")
if(CMAKE_CXX_SIZEOF_DATA_PTR)
set(CMAKE_SIZEOF_VOID_P "${CMAKE_CXX_SIZEOF_DATA_PTR}")
endif()
if(CMAKE_CXX_COMPILER_ABI)
set(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_CXX_COMPILER_ABI}")
endif()
if(CMAKE_CXX_LIBRARY_ARCHITECTURE)
set(CMAKE_LIBRARY_ARCHITECTURE "")
endif()
set(CMAKE_CXX_CL_SHOWINCLUDES_PREFIX "注意: 包含文件: ")
if(CMAKE_CXX_CL_SHOWINCLUDES_PREFIX)
set(CMAKE_CL_SHOWINCLUDES_PREFIX "${CMAKE_CXX_CL_SHOWINCLUDES_PREFIX}")
endif()
set(CMAKE_CXX_IMPLICIT_INCLUDE_DIRECTORIES "")
set(CMAKE_CXX_IMPLICIT_LINK_LIBRARIES "")
set(CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES "")
set(CMAKE_CXX_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "")

@ -1,6 +0,0 @@
set(CMAKE_RC_COMPILER "C:/Program Files (x86)/Windows Kits/10/bin/10.0.19041.0/x64/rc.exe")
set(CMAKE_RC_COMPILER_ARG1 "")
set(CMAKE_RC_COMPILER_LOADED 1)
set(CMAKE_RC_SOURCE_FILE_EXTENSIONS rc;RC)
set(CMAKE_RC_OUTPUT_EXTENSION .res)
set(CMAKE_RC_COMPILER_ENV_VAR "RC")

@ -1,15 +0,0 @@
set(CMAKE_HOST_SYSTEM "Windows-10.0.22631")
set(CMAKE_HOST_SYSTEM_NAME "Windows")
set(CMAKE_HOST_SYSTEM_VERSION "10.0.22631")
set(CMAKE_HOST_SYSTEM_PROCESSOR "AMD64")
set(CMAKE_SYSTEM "Windows-10.0.22631")
set(CMAKE_SYSTEM_NAME "Windows")
set(CMAKE_SYSTEM_VERSION "10.0.22631")
set(CMAKE_SYSTEM_PROCESSOR "AMD64")
set(CMAKE_CROSSCOMPILING "FALSE")
set(CMAKE_SYSTEM_LOADED 1)

@ -1,743 +0,0 @@
#ifdef __cplusplus
# error "A C++ compiler has been selected for C."
#endif
#if defined(__18CXX)
# define ID_VOID_MAIN
#endif
#if defined(__CLASSIC_C__)
/* cv-qualifiers did not exist in K&R C */
# define const
# define volatile
#endif
/* Version number components: V=Version, R=Revision, P=Patch
Version date components: YYYY=Year, MM=Month, DD=Day */
#if defined(__INTEL_COMPILER) || defined(__ICC)
# define COMPILER_ID "Intel"
# if defined(_MSC_VER)
# define SIMULATE_ID "MSVC"
# endif
# if defined(__GNUC__)
# define SIMULATE_ID "GNU"
# endif
/* __INTEL_COMPILER = VRP */
# define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER/100)
# define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER/10 % 10)
# if defined(__INTEL_COMPILER_UPDATE)
# define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER_UPDATE)
# else
# define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER % 10)
# endif
# if defined(__INTEL_COMPILER_BUILD_DATE)
/* __INTEL_COMPILER_BUILD_DATE = YYYYMMDD */
# define COMPILER_VERSION_TWEAK DEC(__INTEL_COMPILER_BUILD_DATE)
# endif
# if defined(_MSC_VER)
/* _MSC_VER = VVRR */
# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
# endif
# if defined(__GNUC__)
# define SIMULATE_VERSION_MAJOR DEC(__GNUC__)
# elif defined(__GNUG__)
# define SIMULATE_VERSION_MAJOR DEC(__GNUG__)
# endif
# if defined(__GNUC_MINOR__)
# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__)
# endif
# if defined(__GNUC_PATCHLEVEL__)
# define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
# endif
#elif (defined(__clang__) && defined(__INTEL_CLANG_COMPILER)) || defined(__INTEL_LLVM_COMPILER)
# define COMPILER_ID "IntelLLVM"
#if defined(_MSC_VER)
# define SIMULATE_ID "MSVC"
#endif
#if defined(__GNUC__)
# define SIMULATE_ID "GNU"
#endif
/* __INTEL_LLVM_COMPILER = VVVVRP prior to 2021.2.0, VVVVRRPP for 2021.2.0 and
* later. Look for 6 digit vs. 8 digit version number to decide encoding.
* VVVV is no smaller than the current year when a versio is released.
*/
#if __INTEL_LLVM_COMPILER < 1000000L
# define COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/100)
# define COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/10 % 10)
# define COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER % 10)
#else
# define COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/10000)
# define COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/100 % 100)
# define COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER % 100)
#endif
#if defined(_MSC_VER)
/* _MSC_VER = VVRR */
# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
#endif
#if defined(__GNUC__)
# define SIMULATE_VERSION_MAJOR DEC(__GNUC__)
#elif defined(__GNUG__)
# define SIMULATE_VERSION_MAJOR DEC(__GNUG__)
#endif
#if defined(__GNUC_MINOR__)
# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__)
#endif
#if defined(__GNUC_PATCHLEVEL__)
# define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
#endif
#elif defined(__PATHCC__)
# define COMPILER_ID "PathScale"
# define COMPILER_VERSION_MAJOR DEC(__PATHCC__)
# define COMPILER_VERSION_MINOR DEC(__PATHCC_MINOR__)
# if defined(__PATHCC_PATCHLEVEL__)
# define COMPILER_VERSION_PATCH DEC(__PATHCC_PATCHLEVEL__)
# endif
#elif defined(__BORLANDC__) && defined(__CODEGEARC_VERSION__)
# define COMPILER_ID "Embarcadero"
# define COMPILER_VERSION_MAJOR HEX(__CODEGEARC_VERSION__>>24 & 0x00FF)
# define COMPILER_VERSION_MINOR HEX(__CODEGEARC_VERSION__>>16 & 0x00FF)
# define COMPILER_VERSION_PATCH DEC(__CODEGEARC_VERSION__ & 0xFFFF)
#elif defined(__BORLANDC__)
# define COMPILER_ID "Borland"
/* __BORLANDC__ = 0xVRR */
# define COMPILER_VERSION_MAJOR HEX(__BORLANDC__>>8)
# define COMPILER_VERSION_MINOR HEX(__BORLANDC__ & 0xFF)
#elif defined(__WATCOMC__) && __WATCOMC__ < 1200
# define COMPILER_ID "Watcom"
/* __WATCOMC__ = VVRR */
# define COMPILER_VERSION_MAJOR DEC(__WATCOMC__ / 100)
# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10)
# if (__WATCOMC__ % 10) > 0
# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10)
# endif
#elif defined(__WATCOMC__)
# define COMPILER_ID "OpenWatcom"
/* __WATCOMC__ = VVRP + 1100 */
# define COMPILER_VERSION_MAJOR DEC((__WATCOMC__ - 1100) / 100)
# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10)
# if (__WATCOMC__ % 10) > 0
# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10)
# endif
#elif defined(__SUNPRO_C)
# define COMPILER_ID "SunPro"
# if __SUNPRO_C >= 0x5100
/* __SUNPRO_C = 0xVRRP */
# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_C>>12)
# define COMPILER_VERSION_MINOR HEX(__SUNPRO_C>>4 & 0xFF)
# define COMPILER_VERSION_PATCH HEX(__SUNPRO_C & 0xF)
# else
/* __SUNPRO_CC = 0xVRP */
# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_C>>8)
# define COMPILER_VERSION_MINOR HEX(__SUNPRO_C>>4 & 0xF)
# define COMPILER_VERSION_PATCH HEX(__SUNPRO_C & 0xF)
# endif
#elif defined(__HP_cc)
# define COMPILER_ID "HP"
/* __HP_cc = VVRRPP */
# define COMPILER_VERSION_MAJOR DEC(__HP_cc/10000)
# define COMPILER_VERSION_MINOR DEC(__HP_cc/100 % 100)
# define COMPILER_VERSION_PATCH DEC(__HP_cc % 100)
#elif defined(__DECC)
# define COMPILER_ID "Compaq"
/* __DECC_VER = VVRRTPPPP */
# define COMPILER_VERSION_MAJOR DEC(__DECC_VER/10000000)
# define COMPILER_VERSION_MINOR DEC(__DECC_VER/100000 % 100)
# define COMPILER_VERSION_PATCH DEC(__DECC_VER % 10000)
#elif defined(__IBMC__) && defined(__COMPILER_VER__)
# define COMPILER_ID "zOS"
/* __IBMC__ = VRP */
# define COMPILER_VERSION_MAJOR DEC(__IBMC__/100)
# define COMPILER_VERSION_MINOR DEC(__IBMC__/10 % 10)
# define COMPILER_VERSION_PATCH DEC(__IBMC__ % 10)
#elif defined(__ibmxl__) && defined(__clang__)
# define COMPILER_ID "XLClang"
# define COMPILER_VERSION_MAJOR DEC(__ibmxl_version__)
# define COMPILER_VERSION_MINOR DEC(__ibmxl_release__)
# define COMPILER_VERSION_PATCH DEC(__ibmxl_modification__)
# define COMPILER_VERSION_TWEAK DEC(__ibmxl_ptf_fix_level__)
#elif defined(__IBMC__) && !defined(__COMPILER_VER__) && __IBMC__ >= 800
# define COMPILER_ID "XL"
/* __IBMC__ = VRP */
# define COMPILER_VERSION_MAJOR DEC(__IBMC__/100)
# define COMPILER_VERSION_MINOR DEC(__IBMC__/10 % 10)
# define COMPILER_VERSION_PATCH DEC(__IBMC__ % 10)
#elif defined(__IBMC__) && !defined(__COMPILER_VER__) && __IBMC__ < 800
# define COMPILER_ID "VisualAge"
/* __IBMC__ = VRP */
# define COMPILER_VERSION_MAJOR DEC(__IBMC__/100)
# define COMPILER_VERSION_MINOR DEC(__IBMC__/10 % 10)
# define COMPILER_VERSION_PATCH DEC(__IBMC__ % 10)
#elif defined(__NVCOMPILER)
# define COMPILER_ID "NVHPC"
# define COMPILER_VERSION_MAJOR DEC(__NVCOMPILER_MAJOR__)
# define COMPILER_VERSION_MINOR DEC(__NVCOMPILER_MINOR__)
# if defined(__NVCOMPILER_PATCHLEVEL__)
# define COMPILER_VERSION_PATCH DEC(__NVCOMPILER_PATCHLEVEL__)
# endif
#elif defined(__PGI)
# define COMPILER_ID "PGI"
# define COMPILER_VERSION_MAJOR DEC(__PGIC__)
# define COMPILER_VERSION_MINOR DEC(__PGIC_MINOR__)
# if defined(__PGIC_PATCHLEVEL__)
# define COMPILER_VERSION_PATCH DEC(__PGIC_PATCHLEVEL__)
# endif
#elif defined(_CRAYC)
# define COMPILER_ID "Cray"
# define COMPILER_VERSION_MAJOR DEC(_RELEASE_MAJOR)
# define COMPILER_VERSION_MINOR DEC(_RELEASE_MINOR)
#elif defined(__TI_COMPILER_VERSION__)
# define COMPILER_ID "TI"
/* __TI_COMPILER_VERSION__ = VVVRRRPPP */
# define COMPILER_VERSION_MAJOR DEC(__TI_COMPILER_VERSION__/1000000)
# define COMPILER_VERSION_MINOR DEC(__TI_COMPILER_VERSION__/1000 % 1000)
# define COMPILER_VERSION_PATCH DEC(__TI_COMPILER_VERSION__ % 1000)
#elif defined(__FUJITSU) || defined(__FCC_VERSION) || defined(__fcc_version)
# define COMPILER_ID "Fujitsu"
#elif defined(__ghs__)
# define COMPILER_ID "GHS"
/* __GHS_VERSION_NUMBER = VVVVRP */
# ifdef __GHS_VERSION_NUMBER
# define COMPILER_VERSION_MAJOR DEC(__GHS_VERSION_NUMBER / 100)
# define COMPILER_VERSION_MINOR DEC(__GHS_VERSION_NUMBER / 10 % 10)
# define COMPILER_VERSION_PATCH DEC(__GHS_VERSION_NUMBER % 10)
# endif
#elif defined(__TINYC__)
# define COMPILER_ID "TinyCC"
#elif defined(__BCC__)
# define COMPILER_ID "Bruce"
#elif defined(__SCO_VERSION__)
# define COMPILER_ID "SCO"
#elif defined(__ARMCC_VERSION) && !defined(__clang__)
# define COMPILER_ID "ARMCC"
#if __ARMCC_VERSION >= 1000000
/* __ARMCC_VERSION = VRRPPPP */
# define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/1000000)
# define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 100)
# define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000)
#else
/* __ARMCC_VERSION = VRPPPP */
# define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/100000)
# define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 10)
# define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000)
#endif
#elif defined(__clang__) && defined(__apple_build_version__)
# define COMPILER_ID "AppleClang"
# if defined(_MSC_VER)
# define SIMULATE_ID "MSVC"
# endif
# define COMPILER_VERSION_MAJOR DEC(__clang_major__)
# define COMPILER_VERSION_MINOR DEC(__clang_minor__)
# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__)
# if defined(_MSC_VER)
/* _MSC_VER = VVRR */
# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
# endif
# define COMPILER_VERSION_TWEAK DEC(__apple_build_version__)
#elif defined(__clang__) && defined(__ARMCOMPILER_VERSION)
# define COMPILER_ID "ARMClang"
# define COMPILER_VERSION_MAJOR DEC(__ARMCOMPILER_VERSION/1000000)
# define COMPILER_VERSION_MINOR DEC(__ARMCOMPILER_VERSION/10000 % 100)
# define COMPILER_VERSION_PATCH DEC(__ARMCOMPILER_VERSION % 10000)
# define COMPILER_VERSION_INTERNAL DEC(__ARMCOMPILER_VERSION)
#elif defined(__clang__)
# define COMPILER_ID "Clang"
# if defined(_MSC_VER)
# define SIMULATE_ID "MSVC"
# endif
# define COMPILER_VERSION_MAJOR DEC(__clang_major__)
# define COMPILER_VERSION_MINOR DEC(__clang_minor__)
# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__)
# if defined(_MSC_VER)
/* _MSC_VER = VVRR */
# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
# endif
#elif defined(__GNUC__)
# define COMPILER_ID "GNU"
# define COMPILER_VERSION_MAJOR DEC(__GNUC__)
# if defined(__GNUC_MINOR__)
# define COMPILER_VERSION_MINOR DEC(__GNUC_MINOR__)
# endif
# if defined(__GNUC_PATCHLEVEL__)
# define COMPILER_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
# endif
#elif defined(_MSC_VER)
# define COMPILER_ID "MSVC"
/* _MSC_VER = VVRR */
# define COMPILER_VERSION_MAJOR DEC(_MSC_VER / 100)
# define COMPILER_VERSION_MINOR DEC(_MSC_VER % 100)
# if defined(_MSC_FULL_VER)
# if _MSC_VER >= 1400
/* _MSC_FULL_VER = VVRRPPPPP */
# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 100000)
# else
/* _MSC_FULL_VER = VVRRPPPP */
# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 10000)
# endif
# endif
# if defined(_MSC_BUILD)
# define COMPILER_VERSION_TWEAK DEC(_MSC_BUILD)
# endif
#elif defined(__VISUALDSPVERSION__) || defined(__ADSPBLACKFIN__) || defined(__ADSPTS__) || defined(__ADSP21000__)
# define COMPILER_ID "ADSP"
#if defined(__VISUALDSPVERSION__)
/* __VISUALDSPVERSION__ = 0xVVRRPP00 */
# define COMPILER_VERSION_MAJOR HEX(__VISUALDSPVERSION__>>24)
# define COMPILER_VERSION_MINOR HEX(__VISUALDSPVERSION__>>16 & 0xFF)
# define COMPILER_VERSION_PATCH HEX(__VISUALDSPVERSION__>>8 & 0xFF)
#endif
#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC)
# define COMPILER_ID "IAR"
# if defined(__VER__) && defined(__ICCARM__)
# define COMPILER_VERSION_MAJOR DEC((__VER__) / 1000000)
# define COMPILER_VERSION_MINOR DEC(((__VER__) / 1000) % 1000)
# define COMPILER_VERSION_PATCH DEC((__VER__) % 1000)
# define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__)
# elif defined(__VER__) && (defined(__ICCAVR__) || defined(__ICCRX__) || defined(__ICCRH850__) || defined(__ICCRL78__) || defined(__ICC430__) || defined(__ICCRISCV__) || defined(__ICCV850__) || defined(__ICC8051__) || defined(__ICCSTM8__))
# define COMPILER_VERSION_MAJOR DEC((__VER__) / 100)
# define COMPILER_VERSION_MINOR DEC((__VER__) - (((__VER__) / 100)*100))
# define COMPILER_VERSION_PATCH DEC(__SUBVERSION__)
# define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__)
# endif
#elif defined(__SDCC_VERSION_MAJOR) || defined(SDCC)
# define COMPILER_ID "SDCC"
# if defined(__SDCC_VERSION_MAJOR)
# define COMPILER_VERSION_MAJOR DEC(__SDCC_VERSION_MAJOR)
# define COMPILER_VERSION_MINOR DEC(__SDCC_VERSION_MINOR)
# define COMPILER_VERSION_PATCH DEC(__SDCC_VERSION_PATCH)
# else
/* SDCC = VRP */
# define COMPILER_VERSION_MAJOR DEC(SDCC/100)
# define COMPILER_VERSION_MINOR DEC(SDCC/10 % 10)
# define COMPILER_VERSION_PATCH DEC(SDCC % 10)
# endif
/* These compilers are either not known or too old to define an
identification macro. Try to identify the platform and guess that
it is the native compiler. */
#elif defined(__hpux) || defined(__hpua)
# define COMPILER_ID "HP"
#else /* unknown compiler */
# define COMPILER_ID ""
#endif
/* Construct the string literal in pieces to prevent the source from
getting matched. Store it in a pointer rather than an array
because some compilers will just produce instructions to fill the
array rather than assigning a pointer to a static array. */
char const* info_compiler = "INFO" ":" "compiler[" COMPILER_ID "]";
#ifdef SIMULATE_ID
char const* info_simulate = "INFO" ":" "simulate[" SIMULATE_ID "]";
#endif
#ifdef __QNXNTO__
char const* qnxnto = "INFO" ":" "qnxnto[]";
#endif
#if defined(__CRAYXT_COMPUTE_LINUX_TARGET)
char const *info_cray = "INFO" ":" "compiler_wrapper[CrayPrgEnv]";
#endif
#define STRINGIFY_HELPER(X) #X
#define STRINGIFY(X) STRINGIFY_HELPER(X)
/* Identify known platforms by name. */
#if defined(__linux) || defined(__linux__) || defined(linux)
# define PLATFORM_ID "Linux"
#elif defined(__CYGWIN__)
# define PLATFORM_ID "Cygwin"
#elif defined(__MINGW32__)
# define PLATFORM_ID "MinGW"
#elif defined(__APPLE__)
# define PLATFORM_ID "Darwin"
#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
# define PLATFORM_ID "Windows"
#elif defined(__FreeBSD__) || defined(__FreeBSD)
# define PLATFORM_ID "FreeBSD"
#elif defined(__NetBSD__) || defined(__NetBSD)
# define PLATFORM_ID "NetBSD"
#elif defined(__OpenBSD__) || defined(__OPENBSD)
# define PLATFORM_ID "OpenBSD"
#elif defined(__sun) || defined(sun)
# define PLATFORM_ID "SunOS"
#elif defined(_AIX) || defined(__AIX) || defined(__AIX__) || defined(__aix) || defined(__aix__)
# define PLATFORM_ID "AIX"
#elif defined(__hpux) || defined(__hpux__)
# define PLATFORM_ID "HP-UX"
#elif defined(__HAIKU__)
# define PLATFORM_ID "Haiku"
#elif defined(__BeOS) || defined(__BEOS__) || defined(_BEOS)
# define PLATFORM_ID "BeOS"
#elif defined(__QNX__) || defined(__QNXNTO__)
# define PLATFORM_ID "QNX"
#elif defined(__tru64) || defined(_tru64) || defined(__TRU64__)
# define PLATFORM_ID "Tru64"
#elif defined(__riscos) || defined(__riscos__)
# define PLATFORM_ID "RISCos"
#elif defined(__sinix) || defined(__sinix__) || defined(__SINIX__)
# define PLATFORM_ID "SINIX"
#elif defined(__UNIX_SV__)
# define PLATFORM_ID "UNIX_SV"
#elif defined(__bsdos__)
# define PLATFORM_ID "BSDOS"
#elif defined(_MPRAS) || defined(MPRAS)
# define PLATFORM_ID "MP-RAS"
#elif defined(__osf) || defined(__osf__)
# define PLATFORM_ID "OSF1"
#elif defined(_SCO_SV) || defined(SCO_SV) || defined(sco_sv)
# define PLATFORM_ID "SCO_SV"
#elif defined(__ultrix) || defined(__ultrix__) || defined(_ULTRIX)
# define PLATFORM_ID "ULTRIX"
#elif defined(__XENIX__) || defined(_XENIX) || defined(XENIX)
# define PLATFORM_ID "Xenix"
#elif defined(__WATCOMC__)
# if defined(__LINUX__)
# define PLATFORM_ID "Linux"
# elif defined(__DOS__)
# define PLATFORM_ID "DOS"
# elif defined(__OS2__)
# define PLATFORM_ID "OS2"
# elif defined(__WINDOWS__)
# define PLATFORM_ID "Windows3x"
# elif defined(__VXWORKS__)
# define PLATFORM_ID "VxWorks"
# else /* unknown platform */
# define PLATFORM_ID
# endif
#elif defined(__INTEGRITY)
# if defined(INT_178B)
# define PLATFORM_ID "Integrity178"
# else /* regular Integrity */
# define PLATFORM_ID "Integrity"
# endif
#else /* unknown platform */
# define PLATFORM_ID
#endif
/* For windows compilers MSVC and Intel we can determine
the architecture of the compiler being used. This is because
the compilers do not have flags that can change the architecture,
but rather depend on which compiler is being used
*/
#if defined(_WIN32) && defined(_MSC_VER)
# if defined(_M_IA64)
# define ARCHITECTURE_ID "IA64"
# elif defined(_M_ARM64EC)
# define ARCHITECTURE_ID "ARM64EC"
# elif defined(_M_X64) || defined(_M_AMD64)
# define ARCHITECTURE_ID "x64"
# elif defined(_M_IX86)
# define ARCHITECTURE_ID "X86"
# elif defined(_M_ARM64)
# define ARCHITECTURE_ID "ARM64"
# elif defined(_M_ARM)
# if _M_ARM == 4
# define ARCHITECTURE_ID "ARMV4I"
# elif _M_ARM == 5
# define ARCHITECTURE_ID "ARMV5I"
# else
# define ARCHITECTURE_ID "ARMV" STRINGIFY(_M_ARM)
# endif
# elif defined(_M_MIPS)
# define ARCHITECTURE_ID "MIPS"
# elif defined(_M_SH)
# define ARCHITECTURE_ID "SHx"
# else /* unknown architecture */
# define ARCHITECTURE_ID ""
# endif
#elif defined(__WATCOMC__)
# if defined(_M_I86)
# define ARCHITECTURE_ID "I86"
# elif defined(_M_IX86)
# define ARCHITECTURE_ID "X86"
# else /* unknown architecture */
# define ARCHITECTURE_ID ""
# endif
#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC)
# if defined(__ICCARM__)
# define ARCHITECTURE_ID "ARM"
# elif defined(__ICCRX__)
# define ARCHITECTURE_ID "RX"
# elif defined(__ICCRH850__)
# define ARCHITECTURE_ID "RH850"
# elif defined(__ICCRL78__)
# define ARCHITECTURE_ID "RL78"
# elif defined(__ICCRISCV__)
# define ARCHITECTURE_ID "RISCV"
# elif defined(__ICCAVR__)
# define ARCHITECTURE_ID "AVR"
# elif defined(__ICC430__)
# define ARCHITECTURE_ID "MSP430"
# elif defined(__ICCV850__)
# define ARCHITECTURE_ID "V850"
# elif defined(__ICC8051__)
# define ARCHITECTURE_ID "8051"
# elif defined(__ICCSTM8__)
# define ARCHITECTURE_ID "STM8"
# else /* unknown architecture */
# define ARCHITECTURE_ID ""
# endif
#elif defined(__ghs__)
# if defined(__PPC64__)
# define ARCHITECTURE_ID "PPC64"
# elif defined(__ppc__)
# define ARCHITECTURE_ID "PPC"
# elif defined(__ARM__)
# define ARCHITECTURE_ID "ARM"
# elif defined(__x86_64__)
# define ARCHITECTURE_ID "x64"
# elif defined(__i386__)
# define ARCHITECTURE_ID "X86"
# else /* unknown architecture */
# define ARCHITECTURE_ID ""
# endif
#elif defined(__TI_COMPILER_VERSION__)
# if defined(__TI_ARM__)
# define ARCHITECTURE_ID "ARM"
# elif defined(__MSP430__)
# define ARCHITECTURE_ID "MSP430"
# elif defined(__TMS320C28XX__)
# define ARCHITECTURE_ID "TMS320C28x"
# elif defined(__TMS320C6X__) || defined(_TMS320C6X)
# define ARCHITECTURE_ID "TMS320C6x"
# else /* unknown architecture */
# define ARCHITECTURE_ID ""
# endif
#else
# define ARCHITECTURE_ID
#endif
/* Convert integer to decimal digit literals. */
#define DEC(n) \
('0' + (((n) / 10000000)%10)), \
('0' + (((n) / 1000000)%10)), \
('0' + (((n) / 100000)%10)), \
('0' + (((n) / 10000)%10)), \
('0' + (((n) / 1000)%10)), \
('0' + (((n) / 100)%10)), \
('0' + (((n) / 10)%10)), \
('0' + ((n) % 10))
/* Convert integer to hex digit literals. */
#define HEX(n) \
('0' + ((n)>>28 & 0xF)), \
('0' + ((n)>>24 & 0xF)), \
('0' + ((n)>>20 & 0xF)), \
('0' + ((n)>>16 & 0xF)), \
('0' + ((n)>>12 & 0xF)), \
('0' + ((n)>>8 & 0xF)), \
('0' + ((n)>>4 & 0xF)), \
('0' + ((n) & 0xF))
/* Construct a string literal encoding the version number components. */
#ifdef COMPILER_VERSION_MAJOR
char const info_version[] = {
'I', 'N', 'F', 'O', ':',
'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[',
COMPILER_VERSION_MAJOR,
# ifdef COMPILER_VERSION_MINOR
'.', COMPILER_VERSION_MINOR,
# ifdef COMPILER_VERSION_PATCH
'.', COMPILER_VERSION_PATCH,
# ifdef COMPILER_VERSION_TWEAK
'.', COMPILER_VERSION_TWEAK,
# endif
# endif
# endif
']','\0'};
#endif
/* Construct a string literal encoding the internal version number. */
#ifdef COMPILER_VERSION_INTERNAL
char const info_version_internal[] = {
'I', 'N', 'F', 'O', ':',
'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','_',
'i','n','t','e','r','n','a','l','[',
COMPILER_VERSION_INTERNAL,']','\0'};
#endif
/* Construct a string literal encoding the version number components. */
#ifdef SIMULATE_VERSION_MAJOR
char const info_simulate_version[] = {
'I', 'N', 'F', 'O', ':',
's','i','m','u','l','a','t','e','_','v','e','r','s','i','o','n','[',
SIMULATE_VERSION_MAJOR,
# ifdef SIMULATE_VERSION_MINOR
'.', SIMULATE_VERSION_MINOR,
# ifdef SIMULATE_VERSION_PATCH
'.', SIMULATE_VERSION_PATCH,
# ifdef SIMULATE_VERSION_TWEAK
'.', SIMULATE_VERSION_TWEAK,
# endif
# endif
# endif
']','\0'};
#endif
/* Construct the string literal in pieces to prevent the source from
getting matched. Store it in a pointer rather than an array
because some compilers will just produce instructions to fill the
array rather than assigning a pointer to a static array. */
char const* info_platform = "INFO" ":" "platform[" PLATFORM_ID "]";
char const* info_arch = "INFO" ":" "arch[" ARCHITECTURE_ID "]";
#if !defined(__STDC__)
# if (defined(_MSC_VER) && !defined(__clang__)) \
|| (defined(__ibmxl__) || defined(__IBMC__))
# define C_DIALECT "90"
# else
# define C_DIALECT
# endif
#elif __STDC_VERSION__ >= 201000L
# define C_DIALECT "11"
#elif __STDC_VERSION__ >= 199901L
# define C_DIALECT "99"
#else
# define C_DIALECT "90"
#endif
const char* info_language_dialect_default =
"INFO" ":" "dialect_default[" C_DIALECT "]";
/*--------------------------------------------------------------------------*/
#ifdef ID_VOID_MAIN
void main() {}
#else
# if defined(__CLASSIC_C__)
int main(argc, argv) int argc; char *argv[];
# else
int main(int argc, char* argv[])
# endif
{
int require = 0;
require += info_compiler[argc];
require += info_platform[argc];
require += info_arch[argc];
#ifdef COMPILER_VERSION_MAJOR
require += info_version[argc];
#endif
#ifdef COMPILER_VERSION_INTERNAL
require += info_version_internal[argc];
#endif
#ifdef SIMULATE_ID
require += info_simulate[argc];
#endif
#ifdef SIMULATE_VERSION_MAJOR
require += info_simulate_version[argc];
#endif
#if defined(__CRAYXT_COMPUTE_LINUX_TARGET)
require += info_cray[argc];
#endif
require += info_language_dialect_default[argc];
(void)argv;
return require;
}
#endif

@ -1,734 +0,0 @@
/* This source file must have a .cpp extension so that all C++ compilers
recognize the extension without flags. Borland does not know .cxx for
example. */
#ifndef __cplusplus
# error "A C compiler has been selected for C++."
#endif
/* Version number components: V=Version, R=Revision, P=Patch
Version date components: YYYY=Year, MM=Month, DD=Day */
#if defined(__COMO__)
# define COMPILER_ID "Comeau"
/* __COMO_VERSION__ = VRR */
# define COMPILER_VERSION_MAJOR DEC(__COMO_VERSION__ / 100)
# define COMPILER_VERSION_MINOR DEC(__COMO_VERSION__ % 100)
#elif defined(__INTEL_COMPILER) || defined(__ICC)
# define COMPILER_ID "Intel"
# if defined(_MSC_VER)
# define SIMULATE_ID "MSVC"
# endif
# if defined(__GNUC__)
# define SIMULATE_ID "GNU"
# endif
/* __INTEL_COMPILER = VRP */
# define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER/100)
# define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER/10 % 10)
# if defined(__INTEL_COMPILER_UPDATE)
# define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER_UPDATE)
# else
# define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER % 10)
# endif
# if defined(__INTEL_COMPILER_BUILD_DATE)
/* __INTEL_COMPILER_BUILD_DATE = YYYYMMDD */
# define COMPILER_VERSION_TWEAK DEC(__INTEL_COMPILER_BUILD_DATE)
# endif
# if defined(_MSC_VER)
/* _MSC_VER = VVRR */
# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
# endif
# if defined(__GNUC__)
# define SIMULATE_VERSION_MAJOR DEC(__GNUC__)
# elif defined(__GNUG__)
# define SIMULATE_VERSION_MAJOR DEC(__GNUG__)
# endif
# if defined(__GNUC_MINOR__)
# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__)
# endif
# if defined(__GNUC_PATCHLEVEL__)
# define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
# endif
#elif (defined(__clang__) && defined(__INTEL_CLANG_COMPILER)) || defined(__INTEL_LLVM_COMPILER)
# define COMPILER_ID "IntelLLVM"
#if defined(_MSC_VER)
# define SIMULATE_ID "MSVC"
#endif
#if defined(__GNUC__)
# define SIMULATE_ID "GNU"
#endif
/* __INTEL_LLVM_COMPILER = VVVVRP prior to 2021.2.0, VVVVRRPP for 2021.2.0 and
* later. Look for 6 digit vs. 8 digit version number to decide encoding.
* VVVV is no smaller than the current year when a versio is released.
*/
#if __INTEL_LLVM_COMPILER < 1000000L
# define COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/100)
# define COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/10 % 10)
# define COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER % 10)
#else
# define COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/10000)
# define COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/100 % 100)
# define COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER % 100)
#endif
#if defined(_MSC_VER)
/* _MSC_VER = VVRR */
# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
#endif
#if defined(__GNUC__)
# define SIMULATE_VERSION_MAJOR DEC(__GNUC__)
#elif defined(__GNUG__)
# define SIMULATE_VERSION_MAJOR DEC(__GNUG__)
#endif
#if defined(__GNUC_MINOR__)
# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__)
#endif
#if defined(__GNUC_PATCHLEVEL__)
# define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
#endif
#elif defined(__PATHCC__)
# define COMPILER_ID "PathScale"
# define COMPILER_VERSION_MAJOR DEC(__PATHCC__)
# define COMPILER_VERSION_MINOR DEC(__PATHCC_MINOR__)
# if defined(__PATHCC_PATCHLEVEL__)
# define COMPILER_VERSION_PATCH DEC(__PATHCC_PATCHLEVEL__)
# endif
#elif defined(__BORLANDC__) && defined(__CODEGEARC_VERSION__)
# define COMPILER_ID "Embarcadero"
# define COMPILER_VERSION_MAJOR HEX(__CODEGEARC_VERSION__>>24 & 0x00FF)
# define COMPILER_VERSION_MINOR HEX(__CODEGEARC_VERSION__>>16 & 0x00FF)
# define COMPILER_VERSION_PATCH DEC(__CODEGEARC_VERSION__ & 0xFFFF)
#elif defined(__BORLANDC__)
# define COMPILER_ID "Borland"
/* __BORLANDC__ = 0xVRR */
# define COMPILER_VERSION_MAJOR HEX(__BORLANDC__>>8)
# define COMPILER_VERSION_MINOR HEX(__BORLANDC__ & 0xFF)
#elif defined(__WATCOMC__) && __WATCOMC__ < 1200
# define COMPILER_ID "Watcom"
/* __WATCOMC__ = VVRR */
# define COMPILER_VERSION_MAJOR DEC(__WATCOMC__ / 100)
# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10)
# if (__WATCOMC__ % 10) > 0
# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10)
# endif
#elif defined(__WATCOMC__)
# define COMPILER_ID "OpenWatcom"
/* __WATCOMC__ = VVRP + 1100 */
# define COMPILER_VERSION_MAJOR DEC((__WATCOMC__ - 1100) / 100)
# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10)
# if (__WATCOMC__ % 10) > 0
# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10)
# endif
#elif defined(__SUNPRO_CC)
# define COMPILER_ID "SunPro"
# if __SUNPRO_CC >= 0x5100
/* __SUNPRO_CC = 0xVRRP */
# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_CC>>12)
# define COMPILER_VERSION_MINOR HEX(__SUNPRO_CC>>4 & 0xFF)
# define COMPILER_VERSION_PATCH HEX(__SUNPRO_CC & 0xF)
# else
/* __SUNPRO_CC = 0xVRP */
# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_CC>>8)
# define COMPILER_VERSION_MINOR HEX(__SUNPRO_CC>>4 & 0xF)
# define COMPILER_VERSION_PATCH HEX(__SUNPRO_CC & 0xF)
# endif
#elif defined(__HP_aCC)
# define COMPILER_ID "HP"
/* __HP_aCC = VVRRPP */
# define COMPILER_VERSION_MAJOR DEC(__HP_aCC/10000)
# define COMPILER_VERSION_MINOR DEC(__HP_aCC/100 % 100)
# define COMPILER_VERSION_PATCH DEC(__HP_aCC % 100)
#elif defined(__DECCXX)
# define COMPILER_ID "Compaq"
/* __DECCXX_VER = VVRRTPPPP */
# define COMPILER_VERSION_MAJOR DEC(__DECCXX_VER/10000000)
# define COMPILER_VERSION_MINOR DEC(__DECCXX_VER/100000 % 100)
# define COMPILER_VERSION_PATCH DEC(__DECCXX_VER % 10000)
#elif defined(__IBMCPP__) && defined(__COMPILER_VER__)
# define COMPILER_ID "zOS"
/* __IBMCPP__ = VRP */
# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100)
# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10)
# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10)
#elif defined(__ibmxl__) && defined(__clang__)
# define COMPILER_ID "XLClang"
# define COMPILER_VERSION_MAJOR DEC(__ibmxl_version__)
# define COMPILER_VERSION_MINOR DEC(__ibmxl_release__)
# define COMPILER_VERSION_PATCH DEC(__ibmxl_modification__)
# define COMPILER_VERSION_TWEAK DEC(__ibmxl_ptf_fix_level__)
#elif defined(__IBMCPP__) && !defined(__COMPILER_VER__) && __IBMCPP__ >= 800
# define COMPILER_ID "XL"
/* __IBMCPP__ = VRP */
# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100)
# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10)
# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10)
#elif defined(__IBMCPP__) && !defined(__COMPILER_VER__) && __IBMCPP__ < 800
# define COMPILER_ID "VisualAge"
/* __IBMCPP__ = VRP */
# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100)
# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10)
# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10)
#elif defined(__NVCOMPILER)
# define COMPILER_ID "NVHPC"
# define COMPILER_VERSION_MAJOR DEC(__NVCOMPILER_MAJOR__)
# define COMPILER_VERSION_MINOR DEC(__NVCOMPILER_MINOR__)
# if defined(__NVCOMPILER_PATCHLEVEL__)
# define COMPILER_VERSION_PATCH DEC(__NVCOMPILER_PATCHLEVEL__)
# endif
#elif defined(__PGI)
# define COMPILER_ID "PGI"
# define COMPILER_VERSION_MAJOR DEC(__PGIC__)
# define COMPILER_VERSION_MINOR DEC(__PGIC_MINOR__)
# if defined(__PGIC_PATCHLEVEL__)
# define COMPILER_VERSION_PATCH DEC(__PGIC_PATCHLEVEL__)
# endif
#elif defined(_CRAYC)
# define COMPILER_ID "Cray"
# define COMPILER_VERSION_MAJOR DEC(_RELEASE_MAJOR)
# define COMPILER_VERSION_MINOR DEC(_RELEASE_MINOR)
#elif defined(__TI_COMPILER_VERSION__)
# define COMPILER_ID "TI"
/* __TI_COMPILER_VERSION__ = VVVRRRPPP */
# define COMPILER_VERSION_MAJOR DEC(__TI_COMPILER_VERSION__/1000000)
# define COMPILER_VERSION_MINOR DEC(__TI_COMPILER_VERSION__/1000 % 1000)
# define COMPILER_VERSION_PATCH DEC(__TI_COMPILER_VERSION__ % 1000)
#elif defined(__FUJITSU) || defined(__FCC_VERSION) || defined(__fcc_version)
# define COMPILER_ID "Fujitsu"
#elif defined(__ghs__)
# define COMPILER_ID "GHS"
/* __GHS_VERSION_NUMBER = VVVVRP */
# ifdef __GHS_VERSION_NUMBER
# define COMPILER_VERSION_MAJOR DEC(__GHS_VERSION_NUMBER / 100)
# define COMPILER_VERSION_MINOR DEC(__GHS_VERSION_NUMBER / 10 % 10)
# define COMPILER_VERSION_PATCH DEC(__GHS_VERSION_NUMBER % 10)
# endif
#elif defined(__SCO_VERSION__)
# define COMPILER_ID "SCO"
#elif defined(__ARMCC_VERSION) && !defined(__clang__)
# define COMPILER_ID "ARMCC"
#if __ARMCC_VERSION >= 1000000
/* __ARMCC_VERSION = VRRPPPP */
# define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/1000000)
# define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 100)
# define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000)
#else
/* __ARMCC_VERSION = VRPPPP */
# define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/100000)
# define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 10)
# define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000)
#endif
#elif defined(__clang__) && defined(__apple_build_version__)
# define COMPILER_ID "AppleClang"
# if defined(_MSC_VER)
# define SIMULATE_ID "MSVC"
# endif
# define COMPILER_VERSION_MAJOR DEC(__clang_major__)
# define COMPILER_VERSION_MINOR DEC(__clang_minor__)
# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__)
# if defined(_MSC_VER)
/* _MSC_VER = VVRR */
# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
# endif
# define COMPILER_VERSION_TWEAK DEC(__apple_build_version__)
#elif defined(__clang__) && defined(__ARMCOMPILER_VERSION)
# define COMPILER_ID "ARMClang"
# define COMPILER_VERSION_MAJOR DEC(__ARMCOMPILER_VERSION/1000000)
# define COMPILER_VERSION_MINOR DEC(__ARMCOMPILER_VERSION/10000 % 100)
# define COMPILER_VERSION_PATCH DEC(__ARMCOMPILER_VERSION % 10000)
# define COMPILER_VERSION_INTERNAL DEC(__ARMCOMPILER_VERSION)
#elif defined(__clang__)
# define COMPILER_ID "Clang"
# if defined(_MSC_VER)
# define SIMULATE_ID "MSVC"
# endif
# define COMPILER_VERSION_MAJOR DEC(__clang_major__)
# define COMPILER_VERSION_MINOR DEC(__clang_minor__)
# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__)
# if defined(_MSC_VER)
/* _MSC_VER = VVRR */
# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
# endif
#elif defined(__GNUC__) || defined(__GNUG__)
# define COMPILER_ID "GNU"
# if defined(__GNUC__)
# define COMPILER_VERSION_MAJOR DEC(__GNUC__)
# else
# define COMPILER_VERSION_MAJOR DEC(__GNUG__)
# endif
# if defined(__GNUC_MINOR__)
# define COMPILER_VERSION_MINOR DEC(__GNUC_MINOR__)
# endif
# if defined(__GNUC_PATCHLEVEL__)
# define COMPILER_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
# endif
#elif defined(_MSC_VER)
# define COMPILER_ID "MSVC"
/* _MSC_VER = VVRR */
# define COMPILER_VERSION_MAJOR DEC(_MSC_VER / 100)
# define COMPILER_VERSION_MINOR DEC(_MSC_VER % 100)
# if defined(_MSC_FULL_VER)
# if _MSC_VER >= 1400
/* _MSC_FULL_VER = VVRRPPPPP */
# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 100000)
# else
/* _MSC_FULL_VER = VVRRPPPP */
# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 10000)
# endif
# endif
# if defined(_MSC_BUILD)
# define COMPILER_VERSION_TWEAK DEC(_MSC_BUILD)
# endif
#elif defined(__VISUALDSPVERSION__) || defined(__ADSPBLACKFIN__) || defined(__ADSPTS__) || defined(__ADSP21000__)
# define COMPILER_ID "ADSP"
#if defined(__VISUALDSPVERSION__)
/* __VISUALDSPVERSION__ = 0xVVRRPP00 */
# define COMPILER_VERSION_MAJOR HEX(__VISUALDSPVERSION__>>24)
# define COMPILER_VERSION_MINOR HEX(__VISUALDSPVERSION__>>16 & 0xFF)
# define COMPILER_VERSION_PATCH HEX(__VISUALDSPVERSION__>>8 & 0xFF)
#endif
#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC)
# define COMPILER_ID "IAR"
# if defined(__VER__) && defined(__ICCARM__)
# define COMPILER_VERSION_MAJOR DEC((__VER__) / 1000000)
# define COMPILER_VERSION_MINOR DEC(((__VER__) / 1000) % 1000)
# define COMPILER_VERSION_PATCH DEC((__VER__) % 1000)
# define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__)
# elif defined(__VER__) && (defined(__ICCAVR__) || defined(__ICCRX__) || defined(__ICCRH850__) || defined(__ICCRL78__) || defined(__ICC430__) || defined(__ICCRISCV__) || defined(__ICCV850__) || defined(__ICC8051__) || defined(__ICCSTM8__))
# define COMPILER_VERSION_MAJOR DEC((__VER__) / 100)
# define COMPILER_VERSION_MINOR DEC((__VER__) - (((__VER__) / 100)*100))
# define COMPILER_VERSION_PATCH DEC(__SUBVERSION__)
# define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__)
# endif
/* These compilers are either not known or too old to define an
identification macro. Try to identify the platform and guess that
it is the native compiler. */
#elif defined(__hpux) || defined(__hpua)
# define COMPILER_ID "HP"
#else /* unknown compiler */
# define COMPILER_ID ""
#endif
/* Construct the string literal in pieces to prevent the source from
getting matched. Store it in a pointer rather than an array
because some compilers will just produce instructions to fill the
array rather than assigning a pointer to a static array. */
char const* info_compiler = "INFO" ":" "compiler[" COMPILER_ID "]";
#ifdef SIMULATE_ID
char const* info_simulate = "INFO" ":" "simulate[" SIMULATE_ID "]";
#endif
#ifdef __QNXNTO__
char const* qnxnto = "INFO" ":" "qnxnto[]";
#endif
#if defined(__CRAYXT_COMPUTE_LINUX_TARGET)
char const *info_cray = "INFO" ":" "compiler_wrapper[CrayPrgEnv]";
#endif
#define STRINGIFY_HELPER(X) #X
#define STRINGIFY(X) STRINGIFY_HELPER(X)
/* Identify known platforms by name. */
#if defined(__linux) || defined(__linux__) || defined(linux)
# define PLATFORM_ID "Linux"
#elif defined(__CYGWIN__)
# define PLATFORM_ID "Cygwin"
#elif defined(__MINGW32__)
# define PLATFORM_ID "MinGW"
#elif defined(__APPLE__)
# define PLATFORM_ID "Darwin"
#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
# define PLATFORM_ID "Windows"
#elif defined(__FreeBSD__) || defined(__FreeBSD)
# define PLATFORM_ID "FreeBSD"
#elif defined(__NetBSD__) || defined(__NetBSD)
# define PLATFORM_ID "NetBSD"
#elif defined(__OpenBSD__) || defined(__OPENBSD)
# define PLATFORM_ID "OpenBSD"
#elif defined(__sun) || defined(sun)
# define PLATFORM_ID "SunOS"
#elif defined(_AIX) || defined(__AIX) || defined(__AIX__) || defined(__aix) || defined(__aix__)
# define PLATFORM_ID "AIX"
#elif defined(__hpux) || defined(__hpux__)
# define PLATFORM_ID "HP-UX"
#elif defined(__HAIKU__)
# define PLATFORM_ID "Haiku"
#elif defined(__BeOS) || defined(__BEOS__) || defined(_BEOS)
# define PLATFORM_ID "BeOS"
#elif defined(__QNX__) || defined(__QNXNTO__)
# define PLATFORM_ID "QNX"
#elif defined(__tru64) || defined(_tru64) || defined(__TRU64__)
# define PLATFORM_ID "Tru64"
#elif defined(__riscos) || defined(__riscos__)
# define PLATFORM_ID "RISCos"
#elif defined(__sinix) || defined(__sinix__) || defined(__SINIX__)
# define PLATFORM_ID "SINIX"
#elif defined(__UNIX_SV__)
# define PLATFORM_ID "UNIX_SV"
#elif defined(__bsdos__)
# define PLATFORM_ID "BSDOS"
#elif defined(_MPRAS) || defined(MPRAS)
# define PLATFORM_ID "MP-RAS"
#elif defined(__osf) || defined(__osf__)
# define PLATFORM_ID "OSF1"
#elif defined(_SCO_SV) || defined(SCO_SV) || defined(sco_sv)
# define PLATFORM_ID "SCO_SV"
#elif defined(__ultrix) || defined(__ultrix__) || defined(_ULTRIX)
# define PLATFORM_ID "ULTRIX"
#elif defined(__XENIX__) || defined(_XENIX) || defined(XENIX)
# define PLATFORM_ID "Xenix"
#elif defined(__WATCOMC__)
# if defined(__LINUX__)
# define PLATFORM_ID "Linux"
# elif defined(__DOS__)
# define PLATFORM_ID "DOS"
# elif defined(__OS2__)
# define PLATFORM_ID "OS2"
# elif defined(__WINDOWS__)
# define PLATFORM_ID "Windows3x"
# elif defined(__VXWORKS__)
# define PLATFORM_ID "VxWorks"
# else /* unknown platform */
# define PLATFORM_ID
# endif
#elif defined(__INTEGRITY)
# if defined(INT_178B)
# define PLATFORM_ID "Integrity178"
# else /* regular Integrity */
# define PLATFORM_ID "Integrity"
# endif
#else /* unknown platform */
# define PLATFORM_ID
#endif
/* For windows compilers MSVC and Intel we can determine
the architecture of the compiler being used. This is because
the compilers do not have flags that can change the architecture,
but rather depend on which compiler is being used
*/
#if defined(_WIN32) && defined(_MSC_VER)
# if defined(_M_IA64)
# define ARCHITECTURE_ID "IA64"
# elif defined(_M_ARM64EC)
# define ARCHITECTURE_ID "ARM64EC"
# elif defined(_M_X64) || defined(_M_AMD64)
# define ARCHITECTURE_ID "x64"
# elif defined(_M_IX86)
# define ARCHITECTURE_ID "X86"
# elif defined(_M_ARM64)
# define ARCHITECTURE_ID "ARM64"
# elif defined(_M_ARM)
# if _M_ARM == 4
# define ARCHITECTURE_ID "ARMV4I"
# elif _M_ARM == 5
# define ARCHITECTURE_ID "ARMV5I"
# else
# define ARCHITECTURE_ID "ARMV" STRINGIFY(_M_ARM)
# endif
# elif defined(_M_MIPS)
# define ARCHITECTURE_ID "MIPS"
# elif defined(_M_SH)
# define ARCHITECTURE_ID "SHx"
# else /* unknown architecture */
# define ARCHITECTURE_ID ""
# endif
#elif defined(__WATCOMC__)
# if defined(_M_I86)
# define ARCHITECTURE_ID "I86"
# elif defined(_M_IX86)
# define ARCHITECTURE_ID "X86"
# else /* unknown architecture */
# define ARCHITECTURE_ID ""
# endif
#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC)
# if defined(__ICCARM__)
# define ARCHITECTURE_ID "ARM"
# elif defined(__ICCRX__)
# define ARCHITECTURE_ID "RX"
# elif defined(__ICCRH850__)
# define ARCHITECTURE_ID "RH850"
# elif defined(__ICCRL78__)
# define ARCHITECTURE_ID "RL78"
# elif defined(__ICCRISCV__)
# define ARCHITECTURE_ID "RISCV"
# elif defined(__ICCAVR__)
# define ARCHITECTURE_ID "AVR"
# elif defined(__ICC430__)
# define ARCHITECTURE_ID "MSP430"
# elif defined(__ICCV850__)
# define ARCHITECTURE_ID "V850"
# elif defined(__ICC8051__)
# define ARCHITECTURE_ID "8051"
# elif defined(__ICCSTM8__)
# define ARCHITECTURE_ID "STM8"
# else /* unknown architecture */
# define ARCHITECTURE_ID ""
# endif
#elif defined(__ghs__)
# if defined(__PPC64__)
# define ARCHITECTURE_ID "PPC64"
# elif defined(__ppc__)
# define ARCHITECTURE_ID "PPC"
# elif defined(__ARM__)
# define ARCHITECTURE_ID "ARM"
# elif defined(__x86_64__)
# define ARCHITECTURE_ID "x64"
# elif defined(__i386__)
# define ARCHITECTURE_ID "X86"
# else /* unknown architecture */
# define ARCHITECTURE_ID ""
# endif
#elif defined(__TI_COMPILER_VERSION__)
# if defined(__TI_ARM__)
# define ARCHITECTURE_ID "ARM"
# elif defined(__MSP430__)
# define ARCHITECTURE_ID "MSP430"
# elif defined(__TMS320C28XX__)
# define ARCHITECTURE_ID "TMS320C28x"
# elif defined(__TMS320C6X__) || defined(_TMS320C6X)
# define ARCHITECTURE_ID "TMS320C6x"
# else /* unknown architecture */
# define ARCHITECTURE_ID ""
# endif
#else
# define ARCHITECTURE_ID
#endif
/* Convert integer to decimal digit literals. */
#define DEC(n) \
('0' + (((n) / 10000000)%10)), \
('0' + (((n) / 1000000)%10)), \
('0' + (((n) / 100000)%10)), \
('0' + (((n) / 10000)%10)), \
('0' + (((n) / 1000)%10)), \
('0' + (((n) / 100)%10)), \
('0' + (((n) / 10)%10)), \
('0' + ((n) % 10))
/* Convert integer to hex digit literals. */
#define HEX(n) \
('0' + ((n)>>28 & 0xF)), \
('0' + ((n)>>24 & 0xF)), \
('0' + ((n)>>20 & 0xF)), \
('0' + ((n)>>16 & 0xF)), \
('0' + ((n)>>12 & 0xF)), \
('0' + ((n)>>8 & 0xF)), \
('0' + ((n)>>4 & 0xF)), \
('0' + ((n) & 0xF))
/* Construct a string literal encoding the version number components. */
#ifdef COMPILER_VERSION_MAJOR
char const info_version[] = {
'I', 'N', 'F', 'O', ':',
'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[',
COMPILER_VERSION_MAJOR,
# ifdef COMPILER_VERSION_MINOR
'.', COMPILER_VERSION_MINOR,
# ifdef COMPILER_VERSION_PATCH
'.', COMPILER_VERSION_PATCH,
# ifdef COMPILER_VERSION_TWEAK
'.', COMPILER_VERSION_TWEAK,
# endif
# endif
# endif
']','\0'};
#endif
/* Construct a string literal encoding the internal version number. */
#ifdef COMPILER_VERSION_INTERNAL
char const info_version_internal[] = {
'I', 'N', 'F', 'O', ':',
'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','_',
'i','n','t','e','r','n','a','l','[',
COMPILER_VERSION_INTERNAL,']','\0'};
#endif
/* Construct a string literal encoding the version number components. */
#ifdef SIMULATE_VERSION_MAJOR
char const info_simulate_version[] = {
'I', 'N', 'F', 'O', ':',
's','i','m','u','l','a','t','e','_','v','e','r','s','i','o','n','[',
SIMULATE_VERSION_MAJOR,
# ifdef SIMULATE_VERSION_MINOR
'.', SIMULATE_VERSION_MINOR,
# ifdef SIMULATE_VERSION_PATCH
'.', SIMULATE_VERSION_PATCH,
# ifdef SIMULATE_VERSION_TWEAK
'.', SIMULATE_VERSION_TWEAK,
# endif
# endif
# endif
']','\0'};
#endif
/* Construct the string literal in pieces to prevent the source from
getting matched. Store it in a pointer rather than an array
because some compilers will just produce instructions to fill the
array rather than assigning a pointer to a static array. */
char const* info_platform = "INFO" ":" "platform[" PLATFORM_ID "]";
char const* info_arch = "INFO" ":" "arch[" ARCHITECTURE_ID "]";
#if defined(__INTEL_COMPILER) && defined(_MSVC_LANG) && _MSVC_LANG < 201403L
# if defined(__INTEL_CXX11_MODE__)
# if defined(__cpp_aggregate_nsdmi)
# define CXX_STD 201402L
# else
# define CXX_STD 201103L
# endif
# else
# define CXX_STD 199711L
# endif
#elif defined(_MSC_VER) && defined(_MSVC_LANG)
# define CXX_STD _MSVC_LANG
#else
# define CXX_STD __cplusplus
#endif
const char* info_language_dialect_default = "INFO" ":" "dialect_default["
#if CXX_STD > 202002L
"23"
#elif CXX_STD > 201703L
"20"
#elif CXX_STD >= 201703L
"17"
#elif CXX_STD >= 201402L
"14"
#elif CXX_STD >= 201103L
"11"
#else
"98"
#endif
"]";
/*--------------------------------------------------------------------------*/
int main(int argc, char* argv[])
{
int require = 0;
require += info_compiler[argc];
require += info_platform[argc];
#ifdef COMPILER_VERSION_MAJOR
require += info_version[argc];
#endif
#ifdef COMPILER_VERSION_INTERNAL
require += info_version_internal[argc];
#endif
#ifdef SIMULATE_ID
require += info_simulate[argc];
#endif
#ifdef SIMULATE_VERSION_MAJOR
require += info_simulate_version[argc];
#endif
#if defined(__CRAYXT_COMPUTE_LINUX_TARGET)
require += info_cray[argc];
#endif
require += info_language_dialect_default[argc];
(void)argv;
return require;
}

@ -1,65 +0,0 @@
The system is: Windows - 10.0.22631 - AMD64
Compiling the C compiler identification source file "CMakeCCompilerId.c" succeeded.
Compiler: D:/VS2019/VC/Tools/MSVC/14.29.30133/bin/Hostx64/x64/cl.exe
Build flags:
Id flags:
The output was:
0
用于 x64 的 Microsoft (R) C/C++ 优化编译器 19.29.30154 版
版权所有(C) Microsoft Corporation。保留所有权利。
CMakeCCompilerId.c
Microsoft (R) Incremental Linker Version 14.29.30154.0
Copyright (C) Microsoft Corporation. All rights reserved.
/out:CMakeCCompilerId.exe
CMakeCCompilerId.obj
Compilation of the C compiler identification source "CMakeCCompilerId.c" produced "CMakeCCompilerId.exe"
Compilation of the C compiler identification source "CMakeCCompilerId.c" produced "CMakeCCompilerId.obj"
The C compiler identification is MSVC, found in "C:/Users/n/Desktop/软件工程/MyTinySTL/src/MyTinySTL-master/MyTinySTL-master/out/build/x64-Debug/CMakeFiles/3.20.21032501-MSVC_2/CompilerIdC/CMakeCCompilerId.exe"
Compiling the CXX compiler identification source file "CMakeCXXCompilerId.cpp" succeeded.
Compiler: D:/VS2019/VC/Tools/MSVC/14.29.30133/bin/Hostx64/x64/cl.exe
Build flags:
Id flags:
The output was:
0
用于 x64 的 Microsoft (R) C/C++ 优化编译器 19.29.30154 版
版权所有(C) Microsoft Corporation。保留所有权利。
CMakeCXXCompilerId.cpp
Microsoft (R) Incremental Linker Version 14.29.30154.0
Copyright (C) Microsoft Corporation. All rights reserved.
/out:CMakeCXXCompilerId.exe
CMakeCXXCompilerId.obj
Compilation of the CXX compiler identification source "CMakeCXXCompilerId.cpp" produced "CMakeCXXCompilerId.exe"
Compilation of the CXX compiler identification source "CMakeCXXCompilerId.cpp" produced "CMakeCXXCompilerId.obj"
The CXX compiler identification is MSVC, found in "C:/Users/n/Desktop/软件工程/MyTinySTL/src/MyTinySTL-master/MyTinySTL-master/out/build/x64-Debug/CMakeFiles/3.20.21032501-MSVC_2/CompilerIdCXX/CMakeCXXCompilerId.exe"
Detecting C compiler ABI info compiled with the following output:
Change Dir: C:/Users/n/Desktop/软件工程/MyTinySTL/src/MyTinySTL-master/MyTinySTL-master/out/build/x64-Debug/CMakeFiles/CMakeTmp
Run Build Command(s):D:\VS2019\COMMON7\IDE\COMMONEXTENSIONS\MICROSOFT\CMAKE\Ninja\ninja.exe cmTC_4a7ce && [1/2] Building C object CMakeFiles\cmTC_4a7ce.dir\CMakeCCompilerABI.c.obj
[2/2] Linking C executable cmTC_4a7ce.exe
Detecting CXX compiler ABI info compiled with the following output:
Change Dir: C:/Users/n/Desktop/软件工程/MyTinySTL/src/MyTinySTL-master/MyTinySTL-master/out/build/x64-Debug/CMakeFiles/CMakeTmp
Run Build Command(s):D:\VS2019\COMMON7\IDE\COMMONEXTENSIONS\MICROSOFT\CMAKE\Ninja\ninja.exe cmTC_75281 && [1/2] Building CXX object CMakeFiles\cmTC_75281.dir\CMakeCXXCompilerABI.cpp.obj
[2/2] Linking CXX executable cmTC_75281.exe

@ -1,5 +0,0 @@
C:/Users/n/Desktop/软件工程/MyTinySTL/src/MyTinySTL-master/MyTinySTL-master/out/build/x64-Debug/CMakeFiles/edit_cache.dir
C:/Users/n/Desktop/软件工程/MyTinySTL/src/MyTinySTL-master/MyTinySTL-master/out/build/x64-Debug/CMakeFiles/rebuild_cache.dir
C:/Users/n/Desktop/软件工程/MyTinySTL/src/MyTinySTL-master/MyTinySTL-master/out/build/x64-Debug/Test/CMakeFiles/stltest.dir
C:/Users/n/Desktop/软件工程/MyTinySTL/src/MyTinySTL-master/MyTinySTL-master/out/build/x64-Debug/Test/CMakeFiles/edit_cache.dir
C:/Users/n/Desktop/软件工程/MyTinySTL/src/MyTinySTL-master/MyTinySTL-master/out/build/x64-Debug/Test/CMakeFiles/rebuild_cache.dir

@ -1 +0,0 @@
# This file is generated by cmake for dependency checking of the CMakeCache.txt file

@ -1,69 +0,0 @@
# CMAKE generated file: DO NOT EDIT!
# Generated by "Ninja" Generator, CMake Version 3.20
# This file contains all the rules used to get the outputs files
# built from the input files.
# It is included in the main 'build.ninja'.
# =============================================================================
# Project: MyTinySTL
# Configurations: release
# =============================================================================
# =============================================================================
#############################################
# localized /showIncludes string
msvc_deps_prefix = 娉ㄦ剰: 鍖呭惈鏂囦欢:
#############################################
# Rule for running custom commands.
rule CUSTOM_COMMAND
command = $COMMAND
description = $DESC
#############################################
# Rule for compiling CXX files.
rule CXX_COMPILER__stltest_release
deps = msvc
command = D:\VS2019\VC\Tools\MSVC\14.29.30133\bin\Hostx64\x64\cl.exe /nologo /TP $DEFINES $INCLUDES $FLAGS /showIncludes /Fo$out /Fd$TARGET_COMPILE_PDB /FS -c $in
description = Building CXX object $out
#############################################
# Rule for linking CXX executable.
rule CXX_EXECUTABLE_LINKER__stltest_release
command = cmd.exe /C "$PRE_LINK && D:\VS2019\Common7\IDE\CommonExtensions\Microsoft\CMake\CMake\bin\cmake.exe -E vs_link_exe --intdir=$OBJECT_DIR --rc=C:\PROGRA~2\WI3CF2~1\10\bin\100190~1.0\x64\rc.exe --mt=C:\PROGRA~2\WI3CF2~1\10\bin\100190~1.0\x64\mt.exe --manifests $MANIFESTS -- D:\VS2019\VC\Tools\MSVC\14.29.30133\bin\Hostx64\x64\link.exe /nologo $in /out:$TARGET_FILE /implib:$TARGET_IMPLIB /pdb:$TARGET_PDB /version:0.0 $LINK_FLAGS $LINK_PATH $LINK_LIBRARIES && $POST_BUILD"
description = Linking CXX executable $TARGET_FILE
restat = $RESTAT
#############################################
# Rule for re-running cmake.
rule RERUN_CMAKE
command = D:\VS2019\Common7\IDE\CommonExtensions\Microsoft\CMake\CMake\bin\cmake.exe --regenerate-during-build -SC:\Users\n\Desktop\软件工程\MyTinySTL\src\MyTinySTL-master\MyTinySTL-master -BC:\Users\n\Desktop\软件工程\MyTinySTL\src\MyTinySTL-master\MyTinySTL-master\out\build\x64-Debug
description = Re-running CMake...
generator = 1
#############################################
# Rule for cleaning all built files.
rule CLEAN
command = D:\VS2019\COMMON7\IDE\COMMONEXTENSIONS\MICROSOFT\CMAKE\Ninja\ninja.exe $FILE_ARG -t clean $TARGETS
description = Cleaning all built files...
#############################################
# Rule for printing all primary targets available.
rule HELP
command = D:\VS2019\COMMON7\IDE\COMMONEXTENSIONS\MICROSOFT\CMAKE\Ninja\ninja.exe -t targets
description = All primary targets available:

@ -1,34 +0,0 @@
# Install script for directory: C:/Users/n/Desktop//MyTinySTL/src/MyTinySTL-master/MyTinySTL-master/Test
# Set the install prefix
if(NOT DEFINED CMAKE_INSTALL_PREFIX)
set(CMAKE_INSTALL_PREFIX "C:/Users/n/Desktop/软件工程/MyTinySTL/src/MyTinySTL-master/MyTinySTL-master/out/install/x64-Debug")
endif()
string(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
# Set the install configuration name.
if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME)
if(BUILD_TYPE)
string(REGEX REPLACE "^[^A-Za-z0-9_]+" ""
CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}")
else()
set(CMAKE_INSTALL_CONFIG_NAME "release")
endif()
message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"")
endif()
# Set the component getting installed.
if(NOT CMAKE_INSTALL_COMPONENT)
if(COMPONENT)
message(STATUS "Install component: \"${COMPONENT}\"")
set(CMAKE_INSTALL_COMPONENT "${COMPONENT}")
else()
set(CMAKE_INSTALL_COMPONENT)
endif()
endif()
# Is this installation the result of a crosscompile?
if(NOT DEFINED CMAKE_CROSSCOMPILING)
set(CMAKE_CROSSCOMPILING "FALSE")
endif()

@ -1,3 +0,0 @@
Start testing: Dec 16 21:13 中国标准时间
----------------------------------------------------------
End testing: Dec 16 21:13 中国标准时间

File diff suppressed because one or more lines are too long

@ -1,50 +0,0 @@
# Install script for directory: C:/Users/n/Desktop//MyTinySTL/src/MyTinySTL-master/MyTinySTL-master
# Set the install prefix
if(NOT DEFINED CMAKE_INSTALL_PREFIX)
set(CMAKE_INSTALL_PREFIX "C:/Users/n/Desktop/软件工程/MyTinySTL/src/MyTinySTL-master/MyTinySTL-master/out/install/x64-Debug")
endif()
string(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
# Set the install configuration name.
if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME)
if(BUILD_TYPE)
string(REGEX REPLACE "^[^A-Za-z0-9_]+" ""
CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}")
else()
set(CMAKE_INSTALL_CONFIG_NAME "release")
endif()
message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"")
endif()
# Set the component getting installed.
if(NOT CMAKE_INSTALL_COMPONENT)
if(COMPONENT)
message(STATUS "Install component: \"${COMPONENT}\"")
set(CMAKE_INSTALL_COMPONENT "${COMPONENT}")
else()
set(CMAKE_INSTALL_COMPONENT)
endif()
endif()
# Is this installation the result of a crosscompile?
if(NOT DEFINED CMAKE_CROSSCOMPILING)
set(CMAKE_CROSSCOMPILING "FALSE")
endif()
if(NOT CMAKE_INSTALL_LOCAL_ONLY)
# Include the install script for each subdirectory.
include("C:/Users/n/Desktop/软件工程/MyTinySTL/src/MyTinySTL-master/MyTinySTL-master/out/build/x64-Debug/Test/cmake_install.cmake")
endif()
if(CMAKE_INSTALL_COMPONENT)
set(CMAKE_INSTALL_MANIFEST "install_manifest_${CMAKE_INSTALL_COMPONENT}.txt")
else()
set(CMAKE_INSTALL_MANIFEST "install_manifest.txt")
endif()
string(REPLACE ";" "\n" CMAKE_INSTALL_MANIFEST_CONTENT
"${CMAKE_INSTALL_MANIFEST_FILES}")
file(WRITE "C:/Users/n/Desktop/软件工程/MyTinySTL/src/MyTinySTL-master/MyTinySTL-master/out/build/x64-Debug/${CMAKE_INSTALL_MANIFEST}"
"${CMAKE_INSTALL_MANIFEST_CONTENT}")

File diff suppressed because it is too large Load Diff

@ -1,520 +0,0 @@
#ifndef MYTINYSTL_ALGOBASE_H_
#define MYTINYSTL_ALGOBASE_H_
// 这个头文件包含了 mystl 的基本算法
#include <cstring>
#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 <class T>
const T& max(const T& lhs, const T& rhs)
{
return lhs < rhs ? rhs : lhs;
}
// 重载版本使用函数对象 comp 代替比较操作
template <class T, class Compare>
const T& max(const T& lhs, const T& rhs, Compare comp)
{
return comp(lhs, rhs) ? rhs : lhs;
}
/*****************************************************************************************/
// min
// 取二者中的较小值,语义相等时保证返回第一个参数
/*****************************************************************************************/
template <class T>
const T& min(const T& lhs, const T& rhs)
{
return rhs < lhs ? rhs : lhs;
}
// 重载版本使用函数对象 comp 代替比较操作
template <class T, class Compare>
const T& min(const T& lhs, const T& rhs, Compare comp)
{
return comp(rhs, lhs) ? rhs : lhs;
}
/*****************************************************************************************/
// iter_swap
// 将两个迭代器所指对象对调
/*****************************************************************************************/
template <class FIter1, class FIter2>
void iter_swap(FIter1 lhs, FIter2 rhs)
{
mystl::swap(*lhs, *rhs);
}
/*****************************************************************************************/
// copy
// 把 [first, last)区间内的元素拷贝到 [result, result + (last - first))内
/*****************************************************************************************/
// input_iterator_tag 版本
template <class InputIter, class OutputIter>
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 <class RandomIter, class OutputIter>
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 <class InputIter, class OutputIter>
OutputIter
unchecked_copy(InputIter first, InputIter last, OutputIter result)
{
return unchecked_copy_cat(first, last, result, iterator_category(first));
}
// 为 trivially_copy_assignable 类型提供特化版本
template <class Tp, class Up>
typename std::enable_if<
std::is_same<typename std::remove_const<Tp>::type, Up>::value &&
std::is_trivially_copy_assignable<Up>::value,
Up*>::type
unchecked_copy(Tp* first, Tp* last, Up* result)
{
const auto n = static_cast<size_t>(last - first);
if (n != 0)
std::memmove(result, first, n * sizeof(Up));
return result + n;
}
template <class InputIter, class OutputIter>
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 <class BidirectionalIter1, class BidirectionalIter2>
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 <class RandomIter1, class BidirectionalIter2>
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 <class BidirectionalIter1, class BidirectionalIter2>
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 <class Tp, class Up>
typename std::enable_if<
std::is_same<typename std::remove_const<Tp>::type, Up>::value &&
std::is_trivially_copy_assignable<Up>::value,
Up*>::type
unchecked_copy_backward(Tp* first, Tp* last, Up* result)
{
const auto n = static_cast<size_t>(last - first);
if (n != 0)
{
result -= n;
std::memmove(result, first, n * sizeof(Up));
}
return result;
}
template <class BidirectionalIter1, class BidirectionalIter2>
BidirectionalIter2
copy_backward(BidirectionalIter1 first, BidirectionalIter1 last, BidirectionalIter2 result)
{
return unchecked_copy_backward(first, last, result);
}
/*****************************************************************************************/
// copy_if
// 把[first, last)内满足一元操作 unary_pred 的元素拷贝到以 result 为起始的位置上
/*****************************************************************************************/
template <class InputIter, class OutputIter, class UnaryPredicate>
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 <class InputIter, class Size, class OutputIter>
mystl::pair<InputIter, OutputIter>
unchecked_copy_n(InputIter first, Size n, OutputIter result, mystl::input_iterator_tag)
{
for (; n > 0; --n, ++first, ++result)
{
*result = *first;
}
return mystl::pair<InputIter, OutputIter>(first, result);
}
template <class RandomIter, class Size, class OutputIter>
mystl::pair<RandomIter, OutputIter>
unchecked_copy_n(RandomIter first, Size n, OutputIter result,
mystl::random_access_iterator_tag)
{
auto last = first + n;
return mystl::pair<RandomIter, OutputIter>(last, mystl::copy(first, last, result));
}
template <class InputIter, class Size, class OutputIter>
mystl::pair<InputIter, OutputIter>
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 <class InputIter, class OutputIter>
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 <class RandomIter, class OutputIter>
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 <class InputIter, class OutputIter>
OutputIter
unchecked_move(InputIter first, InputIter last, OutputIter result)
{
return unchecked_move_cat(first, last, result, iterator_category(first));
}
// 为 trivially_copy_assignable 类型提供特化版本
template <class Tp, class Up>
typename std::enable_if<
std::is_same<typename std::remove_const<Tp>::type, Up>::value &&
std::is_trivially_move_assignable<Up>::value,
Up*>::type
unchecked_move(Tp* first, Tp* last, Up* result)
{
const size_t n = static_cast<size_t>(last - first);
if (n != 0)
std::memmove(result, first, n * sizeof(Up));
return result + n;
}
template <class InputIter, class OutputIter>
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 <class BidirectionalIter1, class BidirectionalIter2>
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 <class RandomIter1, class RandomIter2>
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 <class BidirectionalIter1, class BidirectionalIter2>
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 <class Tp, class Up>
typename std::enable_if<
std::is_same<typename std::remove_const<Tp>::type, Up>::value &&
std::is_trivially_move_assignable<Up>::value,
Up*>::type
unchecked_move_backward(Tp* first, Tp* last, Up* result)
{
const size_t n = static_cast<size_t>(last - first);
if (n != 0)
{
result -= n;
std::memmove(result, first, n * sizeof(Up));
}
return result;
}
template <class BidirectionalIter1, class BidirectionalIter2>
BidirectionalIter2
move_backward(BidirectionalIter1 first, BidirectionalIter1 last, BidirectionalIter2 result)
{
return unchecked_move_backward(first, last, result);
}
/*****************************************************************************************/
// equal
// 比较第一序列在 [first, last)区间上的元素值是否和第二序列相等
/*****************************************************************************************/
template <class InputIter1, class InputIter2>
bool equal(InputIter1 first1, InputIter1 last1, InputIter2 first2)
{
for (; first1 != last1; ++first1, ++first2)
{
if (*first1 != *first2)
return false;
}
return true;
}
// 重载版本使用函数对象 comp 代替比较操作
template <class InputIter1, class InputIter2, class Compared>
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 <class OutputIter, class Size, class T>
OutputIter unchecked_fill_n(OutputIter first, Size n, const T& value)
{
for (; n > 0; --n, ++first)
{
*first = value;
}
return first;
}
// 为 one-byte 类型提供特化版本
template <class Tp, class Size, class Up>
typename std::enable_if<
std::is_integral<Tp>::value && sizeof(Tp) == 1 &&
!std::is_same<Tp, bool>::value &&
std::is_integral<Up>::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 <class OutputIter, class Size, class T>
OutputIter fill_n(OutputIter first, Size n, const T& value)
{
return unchecked_fill_n(first, n, value);
}
/*****************************************************************************************/
// fill
// 为 [first, last)区间内的所有元素填充新值
/*****************************************************************************************/
template <class ForwardIter, class T>
void fill_cat(ForwardIter first, ForwardIter last, const T& value,
mystl::forward_iterator_tag)
{
for (; first != last; ++first)
{
*first = value;
}
}
template <class RandomIter, class T>
void fill_cat(RandomIter first, RandomIter last, const T& value,
mystl::random_access_iterator_tag)
{
fill_n(first, last - first, value);
}
template <class ForwardIter, class T>
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 <class InputIter1, class InputIter2>
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 <class InputIter1, class InputIter2, class Compred>
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 <class InputIter1, class InputIter2>
mystl::pair<InputIter1, InputIter2>
mismatch(InputIter1 first1, InputIter1 last1, InputIter2 first2)
{
while (first1 != last1 && *first1 == *first2)
{
++first1;
++first2;
}
return mystl::pair<InputIter1, InputIter2>(first1, first2);
}
// 重载版本使用函数对象 comp 代替比较操作
template <class InputIter1, class InputIter2, class Compred>
mystl::pair<InputIter1, InputIter2>
mismatch(InputIter1 first1, InputIter1 last1, InputIter2 first2, Compred comp)
{
while (first1 != last1 && comp(*first1, *first2))
{
++first1;
++first2;
}
return mystl::pair<InputIter1, InputIter2>(first1, first2);
}
} // namespace mystl
#endif // !MYTINYSTL_ALGOBASE_H_

@ -1,18 +0,0 @@
#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_

@ -1,264 +0,0 @@
#ifndef MYTINYSTL_ALLOC_H_
#define MYTINYSTL_ALLOC_H_
// 这个头文件包含一个类 alloc用于分配和回收内存以内存池的方式实现
//
// 从 v2.0.0 版本开始,将不再使用内存池,这个文件将被弃用,但暂时保留
//
// 注意!!!
// 我知道这个文件里很多实现是错的,这是很久很久前写的了,后面已经不用这个东西了,
// 所以我也没再维护有诸多问题已经有人在issue中都提了free_list的修改
// 指针作为参数时没实际修改到原指针,等等。相信会看这么仔细的,大部分都是
// 初学C++的朋友,大佬都不会看这些玩具了,所以其中的错误,就留给对内存池实现
// 感兴趣的朋友去修改啦!
#include <new>
#include <cstddef>
#include <cstdio>
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<size_t>(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<size_t>(ESmallObjectBytes))
{
std::free(p);
return;
}
FreeList* q = reinterpret_cast<FreeList*>(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_

@ -1,113 +0,0 @@
#ifndef MYTINYSTL_ALLOCATOR_H_
#define MYTINYSTL_ALLOCATOR_H_
// 这个头文件包含一个模板类 allocator用于管理内存的分配、释放对象的构造、析构
#include "construct.h"
#include "util.h"
namespace mystl
{
// 模板类allocator
// 模板函数代表数据类型
template <class T>
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 <class... Args>
static void construct(T* ptr, Args&& ...args);
static void destroy(T* ptr);
static void destroy(T* first, T* last);
};
template <class T>
T* allocator<T>::allocate()
{
return static_cast<T*>(::operator new(sizeof(T)));
}
template <class T>
T* allocator<T>::allocate(size_type n)
{
if (n == 0)
return nullptr;
return static_cast<T*>(::operator new(n * sizeof(T)));
}
template <class T>
void allocator<T>::deallocate(T* ptr)
{
if (ptr == nullptr)
return;
::operator delete(ptr);
}
template <class T>
void allocator<T>::deallocate(T* ptr, size_type /*size*/)
{
if (ptr == nullptr)
return;
::operator delete(ptr);
}
template <class T>
void allocator<T>::construct(T* ptr)
{
mystl::construct(ptr);
}
template <class T>
void allocator<T>::construct(T* ptr, const T& value)
{
mystl::construct(ptr, value);
}
template <class T>
void allocator<T>::construct(T* ptr, T&& value)
{
mystl::construct(ptr, mystl::move(value));
}
template <class T>
template <class ...Args>
void allocator<T>::construct(T* ptr, Args&& ...args)
{
mystl::construct(ptr, mystl::forward<Args>(args)...);
}
template <class T>
void allocator<T>::destroy(T* ptr)
{
mystl::destroy(ptr);
}
template <class T>
void allocator<T>::destroy(T* first, T* last)
{
mystl::destroy(first, last);
}
} // namespace mystl
#endif // !MYTINYSTL_ALLOCATOR_H_

@ -1,18 +0,0 @@
#ifndef MYTINYSTL_ASTRING_H_
#define MYTINYSTL_ASTRING_H_
// 定义了 string, wstring, u16string, u32string 类型
#include "basic_string.h"
namespace mystl
{
using string = mystl::basic_string<char>;
using wstring = mystl::basic_string<wchar_t>;
using u16string = mystl::basic_string<char16_t>;
using u32string = mystl::basic_string<char32_t>;
}
#endif // !MYTINYSTL_ASTRING_H_

File diff suppressed because it is too large Load Diff

@ -1,85 +0,0 @@
#ifndef MYTINYSTL_CONSTRUCT_H_
#define MYTINYSTL_CONSTRUCT_H_
// 这个头文件包含两个函数 constructdestroy
// construct : 负责对象的构造
// destroy : 负责对象的析构
#include <new>
#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 <class Ty>
void construct(Ty* ptr)
{
::new ((void*)ptr) Ty();
}
template <class Ty1, class Ty2>
void construct(Ty1* ptr, const Ty2& value)
{
::new ((void*)ptr) Ty1(value);
}
template <class Ty, class... Args>
void construct(Ty* ptr, Args&&... args)
{
::new ((void*)ptr) Ty(mystl::forward<Args>(args)...);
}
// destroy 将对象析构
template <class Ty>
void destroy_one(Ty*, std::true_type) {}
template <class Ty>
void destroy_one(Ty* pointer, std::false_type)
{
if (pointer != nullptr)
{
pointer->~Ty();
}
}
template <class ForwardIter>
void destroy_cat(ForwardIter , ForwardIter , std::true_type) {}
template <class ForwardIter>
void destroy_cat(ForwardIter first, ForwardIter last, std::false_type)
{
for (; first != last; ++first)
destroy(&*first);
}
template <class Ty>
void destroy(Ty* pointer)
{
destroy_one(pointer, std::is_trivially_destructible<Ty>{});
}
template <class ForwardIter>
void destroy(ForwardIter first, ForwardIter last)
{
destroy_cat(first, last, std::is_trivially_destructible<
typename iterator_traits<ForwardIter>::value_type>{});
}
} // namespace mystl
#ifdef _MSC_VER
#pragma warning(pop)
#endif // _MSC_VER
#endif // !MYTINYSTL_CONSTRUCT_H_

File diff suppressed because it is too large Load Diff

@ -1,26 +0,0 @@
#ifndef MYTINYSTL_EXCEPTDEF_H_
#define MYTINYSTL_EXCEPTDEF_H_
#include <stdexcept>
#include <cassert>
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_

@ -1,336 +0,0 @@
#ifndef MYTINYSTL_FUNCTIONAL_H_
// 定义一个宏,防止头文件被重复包含
#define MYTINYSTL_FUNCTIONAL_H_
// 定义宏结束
#include <cstddef>
// 包含标准库中的 cstddef 头文件,用于定义 size_t 等类型
namespace mystl
{
// 定义一个命名空间 mystl用于封装自定义的函数对象等
template <class Arg, class Result>
struct unarg_function
{
typedef Arg argument_type;
// 定义一个类型别名 argument_type表示单参数函数对象的参数类型
typedef Result result_type;
// 定义一个类型别名 result_type表示单参数函数对象的结果类型
};
// 定义一个模板结构体 unarg_function用于表示单参数函数对象的类型特征
template <class Arg1, class Arg2, class Result>
struct binary_function
{
typedef Arg1 first_argument_type;
// 定义一个类型别名 first_argument_type表示二元函数对象的第一个参数类型
typedef Arg2 second_argument_type;
// 定义一个类型别名 second_argument_type表示二元函数对象的第二个参数类型
typedef Result result_type;
// 定义一个类型别名 result_type表示二元函数对象的结果类型
};
// 定义一个模板结构体 binary_function用于表示二元函数对象的类型特征
template <class T>
struct plus :public binary_function<T, T, T>
{
T operator()(const T& x, const T& y) const { return x + y; }
// 定义一个模板结构体 plus继承自 binary_function重载 operator() 实现加法操作
};
// 定义一个模板结构体 plus表示加法函数对象
template <class T>
struct minus :public binary_function<T, T, T>
{
T operator()(const T& x, const T& y) const { return x - y; }
// 定义一个模板结构体 minus继承自 binary_function重载 operator() 实现减法操作
};
// 定义一个模板结构体 minus表示减法函数对象
template <class T>
struct multiplies :public binary_function<T, T, T>
{
T operator()(const T& x, const T& y) const { return x * y; }
// 定义一个模板结构体 multiplies继承自 binary_function重载 operator() 实现乘法操作
};
// 定义一个模板结构体 multiplies表示乘法函数对象
template <class T>
struct divides :public binary_function<T, T, T>
{
T operator()(const T& x, const T& y) const { return x / y; }
// 定义一个模板结构体 divides继承自 binary_function重载 operator() 实现除法操作
};
// 定义一个模板结构体 divides表示除法函数对象
template <class T>
struct modulus :public binary_function<T, T, T>
{
T operator()(const T& x, const T& y) const { return x % y; }
// 定义一个模板结构体 modulus继承自 binary_function重载 operator() 实现取模操作
};
// 定义一个模板结构体 modulus表示取模函数对象
template <class T>
struct negate :public unarg_function<T, T>
{
T operator()(const T& x) const { return -x; }
// 定义一个模板结构体 negate继承自 unarg_function重载 operator() 实现取反操作
};
// 定义一个模板结构体 negate表示取反函数对象
template <class T>
T identity_element(plus<T>) { return T(0); }
// 定义一个模板函数 identity_element用于返回加法函数对象的单位元0
template <class T>
T identity_element(multiplies<T>) { return T(1); }
// 定义一个模板函数 identity_element用于返回乘法函数对象的单位元1
template <class T>
struct equal_to :public binary_function<T, T, bool>
{
bool operator()(const T& x, const T& y) const { return x == y; }
// 定义一个模板结构体 equal_to继承自 binary_function重载 operator() 实现等于比较
};
// 定义一个模板结构体 equal_to表示等于比较函数对象
template <class T>
struct not_equal_to :public binary_function<T, T, bool>
{
bool operator()(const T& x, const T& y) const { return x != y; }
// 定义一个模板结构体 not_equal_to继承自 binary_function重载 operator() 实现不等于比较
};
// 定义一个模板结构体 not_equal_to表示不等于比较函数对象
template <class T>
struct greater :public binary_function<T, T, bool>
{
bool operator()(const T& x, const T& y) const { return x > y; }
// 定义一个模板结构体 greater继承自 binary_function重载 operator() 实现大于比较
};
// 定义一个模板结构体 greater表示大于比较函数对象
template <class T>
struct less :public binary_function<T, T, bool>
{
bool operator()(const T& x, const T& y) const { return x < y; }
// 定义一个模板结构体 less继承自 binary_function重载 operator() 实现小于比较
};
// 定义一个模板结构体 less表示小于比较函数对象
template <class T>
struct greater_equal :public binary_function<T, T, bool>
{
bool operator()(const T& x, const T& y) const { return x >= y; }
// 定义一个模板结构体 greater_equal继承自 binary_function重载 operator() 实现大于等于比较
};
// 定义一个模板结构体 greater_equal表示大于等于比较函数对象
template <class T>
struct less_equal :public binary_function<T, T, bool>
{
bool operator()(const T& x, const T& y) const { return x <= y; }
// 定义一个模板结构体 less_equal继承自 binary_function重载 operator() 实现小于等于比较
};
// 定义一个模板结构体 less_equal表示小于等于比较函数对象
template <class T>
struct logical_and :public binary_function<T, T, bool>
{
bool operator()(const T& x, const T& y) const { return x && y; }
// 定义一个模板结构体 logical_and继承自 binary_function重载 operator() 实现逻辑与操作
};
// 定义一个模板结构体 logical_and表示逻辑与函数对象
template <class T>
struct logical_or :public binary_function<T, T, bool>
{
bool operator()(const T& x, const T& y) const { return x || y; }
// 定义一个模板结构体 logical_or继承自 binary_function重载 operator() 实现逻辑或操作
};
// 定义一个模板结构体 logical_or表示逻辑或函数对象
template <class T>
struct logical_not :public unarg_function<T, bool>
{
bool operator()(const T& x) const { return !x; }
// 定义一个模板结构体 logical_not继承自 unarg_function重载 operator() 实现逻辑非操作
};
// 定义一个模板结构体 logical_not表示逻辑非函数对象
template <class T>
struct identity :public unarg_function<T, bool>
{
const T& operator()(const T& x) const { return x; }
// 定义一个模板结构体 identity继承自 unarg_function重载 operator() 实现恒等操作
};
// 定义一个模板结构体 identity表示恒等函数对象
template <class Pair>
struct selectfirst :public unarg_function<Pair, typename Pair::first_type>
{
const typename Pair::first_type& operator()(const Pair& x) const
{
return x.first;
}
// 定义一个模板结构体 selectfirst继承自 unarg_function重载 operator() 实现选择对的第一个元素
};
// 定义一个模板结构体 selectfirst表示选择对的第一个元素的函数对象
template <class Pair>
struct selectsecond :public unarg_function<Pair, typename Pair::second_type>
{
const typename Pair::second_type& operator()(const Pair& x) const
{
return x.second;
}
// 定义一个模板结构体 selectsecond继承自 unarg_function重载 operator() 实现选择对的第二个元素
};
// 定义一个模板结构体 selectsecond表示选择对的第二个元素的函数对象
template <class Arg1, class Arg2>
struct projectfirst :public binary_function<Arg1, Arg2, Arg1>
{
Arg1 operator()(const Arg1& x, const Arg2&) const { return x; }
// 定义一个模板结构体
template <class Arg1, class Arg2>
struct projectfirst :public binary_function<Arg1, Arg2, Arg1>
{
Arg1 operator()(const Arg1& x, const Arg2&) const { return x; }
// 定义一个模板结构体 projectfirst继承自 binary_function重载 operator() 实现返回第一个参数
};
// 定义一个模板结构体 projectfirst表示返回第一个参数的函数对象
template <class Arg1, class Arg2>
struct projectsecond :public binary_function<Arg1, Arg2, Arg2>
{
Arg2 operator()(const Arg1&, const Arg2& y) const { return y; }
// 定义一个模板结构体 projectsecond继承自 binary_function重载 operator() 实现返回第二个参数
};
// 定义一个模板结构体 projectsecond表示返回第二个参数的函数对象
template <class Key>
struct hash {};
// 定义一个模板结构体 hash用于定义哈希函数的接口
template <class T>
struct hash<T*>
{
size_t operator()(T* p) const noexcept
{ return reinterpret_cast<size_t>(p); }
// 为指针类型特化 hash 结构体,重载 operator() 实现指针的哈希运算
};
// 为指针类型特化 hash 结构体
#define MYSTL_TRIVIAL_HASH_FCN(Type) \
template <> struct hash<Type> \
{ \
size_t operator()(Type val) const noexcept \
{ return static_cast<size_t>(val); } \
};
// 定义一个宏 MYSTL_TRIVIAL_HASH_FCN用于为基本类型生成简单的哈希函数
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;
}
// 定义一个函数 bitwise_hash用于计算给定字节序列的哈希值使用 FNV 哈希算法
template <>
struct hash<float>
{
size_t operator()(const float& val)
{
return val == 0.0f ? 0 : bitwise_hash((const unsigned char*)&val, sizeof(float));
}
// 为 float 类型特化 hash 结构体,重载 operator() 实现 float 的哈希运算
};
// 为 float 类型特化 hash 结构体
template <>
struct hash<double>
{
size_t operator()(const double& val)
{
return val == 0.0 ? 0 : bitwise_hash((const unsigned char*)&val, sizeof(double));
}
// 为 double 类型特化 hash 结构体,重载 operator() 实现 double 的哈希运算
};
// 为 double 类型特化 hash 结构体
template <>
struct hash<long double>
{
size_t operator()(const long double& val)
{
return val == 0.0 ? 0 : bitwise_hash((const unsigned char*)&val, sizeof(long double));
}
// 为 long double 类型特化 hash 结构体,重载 operator() 实现 long double 的哈希运算
};
// 为 long double 类型特化 hash 结构体
}
#endif
// 结束命名空间 mystl 和条件编译宏定义

File diff suppressed because it is too large Load Diff

@ -1,227 +0,0 @@
#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 <class RandomIter, class Distance, class T>
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 <class RandomIter, class Distance>
void push_heap_d(RandomIter first, RandomIter last, Distance*)
{
mystl::push_heap_aux(first, (last - first) - 1, static_cast<Distance>(0), *(last - 1));
}
template <class RandomIter>
void push_heap(RandomIter first, RandomIter last)
{ // 新元素应该已置于底部容器的最尾端
mystl::push_heap_d(first, last, distance_type(first));
}
// 重载版本使用函数对象 comp 代替比较操作
template <class RandomIter, class Distance, class T, class Compared>
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 <class RandomIter, class Compared, class Distance>
void push_heap_d(RandomIter first, RandomIter last, Distance*, Compared comp)
{
mystl::push_heap_aux(first, (last - first) - 1, static_cast<Distance>(0),
*(last - 1), comp);
}
template <class RandomIter, class Compared>
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 <class RandomIter, class T, class Distance>
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 <class RandomIter, class T, class Distance>
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<Distance>(0), last - first, value);
}
template <class RandomIter>
void pop_heap(RandomIter first, RandomIter last)
{
mystl::pop_heap_aux(first, last - 1, last - 1, *(last - 1), distance_type(first));
}
// 重载版本使用函数对象 comp 代替比较操作
template <class RandomIter, class T, class Distance, class Compared>
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 <class RandomIter, class T, class Distance, class Compared>
void pop_heap_aux(RandomIter first, RandomIter last, RandomIter result,
T value, Distance*, Compared comp)
{
*result = *first; // 先将尾指设置成首值,即尾指为欲求结果
mystl::adjust_heap(first, static_cast<Distance>(0), last - first, value, comp);
}
template <class RandomIter, class Compared>
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 <class RandomIter>
void sort_heap(RandomIter first, RandomIter last)
{
// 每执行一次 pop_heap最大的元素都被放到尾部直到容器最多只有一个元素完成排序
while (last - first > 1)
{
mystl::pop_heap(first, last--);
}
}
// 重载版本使用函数对象 comp 代替比较操作
template <class RandomIter, class Compared>
void sort_heap(RandomIter first, RandomIter last, Compared comp)
{
while (last - first > 1)
{
mystl::pop_heap(first, last--, comp);
}
}
/*****************************************************************************************/
// make_heap
// 该函数接受两个迭代器,表示 heap 容器的首尾,把容器内的数据变为一个 heap
/*****************************************************************************************/
template <class RandomIter, class Distance>
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 <class RandomIter>
void make_heap(RandomIter first, RandomIter last)
{
mystl::make_heap_aux(first, last, distance_type(first));;
}
// 重载版本使用函数对象 comp 代替比较操作
template <class RandomIter, class Distance, class Compared>
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 <class RandomIter, class Compared>
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_

@ -1,366 +0,0 @@
#ifndef MYTINYSTL_ITERATOR_H_
#define MYTINYSTL_ITERATOR_H_
// 这个头文件用于迭代器设计,包含了一些模板结构体与全局函数,
#include <cstddef>
#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 <class Category, class T, class Distance = ptrdiff_t,
class Pointer = T*, class Reference = T&>
struct iterator
{
typedef Category iterator_category;
typedef T value_type;
typedef Pointer pointer;
typedef Reference reference;
typedef Distance difference_type;
};
// iterator traits
template <class T>
struct has_iterator_cat
{
private:
struct two { char a; char b; };
template <class U> static two test(...);
template <class U> static char test(typename U::iterator_category* = 0);
public:
static const bool value = sizeof(test<T>(0)) == sizeof(char);
};
template <class Iterator, bool>
struct iterator_traits_impl {};
template <class Iterator>
struct iterator_traits_impl<Iterator, true>
{
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 <class Iterator, bool>
struct iterator_traits_helper {};
template <class Iterator>
struct iterator_traits_helper<Iterator, true>
: public iterator_traits_impl<Iterator,
std::is_convertible<typename Iterator::iterator_category, input_iterator_tag>::value ||
std::is_convertible<typename Iterator::iterator_category, output_iterator_tag>::value>
{
};
// 萃取迭代器的特性
template <class Iterator>
struct iterator_traits
: public iterator_traits_helper<Iterator, has_iterator_cat<Iterator>::value> {};
// 针对原生指针的偏特化版本
template <class T>
struct iterator_traits<T*>
{
typedef random_access_iterator_tag iterator_category;
typedef T value_type;
typedef T* pointer;
typedef T& reference;
typedef ptrdiff_t difference_type;
};
template <class T>
struct iterator_traits<const T*>
{
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 <class T, class U, bool = has_iterator_cat<iterator_traits<T>>::value>
struct has_iterator_cat_of
: public m_bool_constant<std::is_convertible<
typename iterator_traits<T>::iterator_category, U>::value>
{
};
// 萃取某种迭代器
template <class T, class U>
struct has_iterator_cat_of<T, U, false> : public m_false_type {};
template <class Iter>
struct is_input_iterator : public has_iterator_cat_of<Iter, input_iterator_tag> {};
template <class Iter>
struct is_output_iterator : public has_iterator_cat_of<Iter, output_iterator_tag> {};
template <class Iter>
struct is_forward_iterator : public has_iterator_cat_of<Iter, forward_iterator_tag> {};
template <class Iter>
struct is_bidirectional_iterator : public has_iterator_cat_of<Iter, bidirectional_iterator_tag> {};
template <class Iter>
struct is_random_access_iterator : public has_iterator_cat_of<Iter, random_access_iterator_tag> {};
template <class Iterator>
struct is_iterator :
public m_bool_constant<is_input_iterator<Iterator>::value ||
is_output_iterator<Iterator>::value>
{
};
// 萃取某个迭代器的 category
template <class Iterator>
typename iterator_traits<Iterator>::iterator_category
iterator_category(const Iterator&)
{
typedef typename iterator_traits<Iterator>::iterator_category Category;
return Category();
}
// 萃取某个迭代器的 distance_type
template <class Iterator>
typename iterator_traits<Iterator>::difference_type*
distance_type(const Iterator&)
{
return static_cast<typename iterator_traits<Iterator>::difference_type*>(0);
}
// 萃取某个迭代器的 value_type
template <class Iterator>
typename iterator_traits<Iterator>::value_type*
value_type(const Iterator&)
{
return static_cast<typename iterator_traits<Iterator>::value_type*>(0);
}
// 以下函数用于计算迭代器间的距离
// distance 的 input_iterator_tag 的版本
template <class InputIterator>
typename iterator_traits<InputIterator>::difference_type
distance_dispatch(InputIterator first, InputIterator last, input_iterator_tag)
{
typename iterator_traits<InputIterator>::difference_type n = 0;
while (first != last)
{
++first;
++n;
}
return n;
}
// distance 的 random_access_iterator_tag 的版本
template <class RandomIter>
typename iterator_traits<RandomIter>::difference_type
distance_dispatch(RandomIter first, RandomIter last,
random_access_iterator_tag)
{
return last - first;
}
template <class InputIterator>
typename iterator_traits<InputIterator>::difference_type
distance(InputIterator first, InputIterator last)
{
return distance_dispatch(first, last, iterator_category(first));
}
// 以下函数用于让迭代器前进 n 个距离
// advance 的 input_iterator_tag 的版本
template <class InputIterator, class Distance>
void advance_dispatch(InputIterator& i, Distance n, input_iterator_tag)
{
while (n--)
++i;
}
// advance 的 bidirectional_iterator_tag 的版本
template <class BidirectionalIterator, class Distance>
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 <class RandomIter, class Distance>
void advance_dispatch(RandomIter& i, Distance n, random_access_iterator_tag)
{
i += n;
}
template <class InputIterator, class Distance>
void advance(InputIterator& i, Distance n)
{
advance_dispatch(i, n, iterator_category(i));
}
/*****************************************************************************************/
// 模板类 : reverse_iterator
// 代表反向迭代器,使前进为后退,后退为前进
template <class Iterator>
class reverse_iterator
{
private:
Iterator current; // 记录对应的正向迭代器
public:
// 反向迭代器的五种相应型别
typedef typename iterator_traits<Iterator>::iterator_category iterator_category;
typedef typename iterator_traits<Iterator>::value_type value_type;
typedef typename iterator_traits<Iterator>::difference_type difference_type;
typedef typename iterator_traits<Iterator>::pointer pointer;
typedef typename iterator_traits<Iterator>::reference reference;
typedef Iterator iterator_type;
typedef reverse_iterator<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 <class Iterator>
typename reverse_iterator<Iterator>::difference_type
operator-(const reverse_iterator<Iterator>& lhs,
const reverse_iterator<Iterator>& rhs)
{
return rhs.base() - lhs.base();
}
// 重载比较操作符
template <class Iterator>
bool operator==(const reverse_iterator<Iterator>& lhs,
const reverse_iterator<Iterator>& rhs)
{
return lhs.base() == rhs.base();
}
template <class Iterator>
bool operator<(const reverse_iterator<Iterator>& lhs,
const reverse_iterator<Iterator>& rhs)
{
return rhs.base() < lhs.base();
}
template <class Iterator>
bool operator!=(const reverse_iterator<Iterator>& lhs,
const reverse_iterator<Iterator>& rhs)
{
return !(lhs == rhs);
}
template <class Iterator>
bool operator>(const reverse_iterator<Iterator>& lhs,
const reverse_iterator<Iterator>& rhs)
{
return rhs < lhs;
}
template <class Iterator>
bool operator<=(const reverse_iterator<Iterator>& lhs,
const reverse_iterator<Iterator>& rhs)
{
return !(rhs < lhs);
}
template <class Iterator>
bool operator>=(const reverse_iterator<Iterator>& lhs,
const reverse_iterator<Iterator>& rhs)
{
return !(lhs < rhs);
}
} // namespace mystl
#endif // !MYTINYSTL_ITERATOR_H_

File diff suppressed because it is too large Load Diff

@ -1,549 +0,0 @@
#ifndef MYTINYSTL_MAP_H_ //
#define MYTINYSTL_MAP_H_
//
// 这个头文件包含了两个模板类 map 和 multimap
// map : 映射,元素具有键值和实值,会根据键值大小自动排序,键值不允许重复
// multimap : 映射,元素具有键值和实值,会根据键值大小自动排序,键值允许重复
// notes:
//
// 异常保证: //
// mystl::map<Key, T> / mystl::multimap<Key, T> 满足基本异常保证,对以下等函数做强异常安全保证:
// * emplace
// * emplace_hint //
// * insert
//
#include "rb_tree.h" //
//
namespace mystl
{
// 模板类 map键值不允许重复
// 参数一代表键值类型,参数二代表实值类型,参数三代表键值的比较方式,缺省使用 mystl::less
template <class Key, class T, class Compare = mystl::less<Key>>
class map
{ //
public:
// map 的嵌套型别定义
typedef Key key_type; //
typedef T mapped_type;
typedef mystl::pair<const Key, T> value_type;
typedef Compare key_compare; //
// 定义一个 functor用来进行元素比较 //
class value_compare : public binary_function <value_type, value_type, bool>
{
friend class map<Key, T, Compare>;
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<value_type, key_compare> 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 <class InputIterator>
map(InputIterator first, InputIterator last) //
:tree_()
{ tree_.insert_unique(first, last); } //
map(std::initializer_list<value_type> 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<value_type> 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<Key, T> 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<Key, T> 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 <class ...Args> //
pair<iterator, bool> emplace(Args&& ...args)
{ //
return tree_.emplace_unique(mystl::forward<Args>(args)...); //
} //
template <class ...Args> //
iterator emplace_hint(iterator hint, Args&& ...args)
{
return tree_.emplace_unique_use_hint(hint, mystl::forward<Args>(args)...); //
}
pair<iterator, bool> insert(const value_type& value)
{
return tree_.insert_unique(value); //
}
pair<iterator, bool> 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 <class InputIterator> //
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<iterator, iterator>
equal_range(const key_type& key)
{ return tree_.equal_range_unique(key); } //
pair<const_iterator, const_iterator>
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 <class Key, class T, class Compare> //
bool operator==(const map<Key, T, Compare>& lhs, const map<Key, T, Compare>& rhs)
{ //
return lhs == rhs;
}
template <class Key, class T, class Compare> //
bool operator<(const map<Key, T, Compare>& lhs, const map<Key, T, Compare>& rhs) //
{
return lhs < rhs; //
} //
template <class Key, class T, class Compare> //
bool operator!=(const map<Key, T, Compare>& lhs, const map<Key, T, Compare>& rhs)
{
return !(lhs == rhs); //
}
//
template <class Key, class T, class Compare> //
bool operator>(const map<Key, T, Compare>& lhs, const map<Key, T, Compare>& rhs)
{ //
return rhs < lhs; //
} //
template <class Key, class T, class Compare>
bool operator<=(const map<Key, T, Compare>& lhs, const map<Key, T, Compare>& rhs)
{ //
return !(rhs < lhs); //
}
template <class Key, class T, class Compare> //
bool operator>=(const map<Key, T, Compare>& lhs, const map<Key, T, Compare>& rhs)
{
return !(lhs < rhs);
} //
// 重载 mystl 的 swap
template <class Key, class T, class Compare>
void swap(map<Key, T, Compare>& lhs, map<Key, T, Compare>& rhs) noexcept
{ //
lhs.swap(rhs);
}
//
/*****************************************************************************************/
// 模板类 multimap键值允许重复 //
// 参数一代表键值类型,参数二代表实值类型,参数三代表键值的比较方式,缺省使用 mystl::less //
template <class Key, class T, class Compare = mystl::less<Key>> //
class multimap //
{
public: //
// multimap 的型别定义
typedef Key key_type;
typedef T mapped_type;
typedef mystl::pair<const Key, T> value_type;
typedef Compare key_compare;
// 定义一个 functor用来进行元素比较
class value_compare : public binary_function <value_type, value_type, bool>
{
friend class multimap<Key, T, Compare>;
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<value_type, key_compare> 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 <class InputIterator>
multimap(InputIterator first, InputIterator last)
:tree_()
{ tree_.insert_multi(first, last); }
multimap(std::initializer_list<value_type> 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<value_type> 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 <class ...Args>
iterator emplace(Args&& ...args) //
{
return tree_.emplace_multi(mystl::forward<Args>(args)...);
}
//
template <class ...Args>
iterator emplace_hint(iterator hint, Args&& ...args) //
{
return tree_.emplace_multi_use_hint(hint, mystl::forward<Args>(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 <class InputIterator>
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<iterator, iterator>
equal_range(const key_type& key)
{ return tree_.equal_range_multi(key); }
//
pair<const_iterator, const_iterator>
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 <class Key, class T, class Compare>
bool operator==(const multimap<Key, T, Compare>& lhs, const multimap<Key, T, Compare>& rhs) //
{
return lhs == rhs;
}
template <class Key, class T, class Compare>
bool operator<(const multimap<Key, T, Compare>& lhs, const multimap<Key, T, Compare>& rhs)
{
return lhs < rhs; //
} //
template <class Key, class T, class Compare>
bool operator!=(const multimap<Key, T, Compare>& lhs, const multimap<Key, T, Compare>& rhs) //
{
return !(lhs == rhs);
}
//
template <class Key, class T, class Compare>
bool operator>(const multimap<Key, T, Compare>& lhs, const multimap<Key, T, Compare>& rhs)
{
return rhs < lhs;
}
//
template <class Key, class T, class Compare>
bool operator<=(const multimap<Key, T, Compare>& lhs, const multimap<Key, T, Compare>& rhs) //
{
return !(rhs < lhs);
} //
//
template <class Key, class T, class Compare>
bool operator>=(const multimap<Key, T, Compare>& lhs, const multimap<Key, T, Compare>& rhs)
{ //
return !(lhs < rhs); //
}
//
// 重载 mystl 的 swap
template <class Key, class T, class Compare> //
void swap(multimap<Key, T, Compare>& lhs, multimap<Key, T, Compare>& rhs) noexcept
{
lhs.swap(rhs);
} //
} // namespace mystl
#endif // !MYTINYSTL_MAP_H_
//

@ -1,208 +0,0 @@
#ifndef MYTINYSTL_MEMORY_H_ //
#define MYTINYSTL_MEMORY_H_
// 这个头文件负责更高级的动态内存管理 //
// 包含一些基本函数、空间配置器、未初始化的储存空间管理,以及一个模板类 auto_ptr
#include <cstddef>
#include <cstdlib>
#include <climits>
#include "algobase.h"
#include "allocator.h"
#include "construct.h" //
#include "uninitialized.h"
//
namespace mystl
{
// 获取对象地址
template <class Tp>
constexpr Tp* address_of(Tp& value) noexcept //
{
return &value;
}
//
// 获取 / 释放 临时缓冲区 //
//
template <class T>
pair<T*, ptrdiff_t> get_buffer_helper(ptrdiff_t len, T*)
{
if (len > static_cast<ptrdiff_t>(INT_MAX / sizeof(T))) //
len = INT_MAX / sizeof(T);
while (len > 0)
{
T* tmp = static_cast<T*>(malloc(static_cast<size_t>(len) * sizeof(T)));
if (tmp)
return pair<T*, ptrdiff_t>(tmp, len); //
len /= 2; // 申请失败时减少 len 的大小
}
return pair<T*, ptrdiff_t>(nullptr, 0); //
} //
template <class T>
pair<T*, ptrdiff_t> get_temporary_buffer(ptrdiff_t len)
{
return get_buffer_helper(len, static_cast<T*>(0));
}
template <class T> //
pair<T*, ptrdiff_t> get_temporary_buffer(ptrdiff_t len, T*)
{ //
return get_buffer_helper(len, static_cast<T*>(0));
}
template <class T> //
void release_temporary_buffer(T* ptr)
{
free(ptr); //
}
// -------------------------------------------------------------------------------------- //
// 类模板 : temporary_buffer
// 进行临时缓冲区的申请与释放
template <class ForwardIterator, class T> //
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 <class ForwardIterator, class T>
temporary_buffer<ForwardIterator, T>::
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<T>()); //
}
}
catch (...)
{
free(buffer);
buffer = nullptr; //
len = 0; //
}
}
//
// allocate_buffer 函数
template <class ForwardIterator, class T>
void temporary_buffer<ForwardIterator, T>::allocate_buffer()
{ //
original_len = len;
if (len > static_cast<ptrdiff_t>(INT_MAX / sizeof(T))) //
len = INT_MAX / sizeof(T);
while (len > 0) //
{
buffer = static_cast<T*>(malloc(len * sizeof(T))); //
if (buffer)
break; //
len /= 2; // 申请失败时减少申请空间大小
} //
} //
//
// --------------------------------------------------------------------------------------
// 模板类: auto_ptr //
// 一个具有严格对象所有权的小型智能指针
template <class T> //
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 <class U>
auto_ptr(auto_ptr<U>& rhs) : m_ptr(rhs.release()) {}
//
auto_ptr& operator=(auto_ptr& rhs) //
{
if (this != &rhs)
{
delete m_ptr; //
m_ptr = rhs.release();
}
return *this;
}
template <class U> //
auto_ptr& operator=(auto_ptr<U>& 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_ //

@ -1,155 +0,0 @@
#ifndef MYTINYSTL_NUMERIC_H_ //
#define MYTINYSTL_NUMERIC_H_
// 这个头文件包含了 mystl 的数值算法
#include "iterator.h"
namespace mystl
{ //
/*****************************************************************************************/ //
// accumulate
// 版本1以初值 init 对每个元素进行累加 //
// 版本2以初值 init 对每个元素进行二元操作
/*****************************************************************************************/
// 版本1 //
template <class InputIter, class T>
T accumulate(InputIter first, InputIter last, T init)
{ //
for (; first != last; ++first)
{ //
init += *first;
}
return init;
} //
// 版本2
template <class InputIter, class T, class BinaryOp>
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 <class InputIter, class OutputIter>
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 <class InputIter, class OutputIter, class BinaryOp>
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 <class InputIter1, class InputIter2, class T>
T inner_product(InputIter1 first1, InputIter1 last1, InputIter2 first2, T init) //
{
for (; first1 != last1; ++first1, ++first2) //
{
init = init + (*first1 * *first2);
} //
return init;
}
// 版本2
template <class InputIter1, class InputIter2, class T, class BinaryOp1, class BinaryOp2>
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 <class ForwardIter, class T>
void iota(ForwardIter first, ForwardIter last, T value) //
{
while (first != last) //
{
*first++ = value; //
++value;
} //
}
//
/*****************************************************************************************/
// partial_sum
// 版本1计算局部累计求和结果保存到以 result 为起始的区间上
// 版本2进行局部进行自定义二元操作 //
/*****************************************************************************************/
template <class InputIter, class OutputIter>
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 <class InputIter, class OutputIter, class BinaryOp>
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_ //

@ -1,364 +0,0 @@
#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 T, class Container = mystl::deque<T>>
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<T, value_type>::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 <class IIter>
queue(IIter first, IIter last) //
:c_(first, last)
{
}
queue(std::initializer_list<T> ilist)
:c_(ilist.begin(), ilist.end())
{ //
} //
queue(const Container& c)
:c_(c)
{ //
}
queue(Container&& c) noexcept(std::is_nothrow_move_constructible<Container>::value) //
:c_(mystl::move(c))
{
}
//
queue(const queue& rhs)
:c_(rhs.c_)
{
} //
queue(queue&& rhs) noexcept(std::is_nothrow_move_constructible<Container>::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<Container>::value) //
{
c_ = mystl::move(rhs.c_);
return *this; //
}
//
queue& operator=(std::initializer_list<T> 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 <class ...Args>
void emplace(Args&& ...args)
{ c_.emplace_back(mystl::forward<Args>(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 <class T, class Container>
bool operator==(const queue<T, Container>& lhs, const queue<T, Container>& rhs)
{ //
return lhs == rhs;
}
template <class T, class Container>
bool operator!=(const queue<T, Container>& lhs, const queue<T, Container>& rhs) //
{ //
return !(lhs == rhs); //
}
template <class T, class Container>
bool operator<(const queue<T, Container>& lhs, const queue<T, Container>& rhs)
{
return lhs < rhs; //
}
//
template <class T, class Container>
bool operator>(const queue<T, Container>& lhs, const queue<T, Container>& rhs)
{
return rhs < lhs;
}
//
template <class T, class Container>
bool operator<=(const queue<T, Container>& lhs, const queue<T, Container>& rhs)
{ //
return !(rhs < lhs);
}
//
template <class T, class Container>
bool operator>=(const queue<T, Container>& lhs, const queue<T, Container>& rhs) //
{
return !(lhs < rhs); //
}
//
// 重载 mystl 的 swap
template <class T, class Container>
void swap(queue<T, Container>& lhs, queue<T, Container>& rhs) noexcept(noexcept(lhs.swap(rhs)))
{
lhs.swap(rhs);
} //
/*****************************************************************************************/
// 模板类 priority_queue
// 参数一代表数据类型,参数二代表容器类型,缺省使用 mystl::vector 作为底层容器
// 参数三代表比较权值的方式,缺省使用 mystl::less 作为比较方式 //
template <class T, class Container = mystl::vector<T>,
class Compare = mystl::less<typename Container::value_type>>
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<T, value_type>::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 <class IIter>
priority_queue(IIter first, IIter last)
:c_(first, last)
{ //
mystl::make_heap(c_.begin(), c_.end(), comp_); //
} //
priority_queue(std::initializer_list<T> 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<T> 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 <class... Args> //
void emplace(Args&& ...args) //
{ //
c_.emplace_back(mystl::forward<Args>(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 <class T, class Container, class Compare>
bool operator==(priority_queue<T, Container, Compare>& lhs, //
priority_queue<T, Container, Compare>& rhs)
{ //
return lhs == rhs;
} //
//
template <class T, class Container, class Compare>
bool operator!=(priority_queue<T, Container, Compare>& lhs,
priority_queue<T, Container, Compare>& rhs) //
{
return lhs != rhs;
}
//
// 重载 mystl 的 swap
template <class T, class Container, class Compare>
void swap(priority_queue<T, Container, Compare>& lhs,
priority_queue<T, Container, Compare>& rhs) noexcept(noexcept(lhs.swap(rhs)))
{
lhs.swap(rhs);
}
//
} // namespace mystl
#endif // !MYTINYSTL_QUEUE_H_

File diff suppressed because it is too large Load Diff

@ -1,477 +0,0 @@
#ifndef MYTINYSTL_SET_H_
#define MYTINYSTL_SET_H_
// 这个头文件包含两个模板类 set 和 multiset
// set : 集合,键值即实值,集合内元素会自动排序,键值不允许重复
// multiset : 集合,键值即实值,集合内元素会自动排序,键值允许重复
// notes:
//
// 异常保证:
// mystl::set<Key> / mystl::multiset<Key> 满足基本异常保证,对以下等函数做强异常安全保证:
// * emplace
// * emplace_hint
// * insert
#include "rb_tree.h"
namespace mystl
{
// 模板类 set键值不允许重复
// 参数一代表键值类型,参数二代表键值比较方式,缺省使用 mystl::less
template <class Key, class Compare = mystl::less<Key>>
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<value_type, key_compare> 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 <class InputIterator>
set(InputIterator first, InputIterator last)
:tree_()
{ tree_.insert_unique(first, last); }
set(std::initializer_list<value_type> 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<value_type> 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 <class ...Args>
pair<iterator, bool> emplace(Args&& ...args)
{
return tree_.emplace_unique(mystl::forward<Args>(args)...);
}
template <class ...Args>
iterator emplace_hint(iterator hint, Args&& ...args)
{
return tree_.emplace_unique_use_hint(hint, mystl::forward<Args>(args)...);
}
pair<iterator, bool> insert(const value_type& value)
{
return tree_.insert_unique(value);
}
pair<iterator, bool> 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 <class InputIterator>
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<iterator, iterator>
equal_range(const key_type& key)
{ return tree_.equal_range_unique(key); }
pair<const_iterator, const_iterator>
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 <class Key, class Compare>
bool operator==(const set<Key, Compare>& lhs, const set<Key, Compare>& rhs)
{
return lhs == rhs;
}
template <class Key, class Compare>
bool operator<(const set<Key, Compare>& lhs, const set<Key, Compare>& rhs)
{
return lhs < rhs;
}
template <class Key, class Compare>
bool operator!=(const set<Key, Compare>& lhs, const set<Key, Compare>& rhs)
{
return !(lhs == rhs);
}
template <class Key, class Compare>
bool operator>(const set<Key, Compare>& lhs, const set<Key, Compare>& rhs)
{
return rhs < lhs;
}
template <class Key, class Compare>
bool operator<=(const set<Key, Compare>& lhs, const set<Key, Compare>& rhs)
{
return !(rhs < lhs);
}
template <class Key, class Compare>
bool operator>=(const set<Key, Compare>& lhs, const set<Key, Compare>& rhs)
{
return !(lhs < rhs);
}
// 重载 mystl 的 swap
template <class Key, class Compare>
void swap(set<Key, Compare>& lhs, set<Key, Compare>& rhs) noexcept
{
lhs.swap(rhs);
}
/*****************************************************************************************/
// 模板类 multiset键值允许重复
// 参数一代表键值类型,参数二代表键值比较方式,缺省使用 mystl::less
template <class Key, class Compare = mystl::less<Key>>
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<value_type, key_compare> 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 <class InputIterator>
multiset(InputIterator first, InputIterator last)
:tree_()
{ tree_.insert_multi(first, last); }
multiset(std::initializer_list<value_type> 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<value_type> 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 <class ...Args>
iterator emplace(Args&& ...args)
{
return tree_.emplace_multi(mystl::forward<Args>(args)...);
}
template <class ...Args>
iterator emplace_hint(iterator hint, Args&& ...args)
{
return tree_.emplace_multi_use_hint(hint, mystl::forward<Args>(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 <class InputIterator>
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<iterator, iterator>
equal_range(const key_type& key)
{ return tree_.equal_range_multi(key); }
pair<const_iterator, const_iterator>
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 <class Key, class Compare>
bool operator==(const multiset<Key, Compare>& lhs, const multiset<Key, Compare>& rhs)
{
return lhs == rhs;
}
template <class Key, class Compare>
bool operator<(const multiset<Key, Compare>& lhs, const multiset<Key, Compare>& rhs)
{
return lhs < rhs;
}
template <class Key, class Compare>
bool operator!=(const multiset<Key, Compare>& lhs, const multiset<Key, Compare>& rhs)
{
return !(lhs == rhs);
}
template <class Key, class Compare>
bool operator>(const multiset<Key, Compare>& lhs, const multiset<Key, Compare>& rhs)
{
return rhs < lhs;
}
template <class Key, class Compare>
bool operator<=(const multiset<Key, Compare>& lhs, const multiset<Key, Compare>& rhs)
{
return !(rhs < lhs);
}
template <class Key, class Compare>
bool operator>=(const multiset<Key, Compare>& lhs, const multiset<Key, Compare>& rhs)
{
return !(lhs < rhs);
}
// 重载 mystl 的 swap
template <class Key, class Compare>
void swap(multiset<Key, Compare>& lhs, multiset<Key, Compare>& rhs) noexcept
{
lhs.swap(rhs);
}
} // namespace mystl
#endif // !MYTINYSTL_SET_H_

@ -1,253 +0,0 @@
#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
// 计算 S1S2 的结果并保存到 result 中,返回一个迭代器指向输出结果的尾部
/*****************************************************************************************/
template <class InputIter1, class InputIter2, class OutputIter>
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 <class InputIter1, class InputIter2, class OutputIter, class Compared>
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 <class InputIter1, class InputIter2, class OutputIter>
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 <class InputIter1, class InputIter2, class OutputIter, class Compared>
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 <class InputIter1, class InputIter2, class OutputIter>
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 <class InputIter1, class InputIter2, class OutputIter, class Compared>
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 <class InputIter1, class InputIter2, class OutputIter>
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 <class InputIter1, class InputIter2, class OutputIter, class Compared>
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_

@ -1,173 +0,0 @@
#ifndef MYTINYSTL_STACK_H_
#define MYTINYSTL_STACK_H_
//这是个头文件
// 这个头文件包含了一个模板类 stack
// stack : 栈
#include "deque.h"
namespace mystl
{
// 模板类 stack
// 参数一代表数据类型,参数二代表底层容器类型,缺省使用 mystl::deque 作为底层容器
template <class T, class Container = mystl::deque<T>>
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<T, value_type>::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 <class IIter>
stack(IIter first, IIter last)
: c_(first, last)
{
}
stack(std::initializer_list<T> ilist)
:c_(ilist.begin(), ilist.end())
{
}
stack(const Container& c)
:c_(c)
{
}
stack(Container&& c) noexcept(std::is_nothrow_move_constructible<Container>::value)
:c_(mystl::move(c))
{
}
stack(const stack& rhs)
:c_(rhs.c_)
{
}
stack(stack&& rhs) noexcept(std::is_nothrow_move_constructible<Container>::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<Container>::value)
{
c_ = mystl::move(rhs.c_);
return *this;
}
stack& operator=(std::initializer_list<T> 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 <class... Args>
void emplace(Args&& ...args)
{ c_.emplace_back(mystl::forward<Args>(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 <class T, class Container>
bool operator==(const stack<T, Container>& lhs, const stack<T, Container>& rhs)
{
return lhs == rhs;
}
template <class T, class Container>
bool operator<(const stack<T, Container>& lhs, const stack<T, Container>& rhs)
{
return lhs < rhs;
}
template <class T, class Container>
bool operator!=(const stack<T, Container>& lhs, const stack<T, Container>& rhs)
{
return !(lhs == rhs);
}
template <class T, class Container>
bool operator>(const stack<T, Container>& lhs, const stack<T, Container>& rhs)
{
return rhs < lhs;
}
template <class T, class Container>
bool operator<=(const stack<T, Container>& lhs, const stack<T, Container>& rhs)
{
return !(rhs < lhs);
}
template <class T, class Container>
bool operator>=(const stack<T, Container>& lhs, const stack<T, Container>& rhs)
{
return !(lhs < rhs);
}
// 重载 mystl 的 swap
template <class T, class Container>
void swap(stack<T, Container>& lhs, stack<T, Container>& rhs) noexcept(noexcept(lhs.swap(rhs)))
{
lhs.swap(rhs);
}
} // namespace mystl
#endif // !MYTINYSTL_STACK_H_

@ -1,45 +0,0 @@
#ifndef MYTINYSTL_TYPE_TRAITS_H_
#define MYTINYSTL_TYPE_TRAITS_H_
// 这个头文件用于提取类型信息
// use standard header for type_traits
#include <type_traits>
namespace mystl
{
// helper struct
template <class T, T v>
struct m_integral_constant
{
static constexpr T value = v;
};
template <bool b>
using m_bool_constant = m_integral_constant<bool, b>;
typedef m_bool_constant<true> m_true_type;
typedef m_bool_constant<false> m_false_type;
/*****************************************************************************************/
// type traits
// is_pair
// --- forward declaration begin
template <class T1, class T2>
struct pair;
// --- forward declaration end
template <class T>
struct is_pair : mystl::m_false_type {};
template <class T1, class T2>
struct is_pair<mystl::pair<T1, T2>> : mystl::m_true_type {};
} // namespace mystl
#endif // !MYTINYSTL_TYPE_TRAITS_H_

@ -1,256 +0,0 @@
#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 <class InputIter, class ForwardIter>
ForwardIter
unchecked_uninit_copy(InputIter first, InputIter last, ForwardIter result, std::true_type)
{
return mystl::copy(first, last, result);
}
template <class InputIter, class ForwardIter>
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 <class InputIter, class ForwardIter>
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<ForwardIter>::
value_type>{});
}
/*****************************************************************************************/
// uninitialized_copy_n
// 把 [first, first + n) 上的内容复制到以 result 为起始处的空间,返回复制结束的位置
/*****************************************************************************************/
template <class InputIter, class Size, class ForwardIter>
ForwardIter
unchecked_uninit_copy_n(InputIter first, Size n, ForwardIter result, std::true_type)
{
return mystl::copy_n(first, n, result).second;
}
template <class InputIter, class Size, class ForwardIter>
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 <class InputIter, class Size, class ForwardIter>
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<InputIter>::
value_type>{});
}
/*****************************************************************************************/
// uninitialized_fill
// 在 [first, last) 区间内填充元素值
/*****************************************************************************************/
template <class ForwardIter, class T>
void
unchecked_uninit_fill(ForwardIter first, ForwardIter last, const T& value, std::true_type)
{
mystl::fill(first, last, value);
}
template <class ForwardIter, class T>
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 <class ForwardIter, class T>
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<ForwardIter>::
value_type>{});
}
/*****************************************************************************************/
// uninitialized_fill_n
// 从 first 位置开始,填充 n 个元素值,返回填充结束的位置
/*****************************************************************************************/
template <class ForwardIter, class Size, class T>
ForwardIter
unchecked_uninit_fill_n(ForwardIter first, Size n, const T& value, std::true_type)
{
return mystl::fill_n(first, n, value);
}
template <class ForwardIter, class Size, class T>
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 <class ForwardIter, class Size, class T>
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<ForwardIter>::
value_type>{});
}
/*****************************************************************************************/
// uninitialized_move
// 把[first, last)上的内容移动到以 result 为起始处的空间,返回移动结束的位置
/*****************************************************************************************/
template <class InputIter, class ForwardIter>
ForwardIter
unchecked_uninit_move(InputIter first, InputIter last, ForwardIter result, std::true_type)
{
return mystl::move(first, last, result);
}
template <class InputIter, class ForwardIter>
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 <class InputIter, class ForwardIter>
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<InputIter>::
value_type>{});
}
/*****************************************************************************************/
// uninitialized_move_n
// 把[first, first + n)上的内容移动到以 result 为起始处的空间,返回移动结束的位置
/*****************************************************************************************/
template <class InputIter, class Size, class ForwardIter>
ForwardIter
unchecked_uninit_move_n(InputIter first, Size n, ForwardIter result, std::true_type)
{
return mystl::move(first, first + n, result);
}
template <class InputIter, class Size, class ForwardIter>
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 <class InputIter, class Size, class ForwardIter>
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<InputIter>::
value_type>{});
}
} // namespace mystl
#endif // !MYTINYSTL_UNINITIALIZED_H_

@ -1,741 +0,0 @@
#ifndef MYTINYSTL_UNORDERED_MAP_H_ // 防止头文件被重复包含的宏定义
#define MYTINYSTL_UNORDERED_MAP_H_
/*以上代码合起来实现了一个自定义的 `unordered_multimap` 容器类模板,该类模板提供了与标准库中的 `std::unordered_multimap` 类似的功能。以下是该类实现的主要功能:
### 容器特性
- ****`unordered_multimap` `pair<const Key, T>` `Key` `T`
- **** `std::map` `unordered_multimap` 使`hashtable`
### 构造与初始化
- **** `unordered_multimap`
- ****
- **** `unordered_multimap`
- **** `unordered_multimap`
### 迭代器
-
-
### 容量操作
- **`empty`**
- **`size`**
- **`max_size`**
### 修改操作
- **`emplace` `emplace_hint`**`emplace_hint` 使 hint
- **`insert`**使 hint
- **`erase`**
- **`clear`**
### 查找操作
- **`find`**
- **`equal_range`**
### 桶操作
- **`bucket_count` `max_bucket_count`**
- **`bucket_size`**
- **`bucket`**
### 哈希策略
- **`load_factor` `max_load_factor`**
- **`rehash` `reserve`**
### 其他
- **`swap`** `unordered_multimap`
- **** `==` `!=` `unordered_multimap`
*/
// 包含自定义的 hashtable 头文件,该文件定义了 hashtable 类
#include "hashtable.h"
namespace mystl // 定义命名空间 mystl用于封装自定义的 STL 组件
{
// 定义 unordered_map 模板类,该类实现了一个不排序的映射容器
template <class Key, class T, class Hash = mystl::hash<Key>, class KeyEqual = mystl::equal_to<Key>>
class unordered_map
{
private:
// 定义一个基于 hashtable 的底层数据结构类型
typedef hashtable<mystl::pair<const Key, T>, Hash, KeyEqual> base_type;
base_type ht_; // 创建一个 hashtable 实例来存储 unordered_map 的数据
public:
// 定义与 hashtable 相关的各种类型别名,以便在 unordered_map 中使用
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; // 定义常量本地迭代器类型
// 提供一个方法来获取 unordered_map 使用的分配器
allocator_type get_allocator() const { return ht_.get_allocator(); }
public:
// 默认构造函数,创建一个空的 unordered_map 实例
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)
{
}
// 范围构造函数,从迭代器指定的范围初始化 unordered_map
template <class InputIterator>
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<size_type>(mystl::distance(first, last))), hash, equal)
{
for (; first != last; ++first)
ht_.insert_unique_noresize(*first); // 将范围内的元素插入到 unordered_map 中
}
// 初始化列表构造函数,从初始化列表中初始化 unordered_map
unordered_map(std::initializer_list<value_type> ilist,
const size_type bucket_count = 100,
const Hash& hash = Hash(),
const KeyEqual& equal = KeyEqual())
:ht_(mystl::max(bucket_count, static_cast<size_type>(ilist.size())), hash, equal)
{
for (auto first = ilist.begin(), last = ilist.end(); first != last; ++first)
ht_.insert_unique_noresize(*first); // 将初始化列表中的元素插入到 unordered_map 中
}
// 复制构造函数,用于创建一个新的 unordered_map 实例,其内容与另一个实例相同
unordered_map(const unordered_map& rhs)
:ht_(rhs.ht_)
{
}
// 移动构造函数,用于创建一个新的 unordered_map 实例,接管另一个实例的所有资源
unordered_map(unordered_map&& rhs) noexcept
:ht_(mystl::move(rhs.ht_))
{
}
// 赋值运算符重载,用于将一个 unordered_map 实例的内容复制到另一个实例中
unordered_map& operator=(const unordered_map& rhs)
{
ht_ = rhs.ht_;
return *this;
}
// 移动赋值运算符,用于将一个 unordered_map 实例的内容移动到另一个实例中
unordered_map& operator=(unordered_map&& rhs)
{
ht_ = mystl::move(rhs.ht_);
return *this;
}
// 从初始化列表赋值,用于将初始化列表中的内容赋给 unordered_map
unordered_map& operator=(std::initializer_list<value_type> ilist)
{
ht_.clear(); // 清除 unordered_map 中的所有元素
ht_.reserve(ilist.size()); // 为新元素预留空间
for (auto first = ilist.begin(), last = ilist.end(); first != last; ++first)
ht_.insert_unique_noresize(*first); // 将初始化列表中的元素插入到 unordered_map 中
return *this;
}
// 默认析构函数,用于释放 unordered_map 占用的资源
~unordered_map() = default;
// 返回指向 unordered_map 第一个元素的迭代器
iterator begin() noexcept
{
return ht_.begin();
}
// 返回指向 unordered_map 第一个元素的常量迭代器
const_iterator begin() const noexcept
{
return ht_.begin();
}
// 返回指向 unordered_map 最后一个元素的迭代器
iterator end() noexcept
{
return ht_.end();
}
// 返回指向 unordered_map 最后一个元素的常量迭代器
const_iterator end() const noexcept
{
return ht_.end();
}
// 返回指向 unordered_map 第一个元素的常量迭代器
const_iterator cbegin() const noexcept
{
return ht_.cbegin();
}
// 返回指向 unordered_map 最后一个元素的常量迭代器
const_iterator cend() const noexcept
{
return ht_.cend();
}
// 检查 unordered_map 是否为空
bool empty() const noexcept { return ht_.empty(); }
// 返回 unordered_map 中的元素数量
size_type size() const noexcept { return ht_.size(); }
// 返回 unordered_map 能容纳的最大元素数量
size_type max_size() const noexcept { return ht_.max_size(); }
// 就地构造元素,并返回插入的迭代器和插入状态
template <class ...Args>
pair<iterator, bool> emplace(Args&& ...args)
{
return ht_.emplace_unique(mystl::forward<Args>(args)...);
}
// 就地构造元素,并使用 hint 提示插入位置,返回插入的迭代器
template <class ...Args>
iterator emplace_hint(const_iterator hint, Args&& ...args)
{
return ht_.emplace_unique_use_hint(hint, mystl::forward<Args>(args)...);
}
};
// 插入元素,并返回插入的迭代器和插入状态
pair<iterator, bool> insert(const value_type& value)
{
return ht_.insert_unique(value); // 调用底层 hashtable 的 insert_unique 方法
}
// 插入移动构造的元素,并返回插入的迭代器和插入状态
pair<iterator, bool> insert(value_type&& value)
{
return ht_.emplace_unique(mystl::move(value)); // 使用 emplace_unique 插入移动构造的元素
}
// 使用 hint 提示插入位置,并插入元素,返回插入的迭代器
iterator insert(const_iterator hint, const value_type& value)
{
return ht_.insert_unique_use_hint(hint, value); // 使用 hint 提示插入位置
}
// 使用 hint 提示插入位置,并插入移动构造的元素,返回插入的迭代器
iterator insert(const_iterator hint, value_type&& value)
{
return ht_.emplace_unique_use_hint(hint, mystl::move(value)); // 使用 hint 插入移动构造的元素
}
// 从迭代器范围插入元素 //
template <class InputIterator>
void insert(InputIterator first, InputIterator last)
{
ht_.insert_unique(first, last); // 插入范围内的所有元素
}
// erase / clear
// 删除指定迭代器位置的元素
void erase(iterator it)
{
ht_.erase(it); // 调用底层 hashtable 的 erase 方法
}
// 删除指定范围的元素
void erase(iterator first, iterator last)
{
ht_.erase(first, last); // 删除范围内的所有元素
}
// 删除指定键的元素,并返回被删除的元素数量
size_type erase(const key_type& key)
{
return ht_.erase_unique(key); // 调用底层 hashtable 的 erase_unique 方法
}
// 清空容器
void clear()
{
ht_.clear(); // 调用底层 hashtable 的 clear 方法,移除所有元素
}
// 交换两个 unordered_map 对象的内容
void swap(unordered_map& other) noexcept
{
ht_.swap(other.ht_); // 交换底层 hashtable 的内容,实现两个 unordered_map 的内容互换
}
// 查找相关
// 返回指定键的值的引用,如果键不存在则抛出异常
mapped_type& at(const key_type& key)
{
iterator it = ht_.find(key); // 查找键对应的元素
THROW_OUT_OF_RANGE_IF(it.node == nullptr, "unordered_map<Key, T> no such element exists"); // 如果键不存在,抛出 out_of_range 异常
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<Key, T> no such element exists"); // 如果键不存在,抛出 out_of_range 异常
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); // 调用底层 hashtable 的 count 方法,返回键对应的元素数量
}
// 查找元素
iterator find(const key_type& key)
{
return ht_.find(key); // 调用底层 hashtable 的 find 方法,返回指向找到的元素的迭代器
}
const_iterator find(const key_type& key) const
{
return ht_.find(key); // 调用底层 hashtable 的 find 方法,返回指向找到的元素的常量迭代器
}
// 返回给定键的元素范围
pair<iterator, iterator> equal_range(const key_type& key)
{
return ht_.equal_range_unique(key); // 调用底层 hashtable 的 equal_range_unique 方法,返回键对应的元素范围
}
pair<const_iterator, const_iterator> equal_range(const key_type& key) const
{
return ht_.equal_range_unique(key); // 调用底层 hashtable 的 equal_range_unique 方法,返回键对应的元素范围
}
// 桶接口
// 返回指定桶的本地迭代器
local_iterator begin(size_type n) noexcept
{
return ht_.begin(n); // 调用底层 hashtable 的 begin 方法,返回指定桶的本地迭代器
}
const_local_iterator begin(size_type n) const noexcept
{
return ht_.begin(n); // 调用底层 hashtable 的 begin 方法,返回指定桶的本地迭代器
}
const_local_iterator cbegin(size_type n) const noexcept
{
return ht_.cbegin(n); // 调用底层 hashtable 的 cbegin 方法,返回指定桶的本地迭代器
}
// 返回指定桶的本地迭代器
local_iterator end(size_type n) noexcept
{
return ht_.end(n); // 调用底层 hashtable 的 end 方法,返回指定桶的本地迭代器
}
const_local_iterator end(size_type n) const noexcept
{
return ht_.end(n); // 调用底层 hashtable 的 end 方法,返回指定桶的本地迭代器
}
const_local_iterator cend(size_type n) const noexcept
{
return ht_.cend(n); // 调用底层 hashtable 的 cend 方法,返回指定桶的本地迭代器
}
// 返回桶的数量
size_type bucket_count() const noexcept
{
return ht_.bucket_count(); // 调用底层 hashtable 的 bucket_count 方法,返回桶的数量
}
size_type max_bucket_count() const noexcept
{
return ht_.max_bucket_count(); // 调用底层 hashtable 的 max_bucket_count 方法,返回桶的最大数量
}
// 返回指定桶的大小
size_type bucket_size(size_type n) const noexcept
{
return ht_.bucket_size(n); // 调用底层 hashtable 的 bucket_size 方法,返回指定桶的大小
}
// 返回给定键的元素所在的桶编号
size_type bucket(const key_type& key) const
{
return ht_.bucket(key); // 调用底层 hashtable 的 bucket 方法,返回键对应的桶编号
}
// 哈希策略
// 返回当前负载因子
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_); // 比较两个 unordered_map 是否相等
}
friend bool operator!=(const unordered_map& lhs, const unordered_map& rhs)
{
return !lhs.ht_.equal_range_unique(rhs.ht_); // 比较两个 unordered_map 是否不相等
}
// 重载比较操作符
template <class Key, class T, class Hash, class KeyEqual>
bool operator==(const unordered_map<Key, T, Hash, KeyEqual>& lhs,
const unordered_map<Key, T, Hash, KeyEqual>& rhs)
{
return lhs == rhs; // 使用友元函数中的比较逻辑
}
template <class Key, class T, class Hash, class KeyEqual>
bool operator!=(const unordered_map<Key, T, Hash, KeyEqual>& lhs,
const unordered_map<Key, T, Hash, KeyEqual>& rhs)
{
return lhs != rhs; // 使用友元函数中的比较逻辑
}
// 重载 mystl 的 swap 函数
template <class Key, class T, class Hash, class KeyEqual>
void swap(unordered_map<Key, T, Hash, KeyEqual>& lhs,
unordered_map<Key, T, Hash, KeyEqual>& rhs)
{
lhs.swap(rhs); // 调用 unordered_map 的 swap 方法,交换两个对象的内容
}
// 模板类 unordered_multimap键值允许重复1
public:
// 定义与底层 hashtable 相关的类型别名,以便在 unordered_multimap 中使用
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; // 定义常量本地迭代器类型
// 提供一个方法来获取 unordered_multimap 使用的分配器
allocator_type get_allocator() const { return ht_.get_allocator(); }
public:
// 默认构造函数,创建一个空的 unordered_multimap 实例
unordered_multimap()
:ht_(100, Hash(), KeyEqual()) // 初始化底层 hashtable设置默认桶数量为 100
{
}
// 构造函数,允许指定桶的数量、哈希函数和键比较函数
explicit unordered_multimap(size_type bucket_count,
const Hash& hash = Hash(),
const KeyEqual& equal = KeyEqual())
:ht_(bucket_count, hash, equal) // 初始化底层 hashtable设置桶数量、哈希函数和键比较函数
{
}
// 范围构造函数,从迭代器指定的范围初始化 unordered_multimap
template <class InputIterator>
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<size_type>(mystl::distance(first, last))), hash, equal) // 初始化底层 hashtable设置桶数量、哈希函数和键比较函数
{
for (; first != last; ++first)
ht_.insert_multi_noresize(*first); // 将范围内的元素插入到 unordered_multimap 中,不调整桶大小
}
// 初始化列表构造函数,从初始化列表中初始化 unordered_multimap
unordered_multimap(std::initializer_list<value_type> ilist,
const size_type bucket_count = 100,
const Hash& hash = Hash(),
const KeyEqual& equal = KeyEqual())
:ht_(mystl::max(bucket_count, static_cast<size_type>(ilist.size())), hash, equal) // 初始化底层 hashtable设置桶数量、哈希函数和键比较函数
{
for (auto first = ilist.begin(), last = ilist.end(); first != last; ++first)
ht_.insert_multi_noresize(*first); // 将初始化列表中的元素插入到 unordered_multimap 中,不调整桶大小
}
// 复制构造函数,用于创建一个新的 unordered_multimap 实例,其内容与另一个实例相同
unordered_multimap(const unordered_multimap& rhs)
:ht_(rhs.ht_) // 深拷贝底层 hashtable
{
}
// 移动构造函数,用于创建一个新的 unordered_multimap 实例,接管另一个实例的所有资源
unordered_multimap(unordered_multimap&& rhs) noexcept
:ht_(mystl::move(rhs.ht_)) // 移动底层 hashtable
{
}
// 赋值运算符重载,用于将一个 unordered_multimap 实例的内容复制到另一个实例中
unordered_multimap& operator=(const unordered_multimap& rhs)
{
ht_ = rhs.ht_; // 深拷贝底层 hashtable
return *this;
}
// 移动赋值运算符,用于将一个 unordered_multimap 实例的内容移动到另一个实例中
unordered_multimap& operator=(unordered_multimap&& rhs)
{
ht_ = mystl::move(rhs.ht_); // 移动底层 hashtable
return *this;
}
// 从初始化列表赋值,用于将初始化列表中的内容赋给 unordered_multimap
unordered_multimap& operator=(std::initializer_list<value_type> ilist)
{
ht_.clear(); // 清除 unordered_multimap 中的所有元素
ht_.reserve(ilist.size()); // 为新元素预留空间
for (auto first = ilist.begin(), last = ilist.end(); first != last; ++first)
ht_.insert_multi_noresize(*first); // 将初始化列表中的元素插入到 unordered_multimap 中,不调整桶大小
return *this;
}
// 默认析构函数,用于释放 unordered_multimap 占用的资源
~unordered_multimap() = default;
// 返回指向 unordered_multimap 第一个元素的迭代器
iterator begin() noexcept { return ht_.begin(); }
// 返回指向 unordered_multimap 第一个元素的常量迭代器
const_iterator begin() const noexcept { return ht_.begin(); }
// 返回指向 unordered_multimap 最后一个元素的迭代器
iterator end() noexcept { return ht_.end(); }
// 返回指向 unordered_multimap 最后一个元素的常量迭代器
const_iterator end() const noexcept { return ht_.end(); }
// 返回指向 unordered_multimap 第一个元素的常量迭代器
const_iterator cbegin() const noexcept { return ht_.cbegin(); }
// 返回指向 unordered_multimap 最后一个元素的常量迭代器
const_iterator cend() const noexcept { return ht_.cend(); }
// 检查 unordered_multimap 是否为空
bool empty() const noexcept { return ht_.empty(); }
// 返回 unordered_multimap 中的元素数量
size_type size() const noexcept { return ht_.size(); }
// 返回 unordered_multimap 能容纳的最大元素数量
size_type max_size() const noexcept { return ht_.max_size(); }
// 修改容器操作
// 就地构造元素,并返回插入的迭代器
template <class ...Args>
iterator emplace(Args&& ...args) {
return ht_.emplace_multi(mystl::forward<Args>(args)...); // 就地构造元素并插入到 unordered_multimap 中
}
// 就地构造元素,并使用 hint 提示插入位置,返回插入的迭代器
template <class ...Args>
iterator emplace_hint(const_iterator hint, Args&& ...args) {
return ht_.emplace_multi_use_hint(hint, mystl::forward<Args>(args)...); // 使用 hint 提示插入位置并就地构造元素
}
// 插入元素,并返回插入的迭代器
iterator insert(const value_type & value) {
return ht_.insert_multi(value); // 插入元素到 unordered_multimap 中
}
// 插入移动构造的元素
iterator insert(value_type && value) {
return ht_.emplace_multi(mystl::move(value)); // 插入移动构造的元素到 unordered_multimap 中
}
// 使用 hint 提示插入位置,并插入元素,返回插入的迭代器
iterator insert(const_iterator hint, const value_type & value) {
return ht_.insert_multi_use_hint(hint, value); // 使用 hint 提示插入位置并插入元素
}
// 使用 hint 提示插入位置,并插入移动构造的元素,返回插入的迭代器
iterator insert(const_iterator hint, value_type && value) {
return ht_.emplace_multi_use_hint(hint, mystl::move(value)); // 使用 hint 提示插入位置并插入移动构造的元素
}
// 从迭代器范围插入元素
template <class InputIterator>
void insert(InputIterator first, InputIterator last) {
ht_.insert_multi(first, last); // 插入范围内的所有元素到 unordered_multimap 中
}
// 删除指定迭代器位置的元素
void erase(iterator it) {
ht_.erase(it); // 删除指定迭代器位置的元素
}
// 删除指定范围的元素
void erase(iterator first, iterator last) {
ht_.erase
// 删除指定键的所有元素,并返回被删除的元素数量
// 删除指定键的所有元素,并返回被删除的元素数量
size_type erase(const key_type & key) {
return ht_.erase_multi(key); // 删除指定键的所有元素
}
// 清空容器
void clear() {
ht_.clear(); // 清空底层 hashtable
}
// 返回指定桶的本地迭代器
local_iterator begin(size_type n) noexcept {
return ht_.begin(n); // 调用底层 hashtable 的 begin 方法,返回指定桶的本地迭代器
}
const_local_iterator begin(size_type n) const noexcept {
return ht_.begin(n); // 调用底层 hashtable 的 begin 方法,返回指定桶的本地常量迭代器
}
const_local_iterator cbegin(size_type n) const noexcept {
return ht_.cbegin(n); // 调用底层 hashtable 的 cbegin 方法,返回指定桶的本地常量迭代器
}
// 返回指定桶的本地迭代器 //
// 返回指定桶的本地迭代器,用于遍历桶中的元素
local_iterator end(size_type n) noexcept {
return ht_.end(n); // 调用底层 hashtable 的 end 方法,获取指定桶的结束迭代器
}
// 返回指定桶的本地常量迭代器,用于遍历桶中的元素
const_local_iterator end(size_type n) const noexcept {
return ht_.end(n); // 调用底层 hashtable 的 end 方法,获取指定桶的结束常量迭代器
}
// 返回指定桶的本地常量迭代器,用于遍历桶中的元素
const_local_iterator cend(size_type n) const noexcept {
return ht_.cend(n); // 调用底层 hashtable 的 cend 方法,获取指定桶的结束常量迭代器
}
// 返回桶的数量,表示容器中桶的总数
size_type bucket_count() const noexcept {
return ht_.bucket_count(); // 调用底层 hashtable 的 bucket_count 方法,获取桶的数量
}
// 返回桶的最大数量,表示容器中桶的最大可能数量
size_type max_bucket_count() const noexcept {
return ht_.max_bucket_count(); // 调用底层 hashtable 的 max_bucket_count 方法,获取最大桶数量
}
// 返回指定桶的大小,即桶中元素的数量
size_type bucket_size(size_type n) const noexcept {
return ht_.bucket_size(n); // 调用底层 hashtable 的 bucket_size 方法,获取指定桶的大小
}
// 返回给定键的元素所在的桶编号
size_type bucket(const key_type& key) const {
return ht_.bucket(key); // 调用底层 hashtable 的 bucket 方法,获取键所在桶的编号
}
// 哈希策略相关操作
// 返回当前负载因子,即容器中元素数量与桶数量的比值
float load_factor() const noexcept {
return ht_.load_factor(); // 调用底层 hashtable 的 load_factor 方法,获取当前负载因子
}
// 返回最大负载因子,即容器允许的最大负载因子
float max_load_factor() const noexcept {
return ht_.max_load_factor(); // 调用底层 hashtable 的 max_load_factor 方法,获取最大负载因子
}
// 设置最大负载因子,用于调整容器的负载因子上限
void max_load_factor(float ml) {
ht_.max_load_factor(ml); // 调用底层 hashtable 的 max_load_factor 方法,设置最大负载因子
}
// 重新哈希,调整桶的数量以优化性能
void rehash(size_type count) {
ht_.rehash(count); // 调用底层 hashtable 的 rehash 方法,重新哈希并调整桶的数量
}
// 调整桶的数量以至少容纳指定数量的元素
void reserve(size_type count) {
ht_.reserve(count); // 调用底层 hashtable 的 reserve 方法,调整桶的数量以至少容纳指定数量的元素
}
// 返回哈希函数,用于计算键的哈希值
hasher hash_fcn() const {
return ht_.hash_fcn(); // 调用底层 hashtable 的 hash_fcn 方法,获取哈希函数
}
// 返回键比较函数,用于比较键的相等性
key_equal key_eq() const {
return ht_.key_eq(); // 调用底层 hashtable 的 key_eq 方法,获取键比较函数
}
// 友元函数,重载比较操作符 ==,用于比较两个 unordered_multimap 对象是否相等
friend bool operator==(const unordered_multimap& lhs, const unordered_multimap& rhs) {
return lhs.ht_.equal_range_multi(rhs.ht_); // 调用底层 hashtable 的 equal_range_multi 方法比较两个容器的元素是否相等
}
// 友元函数,重载比较操作符 !=,用于比较两个 unordered_multimap 对象是否不相等
friend bool operator!=(const unordered_multimap& lhs, const unordered_multimap& rhs) {
return !lhs.ht_.equal_range_multi(rhs.ht_); // 直接返回 == 操作符的相反结果
}
// 重载比较操作符 ==,模板特化,使得可以不写明完整类型定义直接比较两个 unordered_multimap 对象是否相等
template <class Key, class T, class Hash, class KeyEqual>
bool operator==(const unordered_multimap<Key, T, Hash, KeyEqual>& lhs,
const unordered_multimap<Key, T, Hash, KeyEqual>& rhs) {
return lhs == rhs; // 调用友元函数实现的比较逻辑
}
// 重载比较操作符 !=,模板特化,使得可以不写明完整类型定义直接比较两个 unordered_multimap 对象是否不相等
template <class Key, class T, class Hash, class KeyEqual>
bool operator!=(const unordered_multimap<Key, T, Hash, KeyEqual>& lhs,
const unordered_multimap<Key, T, Hash, KeyEqual>& rhs) {
return lhs != rhs; // 调用友元函数实现的比较逻辑
}
// 重载 mystl 的 swap 函数,模板特化,使得可以不写明完整类型定义直接交换两个 unordered_multimap 对象的内容
template <class Key, class T, class Hash, class KeyEqual>
void swap(unordered_multimap<Key, T, Hash, KeyEqual>& lhs,
unordered_multimap<Key, T, Hash, KeyEqual>& rhs) {
lhs.swap(rhs); // 调用 unordered_multimap 类的 swap 成员函数
}
} // namespace mystl 结束命名空间 mystl
#endif // !MYTINYSTL_UNORDERED_MAP_H_ 结束头文件保护

@ -1,750 +0,0 @@
/*这段代码定义了两个模板类 unordered_set 和 unordered_multiset它们都是基于哈希表hashtable实现的关联容器用于存储键值。以下是这两个类的主要功能和区别
unordered_set
unordered_set
使
emplace insert
erase
clear
find equal_range
== != unordered_set
unordered_multiset
unordered_set unordered_multiset
使
emplace insert
erase
clear
find equal_range
unordered_set
unordered_multiset
使*/
namespace mystl // 定义命名空间 mystl用于封装自定义的 STL 组件
{
// 模板类 unordered_set用于存储不允许重复的键值
// 参数一代表键值类型,参数二代表哈希函数,默认使用 mystl::hash
// 参数三代表键值比较方式,默认使用 mystl::equal_to。
template <class Key, class Hash = mystl::hash<Key>, class KeyEqual = mystl::equal_to<Key>>
class unordered_set
{
private:
// 使用 hashtable 作为底层机制来存储数据
typedef hashtable<Key, 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::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_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 <class InputIterator>
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<size_type>(mystl::distance(first, last))), hash, equal)
{
for (; first != last; ++first)
ht_.insert_unique_noresize(*first); // 插入元素,不重新分配空间
}
// 列表初始化构造函数
unordered_set(std::initializer_list<value_type> ilist,
const size_type bucket_count = 100,
const Hash& hash = Hash(),
const KeyEqual& equal = KeyEqual())
:ht_(mystl::max(bucket_count, static_cast<size_type>(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<value_type> 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(); }
};
// 修改容器操作
// emplace / emplace_hint
// emplace 函数用于在容器中直接构造一个新元素,参数是构造函数需要的参数
// emplace_hint 函数与 emplace 类似,但提供了一个迭代器 hint 作为插入位置的提示
template <class ...Args>
pair<iterator, bool> emplace(Args&& ...args)
{
// 调用底层哈希表的 emplace_unique 函数,尝试插入一个新元素
// mystl::forward 用于完美转发参数,保留参数的引用类型
return ht_.emplace_unique(mystl::forward<Args>(args)...);
}
template <class ...Args>
iterator emplace_hint(const_iterator hint, Args&& ...args)
{
// 调用底层哈希表的 emplace_unique_use_hint 函数,尝试插入一个新元素
// hint 作为插入位置的提示,可以提高插入效率
return ht_.emplace_unique_use_hint(hint, mystl::forward<Args>(args)...);
}
// insert
// insert 函数用于将一个元素插入容器中,如果元素已存在则不插入
pair<iterator, bool> insert(const value_type& value)
{
// 调用底层哈希表的 insert_unique 函数,尝试插入一个新元素
return ht_.insert_unique(value);
}
pair<iterator, bool> insert(value_type&& value)
{
// 调用底层哈希表的 emplace_unique 函数,尝试插入一个新元素
// mystl::move 用于将右值引用转换为左值引用,避免不必要的复制
return ht_.emplace_unique(mystl::move(value));
}
iterator insert(const_iterator hint, const value_type& value)
{
// 调用底层哈希表的 insert_unique_use_hint 函数,尝试插入一个新元素
// hint 作为插入位置的提示,可以提高插入效率
return ht_.insert_unique_use_hint(hint, value);
}
iterator insert(const_iterator hint, value_type&& value)
{
// 调用底层哈希表的 emplace_unique_use_hint 函数,尝试插入一个新元素
// hint 作为插入位置的提示,可以提高插入效率
// mystl::move 用于将右值引用转换为左值引用,避免不必要的复制
return ht_.emplace_unique_use_hint(hint, mystl::move(value));
}
template <class InputIterator>
void insert(InputIterator first, InputIterator last)
{
// 调用底层哈希表的 insert_unique 函数,将一个范围内的元素插入容器中
ht_.insert_unique(first, last);
}
// erase / clear
// erase 函数用于从容器中删除元素
void erase(iterator it)
{
ht_.erase(it); // 调用底层哈希表的 erase 函数,删除指定迭代器位置的元素
}
erase(iterator first, iterator last)
{
ht_.erase(first, last); // 调用底层哈希表的 erase 函数,删除指定范围的元素
}
// 删除指定键的所有元素,并返回被删除的元素数量
size_type erase(const key_type& key)
{
return ht_.erase_unique(key); // 调用底层哈希表的 erase_unique 函数,删除指定键的所有元素
}
// 清空容器
void clear()
{
ht_.clear(); // 调用底层哈希表的 clear 函数,清空容器中的所有元素
}
```cpp
template <class InputIterator>
void insert(InputIterator first, InputIterator last)
{
// 将迭代器范围内的元素插入到容器中,利用底层哈希表的插入功能
ht_.insert_unique(first, last);
}
// 删除指定迭代器位置的元素
void erase(iterator it)
{
// 调用底层哈希表的 erase 方法,移除指定位置的元素
ht_.erase(it);
}
// 删除指定范围内的元素
void erase(iterator first, iterator last)
{
// 调用底层哈希表的 erase 方法,移除指定范围内的元素
ht_.erase(first, last);
}
// 删除所有指定键的元素,并返回删除的元素数量
size_type erase(const key_type& key)
{
// 调用底层哈希表的 erase_unique 方法,移除所有指定键的元素
return ht_.erase_unique(key);
}
// 清空容器中的所有元素
void clear()
{
// 调用底层哈希表的 clear 方法,清空容器
ht_.clear();
}
// 交换两个 unordered_set 容器的内容
void swap(unordered_set& other) noexcept
{
// 调用底层哈希表的 swap 方法,交换两个容器的内容
ht_.swap(other.ht_);
}
// 返回指定键值的元素个数
size_type count(const key_type& key) const
{
// 调用底层哈希表的 count 方法,统计指定键值的元素个数
return ht_.count(key);
}
// 查找指定键值的元素,并返回指向该元素的迭代器
iterator find(const key_type& key)
{
// 调用底层哈希表的 find 方法,查找指定键值的元素
return ht_.find(key);
}
// 查找指定键值的元素,并返回指向该元素的常量迭代器
const_iterator find(const key_type& key) const
{
// 调用底层哈希表的 find 方法,查找指定键值的元素
return ht_.find(key);
}
// 查找指定键值的元素范围,并返回一个迭代器对
pair<iterator, iterator> equal_range(const key_type& key)
{
// 调用底层哈希表的 equal_range_unique 方法,查找指定键值的元素范围
return ht_.equal_range_unique(key);
}
// 查找指定键值的元素范围,并返回一个常量迭代器对
pair<const_iterator, const_iterator> equal_range(const key_type& key) const
{
// 调用底层哈希表的 equal_range_unique 方法,查找指定键值的元素范围
return ht_.equal_range_unique(key);
}
// 返回指向指定桶开始的迭代器
local_iterator begin(size_type n) noexcept
{
// 调用底层哈希表的 begin 方法,获取指定桶的开始迭代器
return ht_.begin(n);
}
// 返回指向指定桶开始的常量迭代器
const_local_iterator begin(size_type n) const noexcept
{
// 调用底层哈希表的 begin 方法,获取指定桶的开始常量迭代器
return ht_.begin(n);
}
// 返回指向指定桶开始的常量迭代器
const_local_iterator cbegin(size_type n) const noexcept
{
// 调用底层哈希表的 cbegin 方法,获取指定桶的开始常量迭代器
return ht_.cbegin(n);
}
// 返回指向指定桶结束的迭代器
local_iterator end(size_type n) noexcept
{
// 调用底层哈希表的 end 方法,获取指定桶的结束迭代器
return ht_.end(n);
}
// 返回指向指定桶结束的常量迭代器
const_local_iterator end(size_type n) const noexcept
{
// 调用底层哈希表的 end 方法,获取指定桶的结束常量迭代器
return ht_.end(n);
}
// 返回指向指定桶结束的常量迭代器
const_local_iterator cend(size_type n) const noexcept
{
// 调用底层哈希表的 cend 方法,获取指定桶的结束常量迭代器
return ht_.cend(n);
}
// 返回容器中的桶数量
size_type bucket_count() const noexcept
{
// 调用底层哈希表的 bucket_count 方法,获取桶的数量
return ht_.bucket_count();
}
// 返回容器中允许的最大桶数量
size_type max_bucket_count() const noexcept
{
// 调用底层哈希表的 max_bucket_count 方法,获取最大桶数量
return ht_.max_bucket_count();
}
// 返回指定桶中的元素数量
size_type bucket_size(size_type n) const noexcept
{
// 调用底层哈希表的 bucket_size 方法,获取指定桶的元素数量
return ht_.bucket_size(n);
}
// 返回指定键值所在的桶的索引
size_type bucket(const key_type& key) const
{
// 调用底层哈希表的 bucket 方法,获取键值所在桶的索引
return ht_.bucket(key);
}
// 返回容器的负载因子,即元素数量与桶数量的比值
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:
// 重载相等操作符,用于比较两个 unordered_set 容器是否相等
friend bool operator==(const unordered_set& lhs, const unordered_set& rhs)
{
// 调用底层哈希表的 equal_range_unique 函数,比较两个容器的元素是否相等
return lhs.ht_.equal_range_unique(rhs.ht_);
}
// 重载不等操作符,用于比较两个 unordered_set 容器是否不相等
friend bool operator!=(const unordered_set& lhs, const unordered_set& rhs)
{
// 利用相等操作符的结果来判断两个容器是否不相等
return !(lhs == rhs);
}
/*****************************************************************************************/
// 模板类 unordered_multiset用于存储允许重复的键值。
// 参数一代表键值类型,参数二代表哈希函数,默认使用 mystl::hash
// 参数三代表键值比较方式,默认使用 mystl::equal_to。
template <class Key, class Hash = mystl::hash<Key>, class KeyEqual = mystl::equal_to<Key>>
class unordered_multiset
{
private:
// 使用 hashtable 作为底层机制来存储数据。
typedef hashtable<Key, 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::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 <class InputIterator>
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<size_type>(mystl::distance(first, last))), hash, equal)
{
for (; first != last; ++first)
ht_.insert_multi_noresize(*first); // 插入元素,不重新分配空间
}
// 列表初始化构造函数
unordered_multiset(std::initializer_list<value_type> ilist,
const size_type bucket_count = 100,
const Hash& hash = Hash(),
const KeyEqual& equal = KeyEqual())
:ht_(mystl::max(bucket_count, static_cast<size_type>(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<value_type> 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
// emplace 函数用于在容器中直接构造一个新元素,参数是构造函数需要的参数
// emplace_hint 函数与 emplace 类似,但提供了一个迭代器 hint 作为插入位置的提示
template <class ...Args>
iterator emplace(Args&& ...args)
{
// 调用底层哈希表的 emplace_multi 函数,尝试插入一个新元素
// mystl::forward 用于完美转发参数,保留参数的引用类型
return ht_.emplace_multi(mystl::forward<Args>(args)...);
}
template <class ...Args>
iterator emplace_hint(const_iterator hint, Args&& ...args)
{
// 调用底层哈希表的 emplace_multi_use_hint 函数,尝试插入一个新元素
// hint 作为插入位置的提示,可以提高插入效率
return ht_.emplace_multi_use_hint(hint, mystl::forward<Args>(args)...);
}
// insert
// insert 函数用于将一个元素插入容器中,允许重复
iterator insert(const value_type& value)
{
// 调用底层哈希表的 insert_multi 函数,插入一个新元素
return ht_.insert_multi(value);
}
iterator insert(value_type&& value)
{
// 调用底层哈希表的 emplace_multi 函数,插入一个新元素
// mystl::move 用于将右值引用转换为左值引用,避免不必要的复制
return ht_.emplace_multi(mystl::move(value));
}
iterator insert(const_iterator hint, const value_type& value)
{
// 调用底层哈希表的 insert_multi_use_hint 函数,插入一个新元素
// hint 作为插入位置的提示,可以提高插入效率
return ht_.insert_multi_use_hint(hint, value);
}
iterator insert(const_iterator hint, value_type&& value)
{
// 调用底层哈希表的 emplace_multi_use_hint 函数,插入一个新元素
// hint 作为插入位置的提示,可以提高插入效率
// mystl::move 用于将右值引用转换为左值引用,避免不必要的复制
return ht_.emplace_multi_use_hint(hint, mystl::move(value));
}
template <class InputIterator>
void insert(InputIterator first, InputIterator last)
{
// 调用底层哈希表的 insert_multi 函数,将一个范围内的元素插入容器中
ht_.insert_multi(first, last);
}
// erase / clear
// erase 函数用于从容器中删除元素
void erase(iterator it)
{
// 调用底层哈希表的 erase 函数,删除指定位置的元素
ht_.erase(it);
}
void erase(iterator first, iterator last)
{
// 调用底层哈希表的 erase 函数,删除指定范围内的元素
ht_.erase(first, last);
}
size_type erase(const key_type& key)
{
// 调用底层哈希表的 erase_multi 函数,删除指定键值的所有元素
return ht_.erase_multi(key);
}
void clear()
{
// 调用底层哈希表的 clear 函数,清空容器中的所有元素
ht_.clear();
}
void swap(unordered_multiset& other) noexcept
{
// 调用底层哈希表的 swap 函数,交换两个容器的内容
ht_.swap(other.ht_);
}
// 查找相关
// count 函数用于返回指定键值的元素个数
size_type count(const key_type& key) const
{
// 调用底层哈希表的 count 函数,返回指定键值的元素个数
return ht_.count(key);
}
// find 函数用于查找指定键值的元素,并返回指向该元素的迭代器
iterator find(const key_type& key)
{
// 调用底层哈希表的 find 函数,查找指定键值的元素
return ht_.find(key);
}
const_iterator find(const key_type& key) const
{
// 调用底层哈希表的 find 函数,查找指定键值的元素
return ht_.find(key);
}
// equal_range 函数用于查找指定键值的元素范围,并返回一个迭代器对
pair<iterator, iterator> equal_range(const key_type& key)
{
// 调用底层哈希表的 equal_range_multi 函数,查找指定键值的元素范围
return ht_.equal_range_multi(key);
}
pair<const_iterator, const_iterator> equal_range(const key_type& key) const
{
// 调用底层哈希表的 equal_range_multi 函数,查找指定键值的元素范围
return ht_.equal_range_multi(key);
}
// bucket interface
// begin 函数用于返回指向指定桶的开始的迭代器
local_iterator begin(size_type n) noexcept
{
// 调用底层哈希表的 begin 函数,返回指向指定桶的开始的迭代器
return ht_.begin(n);
}
const_local_iterator begin(size_type n) const noexcept
{
// 调用底层哈希表的 begin 函数,返回指向指定桶的开始的迭代器
return ht_.begin(n);
}
const_local_iterator cbegin(size_type n) const noexcept
{
// 调用底层哈希表的 cbegin 函数,返回指向指定桶的开始的常量迭代器
return ht_.cbegin(n);
}
// end 函数用于返回指向指定桶的结束的迭代器
local_iterator end(size_type n) noexcept
{
// 调用底层哈希表的 end 函数,返回指向指定桶的结束的迭代器
return ht_.end(n);
}
const_local_iterator end(size_type n) const noexcept
{
// 调用底层哈希表的 end 函数,返回指向指定桶的结束的迭代器
return ht_.end(n);
}
const_local_iterator cend(size_type n) const noexcept
{
// 调用底层哈希表的 cend 函数,返回指向指定桶的结束的常量迭代器
return ht_.cend(n);
}
// bucket_count 函数用于返回容器中的桶数量
size_type bucket_count() const noexcept
{
// 调用底层哈希表的 bucket_count 函数,返回容器中的桶数量
return ht_.bucket_count();
}
// max_bucket_count 函数用于返回容器中允许的最大桶数量。
size_type max_bucket_count() const noexcept
{
// 调用底层哈希表的 max_bucket_count 函数,返回容器中允许的最大桶数量。
return ht_.max_bucket_count(); //
}
// bucket_size 函数用于返回指定桶中的元素数量。 //
size_type bucket_size(size_type n) const noexcept
{ //
// 调用底层哈希表的 bucket_size 函数,返回指定桶中的元素数量。
return ht_.bucket_size(n);
}
//
// bucket 函数用于返回指定键值所在的桶的索引。
size_type bucket(const ke //

@ -1,345 +0,0 @@
#ifndef MYTINYSTL_UTIL_H_//
// 防止头文件被重复包含的宏定义开始//
#define MYTINYSTL_UTIL_H_//
// 防止头文件被重复包含的宏定义结束//
//
#include <cstddef>//
// 包含标准库中的cstddef头文件通常用于定义一些基本类型如size_t等//
//
#include "type_traits.h"//
// 包含自定义的type_traits头文件用于提供类型特征支持//
//
namespace mystl//
// 定义命名空间mystl用于封装自定义的STL实现//
//
{//
//
template <class T>//
typename std::remove_reference<T>::type&& move(T&& arg) noexcept//
// 定义move函数模板用于将参数arg转换为右值引用//
{//
return static_cast<typename std::remove_reference<T>::type&&>(arg);//
// 使用static_cast将arg转换为右值引用并返回//
}//
//
template <class T>//
T&& forward(typename std::remove_reference<T>::type& arg) noexcept//
// 定义forward函数模板的重载版本用于完美转发左值引用//
{//
return static_cast<T&&>(arg);//
// 使用static_cast将arg转换为T类型的右值引用并返回//
}//
//
template <class T>//
T&& forward(typename std::remove_reference<T>::type&& arg) noexcept//
// 定义forward函数模板的重载版本用于完美转发右值引用//
{//
static_assert(!std::is_lvalue_reference<T>::value, "bad forward");//
// 静态断言确保T不是左值引用类型否则编译报错//
return static_cast<T&&>(arg);//
// 使用static_cast将arg转换为T类型的右值引用并返回//
}//
//
template <class Tp>//
void swap(Tp& lhs, Tp& rhs)//
// 定义swap函数模板用于交换两个变量的值//
{//
auto tmp(mystl::move(lhs));//
// 使用move将lhs转换为右值引用并存储在tmp中//
lhs = mystl::move(rhs);//
// 将rhs的值赋给lhs//
rhs = mystl::move(tmp);//
// 将tmp的值赋给rhs//
}//
//
template <class ForwardIter1, class ForwardIter2>//
ForwardIter2 swap_range(ForwardIter1 first1, ForwardIter1 last1, ForwardIter2 first2)//
// 定义swap_range函数模板用于交换两个范围内的元素//
{//
for (; first1 != last1; ++first1, (void) ++first2)//
// 遍历两个范围内的元素//
mystl::swap(*first1, *first2);//
// 交换对应位置的元素//
return first2;//
// 返回第二个范围的结束迭代器//
}//
//
template <class Tp, size_t N>//
void swap(Tp(&a)[N], Tp(&b)[N])//
// 定义swap函数模板的重载版本用于交换两个固定大小数组的值//
{//
mystl::swap_range(a, a + N, b);//
// 使用swap_range函数交换两个数组的元素//
}//
//
template <class Ty1, class Ty2>//
struct pair//
// 定义pair结构体模板用于存储两个值//
{//
typedef Ty1 first_type;//
typedef Ty2 second_type;//
// 定义类型别名,分别表示第一个和第二个值的类型//
//
first_type first; //
second_type second; //
// 定义两个成员变量,分别存储第一个和第二个值//
//
//
template <class Other1 = Ty1, class Other2 = Ty2,//
typename = typename std::enable_if<//
std::is_default_constructible<Other1>::value &&//
std::is_default_constructible<Other2>::value, void>::type>//
constexpr pair()//
: first(), second()//
// 定义默认构造函数使用默认构造方式初始化first和second//
{//
}//
//
template <class U1 = Ty1, class U2 = Ty2,//
typename std::enable_if<//
std::is_copy_constructible<U1>::value &&//
std::is_copy_constructible<U2>::value &&//
std::is_convertible<const U1&, Ty1>::value &&//
std::is_convertible<const U2&, Ty2>::value, int>::type = 0>//
constexpr pair(const Ty1& a, const Ty2& b)//
: first(a), second(b)//
// 定义拷贝构造函数使用拷贝构造方式初始化first和second//
{//
}//
//
template <class U1 = Ty1, class U2 = Ty2,//
typename std::enable_if<//
std::is_copy_constructible<U1>::value &&//
std::is_copy_constructible<U2>::value &&//
(!std::is_convertible<const U1&, Ty1>::value ||//
!std::is_convertible<const U2&, Ty2>::value), int>::type = 0>//
explicit constexpr pair(const Ty1& a, const Ty2& b)//
: first(a), second(b)//
// 定义显式拷贝构造函数使用拷贝构造方式初始化first和second//
{//
}//
//
pair(const pair& rhs) = default;//
// 默认拷贝构造函数//
//
pair(pair&& rhs) = default;//
// 默认移动构造函数//
//
template <class Other1, class Other2,//
typename std::enable_if<//
std::is_constructible<Ty1, Other1>::value &&//
std::is_constructible<Ty2, Other2>::value &&//
std::is_convertible<Other1&&, Ty1>::value &&//
std::is_convertible<Other2&&, Ty2>::value, int>::type = 0>//
constexpr pair(Other1&& a, Other2&& b)//
: first(mystl::forward<Other1>(a)),//
second(mystl::forward<Other2>(b))//
// 定义构造函数使用完美转发初始化first和second//
{//
}//
//
template <class Other1, class Other2,//
typename std::enable_if<//
std::is_constructible<Ty1, Other1>::value &&//
std::is_constructible<Ty2, Other2>::value &&//
(!std::is_convertible<Other1, Ty1>::value ||//
!std::is_convertible<Other2, Ty2>::value), int>::type = 0>//
explicit constexpr pair(Other1&& a, Other2&& b)//
: first(mystl::forward<Other1>(a)),//
second(mystl::forward<Other2>(b))//
// 定义显式构造函数使用完美转发初始化first和second//
{//
}//
//
template <class Other1, class Other2,//
typename std::enable_if<//
std::is_constructible<Ty1, const Other1&>::value &&//
std::is_constructible<Ty2, const Other2&>::value &&//
std::is_convertible<const Other1&, Ty1>::value &&//
std::is_convertible<const Other2&, Ty2>::value, int>::type = 0>//
constexpr pair(const pair<Other1, Other2>& other)//
: first(other.first),//
second(other.second)//
// 定义拷贝构造函数使用拷贝构造方式初始化first和second//
{//
}//
//
template <class Other1, class Other2,//
typename std::enable_if<//
std::is_constructible<Ty1, const Other1&>::value &&//
std::is_constructible<Ty2, const Other2&>::value &&//
(!std::is_convertible<const Other1&, Ty1>::value ||//
!std::is_convertible<const Other2&, Ty2>::value), int>::type = 0>//
explicit constexpr pair(const pair<Other1 &other)//
: first(other.first),//
second(other.second)//
// 定义显式拷贝构造函数使用拷贝构造方式初始化first和second//
{//
}//
//
template <class Other1, class Other2,//
typename std::enable_if<//
std::is_constructible<Ty1, Other1>::value &&//
std::is_constructible<Ty2, Other2>::value &&//
std::is_convertible<Other1, Ty1>::value &&//
std::is_convertible<Other2, Ty2>::value, int>::type = 0>//
constexpr pair(pair<Other1, Other2>&& other)//
: first(mystl::forward<Other1>(other.first)),//
second(mystl::forward<Other2>(other.second))//
// 定义构造函数使用完美转发初始化first和second//
{//
}//
//
template <class Other1, class Other2,//
typename std::enable_if<//
std::is_constructible<Ty1, Other1>::value &&//
std::is_constructible<Ty2, Other2>::value &&//
(!std::is_convertible<Other1, Ty1>::value ||//
!std::is_convertible<Other2, Ty2>::value), int>::type = 0>//
explicit constexpr pair(pair<Other1, Other2>&& other)//
: first(mystl::forward<Other1>(other.first)),//
second(mystl::forward<Other2>(other.second))//
// 继续使用完美转发初始化second成员变量//
{//
}//
//
pair& operator=(const pair& rhs)//
// 定义拷贝赋值运算符//
{//
if (this != &rhs)//
// 如果不是自赋值//
{//
first = rhs.first;//
// 将rhs的first赋值给当前对象的first//
second = rhs.second;//
// 将rhs的second赋值给当前对象的second//
}//
return *this;//
// 返回当前对象的引用//
}//
//
pair& operator=(pair&& rhs)//
// 定义移动赋值运算符//
{//
if (this != &rhs)//
// 如果不是自赋值//
{//
first = mystl::move(rhs.first);//
// 将rhs的first移动赋值给当前对象的first//
second = mystl::move(rhs.second);//
// 将rhs的second移动赋值给当前对象的second//
}//
return *this;//
// 返回当前对象的引用//
}//
//
template <class Other1, class Other2>//
pair& operator=(const pair<Other1, Other2>& other)//
// 定义模板化的拷贝赋值运算符//
{//
first = other.first;//
// 将other的first赋值给当前对象的first//
second = other.second;//
// 将other的second赋值给当前对象的second//
return *this;//
// 返回当前对象的引用//
}//
//
template <class Other1, class Other2>//
pair& operator=(pair<Other1, Other2>&& other)//
// 定义模板化的移动赋值运算符//
{//
first = mystl::forward<Other1>(other.first);//
// 将other的first移动赋值给当前对象的first//
second = mystl::forward<Other2>(other.second);//
// 将other的second移动赋值给当前对象的second//
return *this;//
// 返回当前对象的引用//
}//
//
~pair() = default;//
// 默认析构函数//
//
void swap(pair& other)//
// 定义成员函数swap用于交换两个pair对象的成员变量//
{//
if (this != &other)//
// 如果不是自交换//
{//
mystl::swap(first, other.first);//
// 交换first成员变量//
mystl::swap(second, other.second);//
// 交换second成员变量//
}//
}//
//
};//
//
template <class Ty1, class Ty2>//
bool operator==(const pair<Ty1, Ty2>& lhs, const pair<Ty1, Ty2>& rhs)//
// 定义全局函数operator==用于比较两个pair对象是否相等//
{//
return lhs.first == rhs.first && lhs.second == rhs.second;//
// 如果两个pair对象的first和second都相等则认为两个pair对象相等//
}//
//
template <class Ty1, class Ty2>//
bool operator<(const pair<Ty1, Ty2>& lhs, const pair<Ty1, Ty2>& rhs)//
// 定义全局函数operator<用于比较两个pair对象的大小//
{//
return lhs.first < rhs.first || (lhs.first == rhs.first && lhs.second < rhs.second);//
// 如果lhs的first小于rhs的first或者lhs的first等于rhs的first且lhs的second小于rhs的second则认为lhs小于rhs//
}//
//
template <class Ty1, class Ty2>//
bool operator!=(const pair<Ty1, Ty2>& lhs, const pair<Ty1, Ty2>& rhs)//
// 定义全局函数operator!=用于比较两个pair对象是否不相等//
{//
return !(lhs == rhs);//
// 如果两个pair对象不相等则返回true//
}//
//
template <class Ty1, class Ty2>//
bool operator>(const pair<Ty1, Ty2>& lhs, const pair<Ty1, Ty2>& rhs)//
// 定义全局函数operator>用于比较两个pair对象的大小//
{//
return rhs < lhs;//
// 如果rhs小于lhs则认为lhs大于rhs//
}//
//
template <class Ty1, class Ty2>//
bool operator<=(const pair<Ty1, Ty2>& lhs, const pair<Ty1, Ty2>& rhs)//
// 定义全局函数operator<=用于比较两个pair对象的大小//
{//
return !(rhs < lhs);//
// 如果rhs不小于lhs则认为lhs小于等于rhs//
}//
//
template <class Ty1, class Ty2>//
bool operator>=(const pair<Ty1, Ty2>& lhs, const pair<Ty1, Ty2>& rhs)//
// 定义全局函数operator>=用于比较两个pair对象的大小//
{//
return !(lhs < rhs);//
// 如果lhs不小于rhs则认为lhs大于等于rhs//
}//
//
template <class Ty1, class Ty2>//
void swap(pair<Ty1, Ty2>& lhs, pair<Ty1, Ty2>& rhs)//
// 定义全局函数swap用于交换两个pair对象的成员变量//
{//
lhs.swap(rhs);//
// 调用pair对象的成员函数swap进行交换//
}//
//
template <class Ty1, class Ty2>//
pair<Ty1, Ty2> make_pair(Ty1&& first, Ty2&& second)//
// 定义全局函数make_pair用于创建pair对象//
{//
return pair<Ty1, Ty2>(mystl::forward<Ty1>(first), mystl::forward<Ty2>(second));//
// 使用完美转发创建pair对象并返回//
}//
//
} // namespace mystl//
//
#endif // MYTINYSTL_UTIL_H_//
// 防止头文件被重复包含的宏定义结束//

@ -1,936 +0,0 @@
#ifndef MYTINYSTL_VECTOR_H_
#define MYTINYSTL_VECTOR_H_
// 这个头文件包含一个模板类 vector
// vector : 向量
// notes:
//
// 异常保证:
// mystl::vecotr<T> 满足基本异常保证,部分函数无异常保证,并对以下函数做强异常安全保证:
// * emplace
// * emplace_back
// * push_back
// 当 std::is_nothrow_move_assignable<T>::value == true 时,以下函数也满足强异常保证:
// * reserve
// * resize
// * insert
#include <initializer_list>
#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 T>
class vector
{
static_assert(!std::is_same<bool, T>::value, "vector<bool> is abandoned in mystl");
public:
// vector 的嵌套型别定义
typedef mystl::allocator<T> allocator_type;
typedef mystl::allocator<T> 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<iterator> reverse_iterator;
typedef mystl::reverse_iterator<const_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 <class Iter, typename std::enable_if<
mystl::is_input_iterator<Iter>::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<value_type> ilist)
{
range_init(ilist.begin(), ilist.end());
}
vector& operator=(const vector& rhs);
vector& operator=(vector&& rhs) noexcept;
vector& operator=(std::initializer_list<value_type> 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<size_type>(end_ - begin_); }
size_type max_size() const noexcept
{ return static_cast<size_type>(-1) / sizeof(T); }
size_type capacity() const noexcept
{ return static_cast<size_type>(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<T>::at() subscript out of range");
return (*this)[n];
}
const_reference at(size_type n) const
{
THROW_OUT_OF_RANGE_IF(!(n < size()), "vector<T>::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 <class Iter, typename std::enable_if<
mystl::is_input_iterator<Iter>::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<value_type> il)
{ copy_assign(il.begin(), il.end(), mystl::forward_iterator_tag{}); }
// emplace / emplace_back
template <class... Args>
iterator emplace(const_iterator pos, Args&& ...args);
template <class... Args>
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<iterator>(pos), n, value);
}
template <class Iter, typename std::enable_if<
mystl::is_input_iterator<Iter>::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<iterator>(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 <class Iter>
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 <class IIter>
void copy_assign(IIter first, IIter last, input_iterator_tag);
template <class FIter>
void copy_assign(FIter first, FIter last, forward_iterator_tag);
// reallocate
template <class... Args>
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 <class IIter>
void copy_insert(iterator pos, IIter first, IIter last);
// shrink_to_fit
void reinsert(size_type size);
};
/*****************************************************************************************/
// 复制赋值操作符
template <class T>
vector<T>& vector<T>::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 <class T>
vector<T>& vector<T>::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 <class T>
void vector<T>::reserve(size_type n)
{
if (capacity() < n)
{
THROW_LENGTH_ERROR_IF(n > max_size(),
"n can not larger than max_size() in vector<T>::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 <class T>
void vector<T>::shrink_to_fit()
{
if (end_ < cap_)
{
reinsert(size());
}
}
// 在 pos 位置就地构造元素,避免额外的复制或移动开销
template <class T>
template <class ...Args>
typename vector<T>::iterator
vector<T>::emplace(const_iterator pos, Args&& ...args)
{
MYSTL_DEBUG(pos >= begin() && pos <= end());
iterator xpos = const_cast<iterator>(pos);
const size_type n = xpos - begin_;
if (end_ != cap_ && xpos == end_)
{
data_allocator::construct(mystl::address_of(*end_), mystl::forward<Args>(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>(args)...);
end_ = new_end;
}
else
{
reallocate_emplace(xpos, mystl::forward<Args>(args)...);
}
return begin() + n;
}
// 在尾部就地构造元素,避免额外的复制或移动开销
template <class T>
template <class ...Args>
void vector<T>::emplace_back(Args&& ...args)
{
if (end_ < cap_)
{
data_allocator::construct(mystl::address_of(*end_), mystl::forward<Args>(args)...);
++end_;
}
else
{
reallocate_emplace(end_, mystl::forward<Args>(args)...);
}
}
// 在尾部插入元素
template <class T>
void vector<T>::push_back(const value_type& value)
{
if (end_ != cap_)
{
data_allocator::construct(mystl::address_of(*end_), value);
++end_;
}
else
{
reallocate_insert(end_, value);
}
}
// 弹出尾部元素
template <class T>
void vector<T>::pop_back()
{
MYSTL_DEBUG(!empty());
data_allocator::destroy(end_ - 1);
--end_;
}
// 在 pos 处插入元素
template <class T>
typename vector<T>::iterator
vector<T>::insert(const_iterator pos, const value_type& value)
{
MYSTL_DEBUG(pos >= begin() && pos <= end());
iterator xpos = const_cast<iterator>(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 <class T>
typename vector<T>::iterator
vector<T>::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 <class T>
typename vector<T>::iterator
vector<T>::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 <class T>
void vector<T>::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 <class T>
void vector<T>::swap(vector<T>& 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 <class T>
void vector<T>::try_init() noexcept
{
try
{
begin_ = data_allocator::allocate(16);
end_ = begin_;
cap_ = begin_ + 16;
}
catch (...)
{
begin_ = nullptr;
end_ = nullptr;
cap_ = nullptr;
}
}
// init_space 函数
template <class T>
void vector<T>::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 <class T>
void vector<T>::
fill_init(size_type n, const value_type& value)
{
const size_type init_size = mystl::max(static_cast<size_type>(16), n);
init_space(n, init_size);
mystl::uninitialized_fill_n(begin_, n, value);
}
// range_init 函数
template <class T>
template <class Iter>
void vector<T>::
range_init(Iter first, Iter last)
{
const size_type len = mystl::distance(first, last);
const size_type init_size = mystl::max(len, static_cast<size_type>(16));
init_space(len, init_size);
mystl::uninitialized_copy(first, last, begin_);
}
// destroy_and_recover 函数
template <class T>
void vector<T>::
destroy_and_recover(iterator first, iterator last, size_type n)
{
data_allocator::destroy(first, last);
data_allocator::deallocate(first, n);
}
// get_new_cap 函数
template <class T>
typename vector<T>::size_type
vector<T>::
get_new_cap(size_type add_size)
{
const auto old_size = capacity();
THROW_LENGTH_ERROR_IF(old_size > max_size() - add_size,
"vector<T>'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<size_type>(16))
: mystl::max(old_size + old_size / 2, old_size + add_size);
return new_size;
}
// fill_assign 函数
template <class T>
void vector<T>::
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 <class T>
template <class IIter>
void vector<T>::
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 <class T>
template <class FIter>
void vector<T>::
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 <class T>
template <class ...Args>
void vector<T>::
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>(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 <class T>
void vector<T>::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 <class T>
typename vector<T>::iterator
vector<T>::
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<size_type>(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 <class T>
template <class IIter>
void vector<T>::
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 <class T>
void vector<T>::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 <class T>
bool operator==(const vector<T>& lhs, const vector<T>& rhs)
{
return lhs.size() == rhs.size() &&
mystl::equal(lhs.begin(), lhs.end(), rhs.begin());
}
template <class T>
bool operator<(const vector<T>& lhs, const vector<T>& rhs)
{
return mystl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
}
template <class T>
bool operator!=(const vector<T>& lhs, const vector<T>& rhs)
{
return !(lhs == rhs);
}
template <class T>
bool operator>(const vector<T>& lhs, const vector<T>& rhs)
{
return rhs < lhs;
}
template <class T>
bool operator<=(const vector<T>& lhs, const vector<T>& rhs)
{
return !(rhs < lhs);
}
template <class T>
bool operator>=(const vector<T>& lhs, const vector<T>& rhs)
{
return !(lhs < rhs);
}
// 重载 mystl 的 swap
template <class T>
void swap(vector<T>& lhs, vector<T>& rhs)
{
lhs.swap(rhs);
}
} // namespace mystl
#endif // !MYTINYSTL_VECTOR_H_

@ -1,101 +0,0 @@
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).

@ -1,4 +0,0 @@
include_directories(${PROJECT_SOURCE_DIR}/MyTinySTL)
set(APP_SRC test.cpp)
set(EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/bin)
add_executable(stltest ${APP_SRC})

@ -1,351 +0,0 @@
// ============================================================================
// 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 <unistd.h> // getenv
#include <cstring> // strstr
#elif defined(REDBUD_WIN)
#include <Windows.h>
#include <io.h>
#endif
#include <cstdlib>
#include <iostream>
#include <type_traits>
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 <typename T>
using color_return_t = typename std::enable_if<
std::is_same<T, redbud::io::format>::value ||
std::is_same<T, redbud::io::fg>::value ||
std::is_same<T, redbud::io::bg>::value ||
std::is_same<T, redbud::io::hfg>::value ||
std::is_same<T, redbud::io::hbg>::value,
std::ostream&>::type;
template <typename T>
using state_return_t = typename std::enable_if<
std::is_same<T, redbud::io::state>::value,
std::ostream&>::type;
// Sets the format and color of the text.
#if defined(REDBUD_LINUX) || defined(REDBUD_OSX)
template <typename T>
inline color_return_t<T> set_color(std::ostream& os, const T& value)
{
return os << "\033[" << static_cast<int>(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<WORD>(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<WORD>(color) - 40) << 4;
}
inline void set_attributes(redbud::io::hfg color, WORD& state)
{
state &= 0xFFF0;
state |= (static_cast<WORD>(0x8) |
get_rgb(static_cast<WORD>(color) - 90));
}
inline void set_attributes(redbud::io::hbg color, WORD& state)
{
state &= 0xFF0F;
state |= (static_cast<WORD>(0x80) |
get_rgb(static_cast<WORD>(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 <typename T>
inline color_return_t<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 <typename T>
inline details::color_return_t<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 <typename T>
inline details::state_return_t<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_

@ -1,108 +0,0 @@
// ============================================================================
// 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_

@ -1,51 +0,0 @@
单元测试 (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) 中,用了两个类实现了一个简单的测试框架,并定义了大量宏来封装测试过程。</br>
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 以上。**<br>
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.**
测试案例如下:<br>
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).

@ -1,107 +0,0 @@
#ifndef MYTINYSTL_ALGORITHM_PERFORMANCE_TEST_H_ // 预处理指令,防止头文件被重复包含
#define MYTINYSTL_ALGORITHM_PERFORMANCE_TEST_H_ // 定义宏,用于防止头文件被重复包含
// 包含标准库中的算法头文件
#include <algorithm>
// 包含自定义的算法头文件
#include "../MyTinySTL/algorithm.h"
// 包含测试相关的头文件
#include "test.h"
namespace mystl // 命名空间mystl
{
namespace test // 命名空间test
{
namespace algorithm_performance_test // 命名空间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<int>(static_cast<double>(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; // WIDE \
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<int>(static_cast<double>(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; // WIDE \
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 diff suppressed because it is too large Load Diff

Some files were not shown because too many files have changed in this diff Show More

Loading…
Cancel
Save