这个问题是今天早上问的，它让我想知道你认为哪些功能缺失于C++标准库，以及你如何使用包装函数填补这些空白。例如，我的工具库中有一个用于向向量附加的函数：
template <class T>
std::vector<T> & operator += ( std::vector<T> & v1,
const std::vector <T> & v2 ) {
v1.insert( v1.end(), v2.begin(), v2.end() );
return v1;
}
对于清除（或多或少）任何类型的函数 - 特别是在处理std::stack等内容时非常有用：
template <class C>
void Clear( C & c ) {
c = C();
}
我还有一些，但我想知道你使用哪些？请将答案限制在包装器函数上——即不超过几行代码。
很多时候，我会把向量视为一组无特定顺序的项目（当然，当我不需要快速地检查元素是否在集合中时）。在这些情况下，调用erase()是浪费时间的，因为它会重新排序元素，而我不关心顺序。这就是下面这个O(1)函数派上用场 - 只需将最后一个元素移动到要删除的位置：
template<typename T>
void erase_unordered(std::vector<T>& v, size_t index)
{
v[index] = v.back();
v.pop_back();
}
v[index] = st::move(v.back()); v.pop_back();是效率最高的方法之一。 - GManNickGClass x; Class y = std::move(x);意味着当超出作用域时，x的析构函数不会被调用。否则，我反对使它们有效=) - Viktor Sehrstd::array 吗？ - v.oddoucontains(container, val)（非常简单，但很方便）。
template<typename C, typename T>
bool contains(const C& container, const T& val) {
return std::find(std::begin(container), std::end(container), val) != std::end(container);
}
remove_unstable(begin, end, value)
这是 std::remove 的一个更快的版本，但它不保留剩余对象的顺序。
template <typename T>
T remove_unstable(T start, T stop, const typename T::value_type& val){
while(start != stop) {
if (*start == val) {
--stop;
::std::iter_swap(start, stop);
} else {
++start;
}
}
return stop;
}
如果是pod类型（int、float等）的向量，并且几乎所有对象都被删除，使用std::remove可能更快。
contains需要一个第三个参数(bool sorted=false)，并在sorted==true时特化调用binary_search而不是find，您同意吗？ - KitsuneYMGtemplate < class T >
class temp_value {
public :
temp_value(T& var) : _var(var), _original(var) {}
~temp_value() { _var = _original; }
private :
T& _var;
T _original;
temp_value(const temp_value&);
temp_value& operator=(const temp_value&);
};
好的，由于看起来这不像我想象的那样简单，这里有一个解释：
在它的构造函数中，temp_value 存储了一个变量的引用和变量原始值的副本。在它的析构函数中，它将引用的变量恢复到其原始值。因此，在构建和销毁之间对变量进行的任何操作都会在 temp_value 对象超出作用域时被重置。
像这样使用它：
void f(some_type& var)
{
temp_value<some_type> restorer(var); // remembers var's value
// change var as you like
g(var);
// upon destruction restorer will restore var to its original value
}
namespace detail
{
// use scope-guard trick
class restorer_base
{
public:
// call to flag the value shouldn't
// be restored at destruction
void dismiss(void) const
{
mDismissed = true;
}
protected:
// creation
restorer_base(void) :
mDismissed(false)
{}
restorer_base(const restorer_base& pOther) :
mDismissed(pOther.is_dismissed())
{
// take "ownership"
pOther.dismiss();
}
~restorer_base(void) {} // non-virtual
// query
bool is_dismissed(void) const
{
return mDismissed;
}
private:
// not copy-assignable, copy-constructibility is ok
restorer_base& operator=(const restorer_base&);
mutable bool mDismissed;
};
// generic single-value restorer, could be made
// variadic to store and restore several variables
template <typename T>
class restorer_holder : public restorer_base
{
public:
restorer_holder(T& pX) :
mX(pX),
mValue(pX)
{}
~restorer_holder(void)
{
if (!is_dismissed())
mX = mValue;
}
private:
// not copy-assignable, copy-constructibility is ok
restorer_holder& operator=(const restorer_holder&);
T& mX;
T mValue;
};
}
// store references to generated holders
typedef const detail::restorer_base& restorer;
// generator (could also be made variadic)
template <typename T>
detail::restorer_holder<T> store(T& pX)
{
return detail::restorer_holder<T>(pX);
}
这只是一些样板代码，但可以更清晰地使用：
#include <iostream>
template <typename T>
void print(const T& pX)
{
std::cout << pX << std::endl;
}
void foo(void)
{
double d = 10.0;
double e = 12.0;
print(d); print(e);
{
restorer f = store(d);
restorer g = store(e);
d = -5.0;
e = 3.1337;
print(d); print(e);
g.dismiss();
}
print(d); print(e);
}
int main(void)
{
foo();
int i = 5;
print(i);
{
restorer r = store(i);
i *= 123;
print(i);
}
print(i);
}
//none -- it is built into the language
使用方法：
#include <iostream>
template <typename T>
void print(const T& pX)
{
std::cout << pX << std::endl;
}
void foo(void)
{
double d = 10.0;
double e = 12.0;
print(d); print(e);
{
double f(d);
double g(e);
f = -5.0;
g = 3.1337;
print(f); print(g);
e = std::move(g);
}
print(d); print(e);
}
int main(void)
{
foo();
int i = 5;
print(i);
{
int r(i);
r *= 123;
print(r);
}
print(i);
}
remove_copy_if() 实现它。 :p - wilhelmtelltemplate< typename T, std::size_t sz >
inline T* begin(T (&array)[sz]) {return array;}
template< typename T, std::size_t sz >
inline T* end (T (&array)[sz]) {return array + sz;}
T 将是 const U，你会得到预期的函数。 - GManNickG:) - sbi:) - sbi&，数组永远不会按值传递。&的存在是为了使数组长度的类型推断成立。 - Mankarsebegin()和end()之间陷入了困境。我想要一些类似于以下的函数：template<typename T>
void sort(T& x)
{
std::sort(x.begin(), x.end());
}
对于std::find、std::for_each以及所有STL算法的其他类似情况，也是如此。
我认为sort(x)比sort(x.begin(), x.end())更容易阅读/理解。
我现在很少使用这个，但它曾经是一个基本工具：
template<typename T>
std::string make_string(const T& data) {
std::ostringstream stream;
stream << data;
return stream.str();
}
我会尽快补充更多内容，哈哈。
boost::lexical_cast<t, t> 的一种简化方式。 - Billy ONealchar* 或 std::string 上调用它是不必要的昂贵操作。也许需要进行模板特化？ - wilhelmtellboost::lexical_cast 有一堆这样的特化和错误检查。不过，要将奇数转换为字符串，这个方法也可以正常工作。 - Jon Purdy// does a string contain another string
inline bool contains(const std::string &s1, const std::string &s2) {
return s1.find(s2) != std::string::npos;
}
// remove trailing whitespace
inline std::string &rtrim(std::string &s) {
s.erase(std::find_if(s.rbegin(), s.rend(), std::not1(std::ptr_fun<int, int>(std::isspace))).base(), s.end());
return s;
}
// remove leading whitespace
inline std::string <rim(std::string &s) {
s.erase(s.begin(), std::find_if(s.begin(), s.end(), std::not1(std::ptr_fun<int, int>(std::isspace))));
return s;
}
// remove whitespace from both ends
inline std::string &trim(std::string &s) {
return ltrim(rtrim(s));
}
// split a string based on a delimeter and return the result (you pass an existing vector for the results)
inline std::vector<std::string> &split(const std::string &s, char delim, std::vector<std::string> &elems) {
std::stringstream ss(s);
std::string item;
while(std::getline(ss, item, delim)) {
elems.push_back(item);
}
return elems;
}
// same as above, but returns a vector for you
inline std::vector<std::string> split(const std::string &s, char delim) {
std::vector<std::string> elems;
return split(s, delim, elems);
}
// does a string end with another string
inline bool endswith(const std::string &s, const std::string &ending) {
return ending.length() <= s.length() && s.substr(s.length() - ending.length()) == ending;
}
// does a string begin with another string
inline bool beginswith(const std::string &s, const std::string &start) {
return s.compare(0, start.length(), start) == 0;
}
split()函数会吞掉在std::getline()中发生的任何错误，默默地返回一个过短的向量。 - sbisize()。 - Evan Teranstd::getline是否遇到错误。虽然我不确定在操作std::stringstream时std::getline会失败的方式有多少种，但是您考虑了哪些类型的错误？显然，流的bad/fail位可以被设置，但是由什么导致的？什么样的输入可能会导致它失败？ - Evan Teranstringstream/getline循环中可能出错的实际情况（除了字符串根本没有足够的标记可以获取）。我在这里提出了一个问题：https://dev59.com/JUzSa4cB1Zd3GeqPq_Am - Evan Teran每个人工具箱中的实用函数当然是 copy_if。虽然不是一个包装器。
我经常使用的另一个辅助程序是 deleter，这是一个我与 std::for_each 一起使用的函数对象，用于删除容器中的所有指针。
[编辑] 在我的 "sth.h" 中搜索，我还发现了 vector<wstring> StringSplit(wstring const&, wchar_t);
erase算法： template <
class Container,
class Value
>
void erase(Container& ioContainer, Value const& iValue)
{
ioContainer.erase(
std::remove(ioContainer.begin(),
ioContainer.end(),
iValue),
ioContainer.end());
} // erase
template <
class Container,
class Pred
>
void erase_if(Container& ioContainer, Pred iPred)
{
ioContainer.erase(
std::remove_if(ioContainer.begin(),
ioContainer.end(),
iPred),
ioContainer.end());
} // erase_if
std::remove。例如，std::unique。 - Billy ONealset。 - Matthieu M.
c.swap(C())来清空容器不是更好吗？ - Alexandre C.