vs2022 cpp 源码 ＜xstddef＞ 代码笔记

已于 2023-03-28 09:01:40 修改
阅读量1.3k 收藏
点赞数 1
分类专栏： cpp 文章标签： c++ 元编程 模板
于 2023-03-28 08:57:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43172531/article/details/129806957
版权 
_EXPORT_STD template <class _Ty = void>
struct plus {
    using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty;
    using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS          = _Ty;

    _NODISCARD constexpr _Ty operator()(const _Ty& _Left, const _Ty& _Right) const {
        return _Left + _Right;
    }
};

_EXPORT_STD在c++23等高版本允许导出。
_NODISCARD：这是一个属性，用于提示编译器返回值应该被检查。
constexpr 标识常量表达式，编译期计算
前面三个using定义了类型，_CXX17_DEPRECATE_ADAPTOR_TYPEDEFS强调了c++17已废弃

//<xstddef>文件解析笔记
template <class>
// false value attached to a dependent name (for static_assert)
_INLINE_VAR constexpr bool _Always_false = false; //定义const常量

// stuff from <functional> <functional>中的内容
#if _HAS_AUTO_PTR_ETC
_EXPORT_STD template <class _Arg, class _Result>
struct unary_function { // base class for unary functions 一元函数
    using argument_type = _Arg;
    using result_type = _Result;
};
_EXPORT_STD template <class _Arg1, class _Arg2, class _Result>
struct binary_function { // base class for binary functions 二元函数
    using first_argument_type = _Arg1;
    using second_argument_type = _Arg2;
    using result_type = _Result;
};
#endif // _HAS_AUTO_PTR_ETC

template <class _Ty>
_NODISCARD _Ty _Fake_copy_init(_Ty) noexcept;
// _Fake_copy_init<T>(E):
// (1) has type T [decay_t<decltype((E))> if T is deduced],
// (2) is well-formed if and only if E is implicitly convertible to T and T is destructible, and
// (3) is non-throwing if and only if both conversion from decltype((E)) to T and destruction of T are non-throwing.
//（1）具有类型T[decy_T<decltype（（E））>，如果推导出T]，
//（2）是良好形成的，当且仅当E隐式可转换为T，并且T是可破坏的，并且
//（3）是非抛出的，当且仅当从decltype（（E））到T的转换和T的销毁都是非抛出。

_EXPORT_STD template <class _Ty = void>
struct plus {
    _NODISCARD constexpr _Ty operator()(const _Ty& _Left, const _Ty& _Right) const {
        return _Left + _Right;
    }
};
_EXPORT_STD template <class _Ty = void>
struct minus {
    _NODISCARD constexpr _Ty operator()(const _Ty& _Left, const _Ty& _Right) const {
        return _Left - _Right;
    }
};
_EXPORT_STD template <class _Ty = void>
struct multiplies {
    _NODISCARD constexpr _Ty operator()(const _Ty& _Left, const _Ty& _Right) const {
        return _Left * _Right;
    }
};
_EXPORT_STD template <class _Ty = void>
struct equal_to {
    _NODISCARD constexpr bool operator()(const _Ty& _Left, const _Ty& _Right) const
        noexcept(noexcept(_Fake_copy_init<bool>(_Left == _Right))) /* strengthened 加强 */ {
        return _Left == _Right;
    }
};
_EXPORT_STD template <class _Ty = void>
struct not_equal_to {
    _NODISCARD constexpr bool operator()(const _Ty& _Left, const _Ty& _Right) const
        noexcept(noexcept(_Fake_copy_init<bool>(_Left != _Right))) /* strengthened */ {
        return _Left != _Right;
    }
};
_EXPORT_STD template <class _Ty = void>
struct greater {
    _NODISCARD constexpr bool operator()(const _Ty& _Left, const _Ty& _Right) const
        noexcept(noexcept(_Fake_copy_init<bool>(_Left > _Right))) /* strengthened */ {
        return _Left > _Right;
    }
};
_EXPORT_STD template <class _Ty = void>
struct less {
    _NODISCARD constexpr bool operator()(const _Ty& _Left, const _Ty& _Right) const
        noexcept(noexcept(_Fake_copy_init<bool>(_Left < _Right))) /* strengthened */ {
        return _Left < _Right;
    }
};
_EXPORT_STD template <class _Ty = void>
struct greater_equal {
    _NODISCARD constexpr bool operator()(const _Ty& _Left, const _Ty& _Right) const
        noexcept(noexcept(_Fake_copy_init<bool>(_Left >= _Right))) /* strengthened */ {
        return _Left >= _Right;
    }
};
_EXPORT_STD template <class _Ty = void>
struct less_equal {
    _NODISCARD constexpr bool operator()(const _Ty& _Left, const _Ty& _Right) const
        noexcept(noexcept(_Fake_copy_init<bool>(_Left <= _Right))) /* strengthened */ {
        return _Left <= _Right;
    }
}; 
_EXPORT_STD template <class _Ty = void>
struct plus {
    _NODISCARD constexpr _Ty operator()(const _Ty& _Left, const _Ty& _Right) const {
        return _Left + _Right;
    }
};
template <>
struct plus<void> {
    template <class _Ty1, class _Ty2>
    _NODISCARD constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
        noexcept(noexcept(static_cast<_Ty1&&>(_Left) + static_cast<_Ty2&&>(_Right))) // strengthened 加法是noexcept的，函数也是noexcept的
        -> decltype(static_cast<_Ty1&&>(_Left) + static_cast<_Ty2&&>(_Right))  //定义函数返回类型
    {
        return static_cast<_Ty1&&>(_Left) + static_cast<_Ty2&&>(_Right);
    }
    using is_transparent = int;//表示这个函数对象在参数相关查找（ADL）中是透明的。
    //函数对象在参数相关查找（Argument - Dependent Lookup，简称ADL）中是透明的，意味着当使用该函数对象进行函数重载解析时，
    //    编译器会搜索与其参数类型相关的命名空间，而不是仅仅在当前命名空间中进行查找。
    //    例如，在使用该函数对象进行函数重载解析时，编译器会先在_Ty1和_Ty2的命名空间中查找与该函数对象相关的函数，
    //    如果没有找到，则会继续在全局命名空间中查找。因此，该函数对象的存在不会影响函数重载解析的正确性。
    //    函数对象的透明性是C++语言中的一个重要特性，它允许开发者以更加灵活的方式进行函数重载和泛型编程，而不必考虑函数对象的命名空间。
};
template <>
struct minus<void> {
    template <class _Ty1, class _Ty2>
    _NODISCARD constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
        noexcept(noexcept(static_cast<_Ty1&&>(_Left) - static_cast<_Ty2&&>(_Right))) // strengthened
        -> decltype(static_cast<_Ty1&&>(_Left) - static_cast<_Ty2&&>(_Right)) {
        return static_cast<_Ty1&&>(_Left) - static_cast<_Ty2&&>(_Right);
    }
    using is_transparent = int;
};
template <>
struct multiplies<void> {
    template <class _Ty1, class _Ty2>
    _NODISCARD constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
        noexcept(noexcept(static_cast<_Ty1&&>(_Left)* static_cast<_Ty2&&>(_Right))) // strengthened
        -> decltype(static_cast<_Ty1&&>(_Left)* static_cast<_Ty2&&>(_Right)) {
        return static_cast<_Ty1&&>(_Left) * static_cast<_Ty2&&>(_Right);
    }
    using is_transparent = int;
};
template <>
struct equal_to<void> {
    template <class _Ty1, class _Ty2>
    _NODISCARD constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
        noexcept(noexcept(static_cast<_Ty1&&>(_Left) == static_cast<_Ty2&&>(_Right))) // strengthened
        -> decltype(static_cast<_Ty1&&>(_Left) == static_cast<_Ty2&&>(_Right)) {
        return static_cast<_Ty1&&>(_Left) == static_cast<_Ty2&&>(_Right);
    }
    using is_transparent = int;
};
template <>
struct not_equal_to<void> {
    template <class _Ty1, class _Ty2>
    _NODISCARD constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
        noexcept(noexcept(static_cast<_Ty1&&>(_Left) != static_cast<_Ty2&&>(_Right))) // strengthened
        -> decltype(static_cast<_Ty1&&>(_Left) != static_cast<_Ty2&&>(_Right)) {
        return static_cast<_Ty1&&>(_Left) != static_cast<_Ty2&&>(_Right);
    }
    using is_transparent = int;
};
template <>
struct greater<void> {
    template <class _Ty1, class _Ty2>
    _NODISCARD constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
        noexcept(noexcept(static_cast<_Ty1&&>(_Left) > static_cast<_Ty2&&>(_Right))) // strengthened
        -> decltype(static_cast<_Ty1&&>(_Left) > static_cast<_Ty2&&>(_Right)) {
        return static_cast<_Ty1&&>(_Left) > static_cast<_Ty2&&>(_Right);
    }
    using is_transparent = int;
};
template <>
struct less<void> {
    template <class _Ty1, class _Ty2>
    _NODISCARD constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
        noexcept(noexcept(static_cast<_Ty1&&>(_Left) < static_cast<_Ty2&&>(_Right))) // strengthened
        -> decltype(static_cast<_Ty1&&>(_Left) < static_cast<_Ty2&&>(_Right)) {
        return static_cast<_Ty1&&>(_Left) < static_cast<_Ty2&&>(_Right);
    }
    using is_transparent = int;
};
template <>
struct greater_equal<void> {
    template <class _Ty1, class _Ty2>
    _NODISCARD constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
        noexcept(noexcept(static_cast<_Ty1&&>(_Left) >= static_cast<_Ty2&&>(_Right))) // strengthened
        -> decltype(static_cast<_Ty1&&>(_Left) >= static_cast<_Ty2&&>(_Right)) {
        return static_cast<_Ty1&&>(_Left) >= static_cast<_Ty2&&>(_Right);
    }
    using is_transparent = int;
};
template <>
struct less_equal<void> {
    template <class _Ty1, class _Ty2>
    _NODISCARD constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
        noexcept(noexcept(static_cast<_Ty1&&>(_Left) <= static_cast<_Ty2&&>(_Right))) // strengthened
        -> decltype(static_cast<_Ty1&&>(_Left) <= static_cast<_Ty2&&>(_Right)) {
        return static_cast<_Ty1&&>(_Left) <= static_cast<_Ty2&&>(_Right);
    }
    using is_transparent = int;
};
_EXPORT_STD template <class _Ty>
_NODISCARD constexpr _Ty* addressof(_Ty& _Val) noexcept {
    return __builtin_addressof(_Val);
}
_EXPORT_STD template <class _Ty>
const _Ty* addressof(const _Ty&&) = delete; //禁止右值引用的取地址(右值引用没有地址，取地址会导致错误)
template <class _Ptrty>
_NODISCARD constexpr auto _Unfancy(_Ptrty _Ptr) noexcept { // converts from a fancy pointer to a plain pointer 
    return _STD addressof(*_Ptr);//从"高级指针"（fancy pointer）转换为普通指针
}
//template <typename T>
//using FancyPtr = T* const&; // 定义一个"高级指针"类型
//template <typename PtrType>
//void PrintAddress(PtrType ptr) {
//    std::cout << "Address: " << _Unfancy(ptr) << std::endl; // 使用_Unfancy转换为普通指针
//}
//void main() {
//    int val = 10;
//    FancyPtr<int> fancyPtr = &val; // 定义一个"高级指针"类型的变量
//    PrintAddress(fancyPtr); // 打印普通指针的地址
//}

template <class _Ty>
_NODISCARD constexpr _Ty* _Unfancy(_Ty* _Ptr) noexcept { // do nothing for plain pointers
    return _Ptr;
}
_STD_END

#define _EMIT_CDECL(FUNC, OPT1, OPT2, OPT3) FUNC(__cdecl, OPT1, OPT2, OPT3)
//void my_function(void(*func)(int), int opt1, char opt2, float opt3) {...}
//_EMIT_CDECL(my_function, 123, 'a', 3.14f); // 生成一个调用C语言规约的函数

#ifdef _M_CEE
#define _EMIT_CLRCALL(FUNC, OPT1, OPT2, OPT3) FUNC(__clrcall, OPT1, OPT2, OPT3)

#else // _M_CEE
#define _EMIT_CLRCALL(FUNC, OPT1, OPT2, OPT3)
#endif // _M_CEE

#if defined(_M_IX86) && !defined(_M_CEE)
#define _EMIT_FASTCALL(FUNC, OPT1, OPT2, OPT3) FUNC(__fastcall, OPT1, OPT2, OPT3)

#else // defined(_M_IX86) && !defined(_M_CEE)
#define _EMIT_FASTCALL(FUNC, OPT1, OPT2, OPT3)
#endif // defined(_M_IX86) && !defined(_M_CEE)

#ifdef _M_IX86
#define _EMIT_STDCALL(FUNC, OPT1, OPT2, OPT3)  FUNC(__stdcall, OPT1, OPT2, OPT3)
#define _EMIT_THISCALL(FUNC, OPT1, OPT2, OPT3) FUNC(__thiscall, OPT1, OPT2, OPT3)

#else // _M_IX86
#define _EMIT_STDCALL(FUNC, OPT1, OPT2, OPT3)
#define _EMIT_THISCALL(FUNC, OPT1, OPT2, OPT3)
#endif // _M_IX86

#if ((defined(_M_IX86) && _M_IX86_FP >= 2) || defined(_M_X64)) && !defined(_M_CEE)
#define _EMIT_VECTORCALL(FUNC, OPT1, OPT2, OPT3) FUNC(__vectorcall, OPT1, OPT2, OPT3)

#else // defined(_M_IX86) && _M_IX86_FP >= 2 etc.
#define _EMIT_VECTORCALL(FUNC, OPT1, OPT2, OPT3)
#endif // defined(_M_IX86) && _M_IX86_FP >= 2 etc.

#define _NON_MEMBER_CALL(FUNC, CV_OPT, REF_OPT, NOEXCEPT_OPT) \
    _EMIT_CDECL(FUNC, CV_OPT, REF_OPT, NOEXCEPT_OPT)          \
    _EMIT_CLRCALL(FUNC, CV_OPT, REF_OPT, NOEXCEPT_OPT)        \
    _EMIT_FASTCALL(FUNC, CV_OPT, REF_OPT, NOEXCEPT_OPT)       \
    _EMIT_STDCALL(FUNC, CV_OPT, REF_OPT, NOEXCEPT_OPT)        \
    _EMIT_VECTORCALL(FUNC, CV_OPT, REF_OPT, NOEXCEPT_OPT)

#define _NON_MEMBER_CALL_CV(FUNC, REF_OPT, NOEXCEPT_OPT)    \
    _NON_MEMBER_CALL(FUNC, , REF_OPT, NOEXCEPT_OPT)         \
    _NON_MEMBER_CALL(FUNC, const, REF_OPT, NOEXCEPT_OPT)    \
    _NON_MEMBER_CALL(FUNC, volatile, REF_OPT, NOEXCEPT_OPT) \
    _NON_MEMBER_CALL(FUNC, const volatile, REF_OPT, NOEXCEPT_OPT)

#define _NON_MEMBER_CALL_CV_REF(FUNC, NOEXCEPT_OPT) \
    _NON_MEMBER_CALL_CV(FUNC, , NOEXCEPT_OPT)       \
    _NON_MEMBER_CALL_CV(FUNC, &, NOEXCEPT_OPT)      \
    _NON_MEMBER_CALL_CV(FUNC, &&, NOEXCEPT_OPT)

#ifdef __cpp_noexcept_function_type
#define _NON_MEMBER_CALL_CV_REF_NOEXCEPT(FUNC) \
    _NON_MEMBER_CALL_CV_REF(FUNC, )            \
    _NON_MEMBER_CALL_CV_REF(FUNC, noexcept)
#else // __cpp_noexcept_function_type
#define _NON_MEMBER_CALL_CV_REF_NOEXCEPT(FUNC) _NON_MEMBER_CALL_CV_REF(FUNC, )
#endif // __cpp_noexcept_function_type

#define _MEMBER_CALL(FUNC, CV_OPT, REF_OPT, NOEXCEPT_OPT) \
    _EMIT_CDECL(FUNC, CV_OPT, REF_OPT, NOEXCEPT_OPT)      \
    _EMIT_CLRCALL(FUNC, CV_OPT, REF_OPT, NOEXCEPT_OPT)    \
    _EMIT_FASTCALL(FUNC, CV_OPT, REF_OPT, NOEXCEPT_OPT)   \
    _EMIT_STDCALL(FUNC, CV_OPT, REF_OPT, NOEXCEPT_OPT)    \
    _EMIT_THISCALL(FUNC, CV_OPT, REF_OPT, NOEXCEPT_OPT)   \
    _EMIT_VECTORCALL(FUNC, CV_OPT, REF_OPT, NOEXCEPT_OPT)

#define _MEMBER_CALL_CV(FUNC, REF_OPT, NOEXCEPT_OPT)    \
    _MEMBER_CALL(FUNC, , REF_OPT, NOEXCEPT_OPT)         \
    _MEMBER_CALL(FUNC, const, REF_OPT, NOEXCEPT_OPT)    \
    _MEMBER_CALL(FUNC, volatile, REF_OPT, NOEXCEPT_OPT) \
    _MEMBER_CALL(FUNC, const volatile, REF_OPT, NOEXCEPT_OPT)

#define _MEMBER_CALL_CV_REF(FUNC, NOEXCEPT_OPT) \
    _MEMBER_CALL_CV(FUNC, , NOEXCEPT_OPT)       \
    _MEMBER_CALL_CV(FUNC, &, NOEXCEPT_OPT)      \
    _MEMBER_CALL_CV(FUNC, &&, NOEXCEPT_OPT)

#ifdef __cpp_noexcept_function_type
#define _MEMBER_CALL_CV_REF_NOEXCEPT(FUNC) \
    _MEMBER_CALL_CV_REF(FUNC, )            \
    _MEMBER_CALL_CV_REF(FUNC, noexcept)
#else // __cpp_noexcept_function_type
#define _MEMBER_CALL_CV_REF_NOEXCEPT(FUNC) _MEMBER_CALL_CV_REF(FUNC, )
#endif // __cpp_noexcept_function_type

//生成一系列带不同限定符和引用的类的定义
#ifdef __cpp_noexcept_function_type
#define _CLASS_DEFINE_CV_REF_NOEXCEPT(CLASS) \
    CLASS(_EMPTY_ARGUMENT)                   \
    CLASS(const)                             \
    CLASS(volatile)                          \
    CLASS(const volatile)                    \
    CLASS(&)                                 \
    CLASS(const&)                            \
    CLASS(volatile&)                         \
    CLASS(const volatile&)                   \
    CLASS(&&)                                \
    CLASS(const&&)                           \
    CLASS(volatile&&)                        \
    CLASS(const volatile&&)                  \
    CLASS(noexcept)                          \
    CLASS(const noexcept)                    \
    CLASS(volatile noexcept)                 \
    CLASS(const volatile noexcept)           \
    CLASS(&noexcept)                         \
    CLASS(const& noexcept)                   \
    CLASS(volatile& noexcept)                \
    CLASS(const volatile& noexcept)          \
    CLASS(&&noexcept)                        \
    CLASS(const&& noexcept)                  \
    CLASS(volatile&& noexcept)               \
    CLASS(const volatile&& noexcept)
#else // __cpp_noexcept_function_type
#define _CLASS_DEFINE_CV_REF_NOEXCEPT(CLASS) \
    CLASS(_EMPTY_ARGUMENT)                   \
    CLASS(const)                             \
    CLASS(volatile)                          \
    CLASS(const volatile)                    \
    CLASS(&)                                 \
    CLASS(const&)                            \
    CLASS(volatile&)                         \
    CLASS(const volatile&)                   \
    CLASS(&&)                                \
    CLASS(const&&)                           \
    CLASS(volatile&&)                        \
    CLASS(const volatile&&)
#endif // __cpp_noexcept_function_type
御风@户外
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言-库函数-源码.....
04-03
C语言库函数源码
cpp代码-模板 泛型 template<typename> template<class>
07-14
template <> void swap(int& a, int& b) { std::swap(a, b); // 使用内置的交换函数，可能更高效 } ``` 模板模板参数则允许我们为接受其他模板作为参数的模板编写代码，例如`std::allocator`模板： ```cpp ...
机器学习——训练模型
热门推荐
m0_63953970的博客
07-27 15万+
机器学习——训练模型
vs2022 cpp ＜cstdlib＞stdlib.h、limits.h、corecrt_math.h、corecrt_math_defines.h、initializer_list代码解析
weixin_43172531的博客
03-29 410
vs2022 cpp ＜cstdlib＞stdlib.h、limits.h、corecrt_math.h、corecrt_math_defines.h、initializer_list代码解析
C语言 函数（附源码）
君逍遥o
04-14 685
函数是一组一起执行一个任务的语句。每个 C 程序都至少有一个函数，即主函数 main() ，所有简单的程序都可以定义其他额外的函数。
SpringCloudAlibaba 微服务组件 Nacos 之配置中心源码深度解析
https://github.com/lyh200
11-11 637
文章从服务启动时的配置拉取，服务启动后的配置监听器注册，以及配置变动后的热更新实现三个方面从源码层面解析了整个的原理，希望对大家有所帮助。
vs2019 cpp20 规范的线程头文件 <thread> 注释并探讨几个问题
最新发布
05-12
vs 2019 c++20 规范的线程头文件 <thread> 注释并探讨几个问题
vs2019 cpp STL之源码分析<unoredered-set>
09-12
vs2019 cpp STL之源码分析<unoredered_set>
<免费>devcpp5.12优化版
11-22
被优化过界面代码都好看了不少(我个人认为) 我常用的C语言编译器也是这个 相比于vc6.0我更倾向于devcpp
C++14新特性总结
柚子树's Blog
07-19 6281
一、语言特性 1.1 函数返回类型推导 如下，声明一个返回类型为auto的函数，让它依据函数调用时传入的参数进行推导，指定C++11标准进行编译，我用的是clang编译器，编译命令为：clang++ -std=c++11 1.1.cpp，发现会有编译错误，并且报告说这是C++14的新特性，如下： /** * @file 1.1.cpp * @brief * @author YongDu * @date 2021-07-18 */ #include <iostream&gt
cpp
03-01
cpp
CPP实战开发源码
12-21
包含大量实例，及时和新手学习之用也适合有一定基础的人学习，欢迎下载
C++多线程学习记录
qq_38624569的博客
07-22 132
C++ 多线程学习记录，C++基础知识记录
XSTDDEF
xzm_cn
01-17 769
// xstddef standard header #if _MSC_VER > 1000 #pragma once #endif #ifndef _XSTDDEF_ #define _XSTDDEF_ #ifndef _YVALS #include #endif #include /* Define _CRTIMP */ #ifndef _CRTIMP #ifdef _DL
cpp-httplib 源码剖析
fy291021851的博客
12-06 4276
cpp-httplib是一个c++封装的http开源库，仅包含一个头文件，不过代码行数达到8000多行，相比于上一节中讲述的Tinyhttpd ，该库功能就比较完善，并且可以在简单的项目中使用。 cpp-httplib 服务端采用select IO多路复用模型，工作线程池的处理方式，主要包含的类Server、Client、Request、Response。 1 该库使用简洁方便 1.1 服务端举例 httplib::Server server; ...
C++开源代码项目汇总
乐观进取　奋斗不止
10-13 5万+
C++开源码项目
怎么写出一个C语言代码（VS2022版）
xuaoyao的博客
04-06 2197
"hello bit"是一个字符串，双引号引起来的就是字符串。源文件->添加->新建项->Visual C++ ->将文件名称.cpp换为.c。printf是一个库函数 —— C语言编译器提供的一个现成的函数直接可以使用。写好的C语言代码是文本信息，这些代码不能直接运行起来。VS2022 是微软开发的一个强大的集成开发环境。路径：一定要按照自己的安排去选择代码存放的路径。写成.cpp是，编译器会按照C++的语法编译。并且程序是从main函数的第一行开始执行的。具有编辑、编译、链接、运行、调试等功能。
01 cppunit 源码解读
qq_32949807的博客
07-11 187
背景 相关：STL：标准模板库 ，有六大组件：容器、迭代器、算法、仿函数、迭代适配器、空间配置器Design Pattern：设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。CppUnit的总体构成：core：核心部分；output：输出管理；helper：一些辅助类extensi...
cpp vector<string>删除某元素
06-10
要删除 `vector<string>` 中的某个元素，可以使用 `erase()` 函数。该函数接受一个迭代器参数，指向要删除的元素。例如，如果要删除第三个元素，可以这样做： ```cpp vector<string> v{"foo", "bar", "baz", "qux"}...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值