为什么std::swap不是类模板？
std::swap 不是类模板，而是一个函数模板。这个设计决策主要是基于以下几个原因：
基础概念
- 函数模板：函数模板允许你定义一个函数，它可以处理多种数据类型。编译器根据传递给函数的参数类型生成特定的函数实例。
- 类模板：类模板允许你定义一个类，它可以处理多种数据类型。编译器根据传递给类的模板参数生成特定的类实例。
为什么 std::swap 是函数模板而不是类模板
- 简洁性：函数模板通常比类模板更简洁。
std::swap的目的是交换两个对象的值，这个操作可以直接通过一个函数来实现，而不需要定义一个类。 - 通用性：函数模板可以应用于任何可以交换的对象，而不需要为每种类型定义一个新的类。
- 性能：函数模板在编译时生成特定的函数实例，通常比类模板生成的实例更高效。
相关优势
- 简洁性：函数模板代码更简洁，易于理解和维护。
- 通用性：可以处理多种数据类型，而不需要为每种类型定义一个新的类。
- 性能：编译时生成特定的函数实例，通常比类模板生成的实例更高效。
类型和应用场景
std::swap 是一个通用的交换函数模板，可以用于任何可以交换的对象类型。例如：
#include <iostream>
#include <algorithm>
int main() {
int a = 5, b = 10;
std::swap(a, b);
std::cout << "a: "<< a << ", b: "<< b << std::endl; // 输出: a: 10, b: 5
std::string s1 = "hello", s2 = "world";
std::swap(s1, s2);
std::cout << "s1: " << s1 << ", s2: " << s2 << std::endl; // 输出: s1: world, s2: hello
return 0;
}遇到的问题和解决方法
如果你在使用 std::swap 时遇到问题，通常是因为传递的对象类型不支持交换操作。解决方法包括：
- 自定义交换函数：如果标准库的
std::swap不支持你的类型，可以自定义一个交换函数。
#include <iostream>
class MyClass {
public:
int value;
MyClass(int v) : value(v) {}
};
void swap(MyClass& a, MyClass& b) {
std::swap(a.value, b.value);
}
int main() {
MyClass obj1(5), obj2(10);
swap(obj1, obj2);
std::cout << "obj1: " << obj1.value << ", obj2: " << obj2.value << std::endl; // 输出: obj1: 10, obj2: 5
return 0;
}- 特化
std::swap：可以为你的类型特化std::swap。
#include <iostream>
#include <algorithm>
class MyClass {
public:
int value;
MyClass(int v) : value(v) {}
};
namespace std {
template <>
void swap<MyClass>(MyClass& a, MyClass& b) {
std::swap(a.value, b.value);
}
}
int main() {
MyClass obj1(5), obj2(10);
std::swap(obj1, obj2);
std::cout << "obj1: " << obj1.value << ", obj2: " << obj2.value << std::endl; // 输出: obj1: 10, obj2: 5
return 0;
}通过这些方法，你可以确保 std::swap 能够处理你的自定义类型。
相关·内容
2回答
以下程序
#include <algorithm>
#include <utility>
#include <memory>
namespace my_namespace
{
template<class T>
void swap(T& a, T& b)
{
T tmp = std::move(a);
a = std::move(b);
b = std::move(tmp);
}
template<class T, class Alloc = std::allocator<T>>
cla
浏览 5提问于2015-12-03得票数 23
回答已采纳
1回答
使用声明隐藏名称
、、、、
#include <iostream>
struct H
{
void swap(H &rhs);
};
void swap(H &, H &)
{
std::cout << "swap(H &t1, H &t2)" << std::endl;
}
void H::swap(H &rhs)
{
using std::swap;
swap(*this, rhs);
}
int main(void)
{
H a;
H b;
浏览 3提问于2016-03-09得票数 3
回答已采纳
3回答
考虑一下守则：
#include <iostream>
#include <algorithm> // std::swap C++98
#include <utility> // std::swap C++11
namespace A
{
template<typename T>
struct Foo {};
template<typename T>
void swap(Foo<T> &lhs, Foo<T> &rhs)
{
std::cout << "A::sw
浏览 7提问于2015-01-22得票数 3
回答已采纳
2回答
在我成功地重载了类类型的std::swap之后，现在我希望对它进行专门化，而不是重载它，因为标准允许向命名空间std添加模板专门化。以下是我的例子：
class Foo{
public:
Foo(){
std::cout << "Foo()\n";
}
Foo(Foo const&){
std::cout << "Foo(Foo const&)\n";
}
Foo(Foo&&){
std::cout << &
浏览 0提问于2021-04-05得票数 1
我试图在我的自定义矩阵类中实现，但我遇到了一些麻烦，因为我使用链接问题中建议的方式实现了swap()：
(我使用的编译器是MS VS2010集成开发环境的，方言是很好的老式C++03。)
// matrix.h
namespace my_space
{
template<typename T> class Matrix
{
public:
/* ... */
friend void swap(Matrix<T> &first, Matrix<T> &second)
{
using std::sw
浏览 4提问于2012-07-20得票数 0
回答已采纳
3回答
所以，我有一个宏。
// swap_specialize.hpp
#include <algorithm>
#ifndef STD_SWAP_SPECIALIZE
#define STD_SWAP_SPECIALIZE( CLASSNAME ) \
namespace std { \
template<> inline \
void swap( CLASSNAME & lhs, CLASSNA
浏览 0提问于2009-07-17得票数 2
回答已采纳
2回答
下面是我在创建一个更大的类时遇到的一个简化的例子，并试图通过提供我自己的非会员朋友交换函数来实现Swappable。
#include <iostream>
#include <utility>
template<typename T>
class Wrapper {
friend void swap(Wrapper& a, Wrapper& b);
public:
Wrapper(T t) : value_(t) {}
const T& operator*() const { return value_; }
pr
浏览 0提问于2016-02-06得票数 1
回答已采纳
1回答
我阅读了STL中的unique_ptr实现，并提出了一些问题。unique_ptr::swap()的代码如下：
void
swap(unique_ptr& __u)
{
using std::swap;
swap(_M_t, __u._M_t);
}
对于这个功能，我有两个问题：
unique_ptr::_M_t是一个私有成员，为什么可以访问__u._M_t？
为什么没有在unique_ptr& __u中指定模板参数？这是由特定的unique_ptr的构造函数完成的吗？
谢谢你的帮忙!
浏览 0提问于2013-09-06得票数 1
回答已采纳
2回答
iter_swap的意义何在？
、、、、
我只是在想，为什么会有人这样写：
std::iter_swap(i, k);
而不是这个？
std::swap(*i, *k); // saved a few keystrokes!
然后我研究了iter_swap的实现，当然它只使用swap而不是std::swap，因为我们已经在namespace std中了。这就引出了下一个问题：
为什么会有人写这样的话：
using std::swap;
swap(a, b);
而不是这个？
std::iter_swap(&a, &b); // saved an entire line of code!
这里有没有什么我忽略的重要
浏览 3提问于2012-12-21得票数 37
回答已采纳
可能重复：
我有存储std::unique_ptr所需的这些类(适当的boost::any)：
class any
{
public:
any()
: content(0)
{
}
any(any const&) = delete;
any(any && other)
: content(other.content)
{
content = 0;
}
template<typename ValueType>
any(ValueType const& value)
: c
浏览 2提问于2012-04-13得票数 0
我知道ADL是什么，我知道在C++中，内部作用域函数隐藏外部作用域函数。也就是说，名称不会跨作用域重载。因此，功能重载需要在相同的范围内进行。
所以现在我的问题是，对于这个常见的代码片段：
#include <iostream>
#include <string>
using std::cout;
using std::endl;
namespace Foo{
class Bar{
friend void swap(Bar& a, Bar& b);
};
void swap(Bar& a, Bar&
浏览 3提问于2020-05-09得票数 3
回答已采纳
考虑到以下内容(剥离并刻意突出显示问题)：
#include <utility>
namespace Generic
{
class Whatever
{
public:
// ISSUE1 (member "swap()" has same name as non-member template)
void swap()
{
}
};
// Forward declaration of class template "Test"
te
浏览 0提问于2017-09-28得票数 3
我今天读到了一些有趣的东西，其中说对用户提供的类型(作为模板参数提供的)调用交换的“标准”方法是.
using std::swap;
swap(something, soemthingelse);
这样做的原因是使用依赖于参数的查找，要么在用户名称空间中使用swap函数，要么在std命名空间中使用swap。这使我产生了一个有兴趣的问题。当我为我的一个类重载std::swap时，我实际上一直在std命名空间中定义它.namespace std { void swap(/*...*/){/*...*/} }。这种做法不对吗？我应该在swap或我自己的名称空间中定义自己的std (以及为什么)？
浏览 5提问于2013-01-18得票数 21
回答已采纳
3回答
我编写了这个简单的C++代码来交换任何两个变量。它适用于整数和双，但对于复数不起作用，你知道为什么吗？
#include <iostream>
#include <complex>
using std::cout;
using std::endl;
using std::complex;
template <class T>
inline void swap(T& d, T& s)
{
T temp = d;
d = s;
s = temp;
}
int main()
{
int m=5,
浏览 1提问于2013-11-06得票数 0
回答已采纳
2回答
我正在读Meyer的关于有效的c++编程的书，在第25项中我找到了total template specialization，但我不能理解它，这是什么意思？他还举了个例子：
namespace std {
template<>
void swap<Widget>(Widget& a, Widget& b)
{
swap(a.pimpl, b.pimpl);
}
}
这句话是什么意思：template<>(为什么没有typename?)
提前感谢
浏览 6提问于2010-10-14得票数 6
回答已采纳
正如标题所说，std::begin、std::end、std::swap等都是非常著名的std“定制点”(函数是通过ADL找到的)。然而，我认为，std::hash是唯一可由用户定制的标准行为，这意味着(A)打开std名称空间(B)创建部分专门化。
为什么std::hash没有像其他的那样被设计成一个定制点，通过重载一个函数而不是部分专门化一个类？
浏览 28提问于2019-09-08得票数 2
如果我有某种类类型，例如管理资源，并且我的类需要定义一个swap()函数作为其接口的一部分，该接口可以工作于该类型的对象，那么我通常会这样做：
struct Foo{};
Foo f1, f2;
void swap(Foo& lhs, Foo& rhs){
// code to swap member data of lhs and rhs
}
int main(){
using std::swap;
Foo f1, f2;
swap(f1, f2);
}
现在，我是重载std::swap，还是专门化它？
我了解到，如果我想专门化标准库的函
浏览 2提问于2021-04-05得票数 4
2回答
在使用模板类时，我得到了一个链接器错误，我尝试实现这里建议的复制和交换成语：
模板类(让我们称之为"TemplateClass“)部分地定义如下：
template< class T >
class TemplateClass
{
// ...
TemplateClass< T >& operator= ( TemplateClass< T > other );
friend void swap( TemplateClass< T >& first, TemplateClass< T >
浏览 4提问于2011-09-07得票数 2
回答已采纳
模板函数专门化的通常定义如下：
class Foo {
[...]
};
namespace std {
template<>
void swap(Foo& left, Foo& right) {
[...]
}
} // namespace std
但是，当专门化的类型本身是模板时，如何正确定义专门化呢？下面是我得到的信息：
template <size_t Bits>
class fixed {
[...]
};
namespace std {
template<size_t
浏览 0提问于2010-04-28得票数 3
回答已采纳
到目前为止，我有一段代码在VisualStudio2017中编译得很好，但现在我一直从std::vector获得模板实例化错误，这些错误在文章末尾提供。我要补充的是，从那时(当代码编译好)到现在，没有一行代码被更改。
当我隔离这个问题时，奇怪的是，std::vector是否包含在其中一个头文件中。以下代码复制错误：
(请注意，代码并没有多大意义。)
CDataUnit_ALB.h：
#pragma once
#include "DataUnit\CDataUnit.h"
// #include <vector> // <== UnREM'ing
浏览 1提问于2017-11-15得票数 3
1回答
我发现自己经常从vector中删除元素，而不关心顺序的维护，这意味着使用擦除将是浪费的。最好用最后一个元素和pop_back()交换移除元素。标准库中似乎没有任何东西可以这样做，所以我正在尝试编写自己的模板，但我确实对模板语法没有很强的把握。
我写了这个：
template<typename T>
void unordered_erase(std::vector<T>& vec, const std::vector<T>::iterator& it)
{
if (it != vec.end())
{
std::
浏览 3提问于2016-04-11得票数 2
回答已采纳
1回答
我从下面的代码中得到了两个错误，并且不知道如何解决它们：
第一个错误：invalid use of incomplete type 'class myArray<T>'
第二个错误：declaration of 'class myArray<T>'
我想这是因为我正向前声明了一个成员函数，这个成员函数在类的第一次调用时还没有实现。但是，如果不向前声明此函数，则会出现多个错误。
//myArray.h
#ifndef ARRAY_H_INCLUDED
#define ARRAY_H_INCLUDED
#include <iostre
浏览 0提问于2019-08-17得票数 1
2回答
我正在学习 to a 关于为用户定义的类型实现函数的最佳实践。(我的问题最初是由提出的。)
我不会在这里重新打印上面链接的答案的代码片段。
相反，我想了解答案。
我上面链接的答案是，在第一个代码段下面，关于namespace std中的重载(而不是专门处理这个名称空间)：
如果您的编译器打印出了不同的内容，那么它就不能正确地实现模板的“两阶段查找”。
答案接着指出，specializing swap in namespace std (而不是重载)产生了不同的结果(在专门化的情况下需要的结果)。
但是，答案是另一种情况：专门化交换用户定义的模板类--在这种情况下，同样没有达到预期的
浏览 2提问于2014-01-27得票数 9
回答已采纳
也许以前有人问过，但所有这些都接近了我对C++的理解和认知的极限，所以我在理解讨论的内容和到底发生了什么方面有点慢。让我直接跳到密码上。这样做是可行的：
template <typename T>
class Foo
{
struct Bar
{
Bar() {}
~Bar() noexcept {}
Bar(Bar&& b) : Bar() { swap(*this, b); }
friend void swap(Bar& b1, Bar& b2) { /* ...
浏览 4提问于2012-10-13得票数 10
回答已采纳
为了演示目的，我有两个ADL片段。这两个片段都是由VC10、gcc和comeau C++编译器编译的，结果对这三种代码都是一样的。
<1>ADL反对使用用户定义的命名空间的指令：
#include <algorithm>
namespace N
{
struct T {};
void swap(T,T) {}
}
namespace M
{
void swap(N::T,N::T) {}
}
int main()
{
using M::swap;
N::T o1,o2;
swap(o1,o2);
浏览 0提问于2012-10-05得票数 7
回答已采纳
1回答
这是非常迂腐的，但在C++03中，一个程序显然不符合重载(不是专门化)，这是std命名空间中的模板函数:参见对和的提及。
也就是说，这是可以的：
namespace std
{
template <>
void swap (Foo & f, Foo & g)
{
// ...
}
}
但这不是(如果我理解得对.)：
namespace std
{
template <typename T>
void swap (TempateFoo<T> & f, TempateFoo&l
浏览 4提问于2013-02-27得票数 8
回答已采纳
1回答
一个基本的多维阵列
、、、
我一直潜伏在堆栈溢出的C++端，只知道有很多初学者和中级程序员对多维数组感到困惑。我见过很多 怪诞：三星级程序员，缓存-不友好的实现，向量向量…，等。
我想为他们提供一个基本的多维数组：
对扩展开放，
适合生产和试验，
没有拨款的工作，
而且对缓存友好。
在此之前，我希望得到社会各界的一些建议。
在提供的这个类的特性方面，我可以改进什么？
一个人可以添加什么新特性，为什么它会有用？
#include <array>
#include <numeric>
namespace ysc
{
namespace _details
{
template<clas
浏览 0提问于2018-10-26得票数 5
4回答
如何重载std::swap()
、、、、
许多标准容器(如std::list和std::vector)在排序甚至赋值过程中都会使用std::swap()。
但是swap()的标准实现是非常通用的，并且对于自定义类型来说效率相当低。
因此，可以通过使用特定于自定义类型的实现重载std::swap()来获得效率。但是，如何实现它才能被std容器使用呢？
浏览 8提问于2008-08-14得票数 122
回答已采纳
5回答
昨晚我睡不着觉，开始想std::swap。下面是熟悉的C++98版本：
template <typename T>
void swap(T& a, T& b)
{
T c(a);
a = b;
b = c;
}
如果用户定义的类Foo使用外部资源，这是低效的.常见的成语是提供一个方法void Foo::swap(Foo& other)和一个专门化的std::swap<Foo>。请注意，这不适用于类模板，因为您不能部分地专门化函数模板，而且std命名空间中的重载名称是非法的。解决方案是在自己的名称空间中编写一个模板函数，并依
浏览 3提问于2011-02-02得票数 14
回答已采纳
3回答
在STL算法中启用我的swap的正确方法是什么？
1)成员swap。std::swap是否使用SFINAE技巧来使用成员swap。
2)同一命名空间中的自由swap。
3) std::swap的部分专业化。
4)以上所有内容。
谢谢。
编辑:看起来我没有清楚地表达我的问题。基本上，我有一个模板类，我需要STL算法来使用我为该类编写的(高效)交换方法。
浏览 1提问于2011-06-17得票数 93
回答已采纳
我是C++新手，这可能是个愚蠢的问题。
我正在阅读C++中的一本书“数据结构和算法分析”，其中提供了用户定义的向量类模板的实现。
这是它的一个片段
// Move Constructor
Vector(Vector&& source) noexcept
: size(source.size), capacity(source.capacity), objects(source.objects)
{
source.objects = nullptr;
source.size = 0;
source.capacity = 0;
}
// Move
浏览 3提问于2022-09-20得票数 0
6回答
C++标准禁止在名称空间std中声明类型或定义任何内容，但它允许您为用户定义的类型专门化标准STL模板。
通常，当我想为自己的自定义模板化类型指定std::swap时，我只需这样做：
namespace std
{
template <class T>
void swap(MyType<T>& t1, MyType<T>& t2)
{
t1.swap(t2);
}
}
...and可以很好地工作。但我不能完全确定我通常的做法是否符合标准。我这样做正确吗？
浏览 1提问于2010-02-09得票数 14
回答已采纳
2回答
关于函数调用解析的混淆
、、、、
这个问题是由提出的。考虑一下守则：
namespace ns {
template <typename T>
void swap(T& a, T& b) {
using namespace std;
swap(a, b);
}
}
在和GCC做了一些测试之后，我发现swap(a, b);决定
1)如果std::swap T重载了std::swap (例如，标准容器类型)
2) ns::swap，否则，导致无限递归。
因此，编译器似乎将首先尝试在命名空间ns中找到匹配项。如果找到匹配项，则搜索结束。但是当ADL出现时，情况并非如此，在这种情
浏览 4提问于2015-05-04得票数 7
回答已采纳
我有一个类，其中包含任意数量的类，并将它们存储到std::tuple中。这是一个多样化的模板类。我已经正确地重载了operator+操作符，它们按预期工作。但是，现在我试图将一个控制器类分配给另一个控制器类。我尝试了以下几点：
template<typename...ClassesR>
auto operator=(const Controller<ClassesR...>& rhs)
{
objects.swap(rhs.getObjects());
return *this;
}
但是，在编译代码时，我会得到一个错误：“对std::tuple<
浏览 4提问于2019-11-14得票数 0
回答已采纳
我正在尝试使用以下C++模板： _CONSTEXPR20 void swap(_Ty& _Left, _Ty& _Right) noexcept(
is_nothrow_move_constructible_v<_Ty>&& is_nothrow_move_assignable_v<_Ty>) {
_Ty _Tmp = _STD move(_Left);
_Left = _STD move(_Right);
_Right = _STD move(_Tmp);
} 从Microsoft实用
浏览 15提问于2020-10-08得票数 2
2回答
我有以下代码：
#include "stdafx.h"
#include <iostream>
using namespace std;
#include <conio.h>
#include <cstring>
#include <iomanip>
void swap(long a, long b)
{
long temp;
temp=a;
a=b;
b=temp;
}
int _tmain(int argc, _TCHAR* argv[])
{
int x = 5, y = 3;
浏览 2提问于2011-05-07得票数 10
回答已采纳
2回答
我开始阅读一本关于C++的书，发现了以下代码。这是一个关于如何通过引用发送传递参数的示例。
#include <iostream>
void swap(int &x, int &y);
int main()
{
int x = 5, y = 10;
std::cout << "Main. Before swap, x: " << x
<< " y: " << y << "\n";
swap(x, y);
浏览 0提问于2011-09-16得票数 2
回答已采纳
下面是最大堆的insert()成员函数的实现。我尝试使用std::forward，因为我认为它可以替代编写这个接受lvalue的函数的重载。但是，代码仍然不适用于lvalue。知道为什么吗？
注意：values是max_heap类中的私有vector<T>。
template <typename T, typename compare_type>
void max_heap<T, compare_type>::insert(T&& item){
if(values.empty()){
values.push_back(
浏览 3提问于2021-10-01得票数 1
回答已采纳
3回答
朋友定义函数的名称空间是什么？
、、、、
如果我在类中有一个定义为朋友的函数。该函数的名称空间是什么？
namespace A{namespace B{
struct S{
friend void f(S const&){};
};
}}
int main(){
A::B::S s{};
f(s); // ok
::f(s); // not ok, no f in global namespace
A::B::f(s); // no f in A::B
A::B::S::f(s); // not ok, no f in A::B::S
}
它有命名空间吗
浏览 0提问于2018-07-19得票数 3
回答已采纳
1回答
这很奇怪，我不知道这是不是C++标准，是我的编译器(Ubuntu12.04上的G++版本4.6.3，这是Ubuntu12.04的最新长期支持版本)，还是我，谁不明白;-)
所讨论的代码非常简单，如下所示：
#include <algorithm> // for std::swap
void f(void)
{
class MyClass { };
MyClass aa, bb;
std::swap(aa, bb); // doesn't compile
}
尝试使用G++编译时，编译器生成以下错误消息：
test.cpp: I
浏览 0提问于2013-06-27得票数 10
回答已采纳
我编写了以下代码，作为swap函数在c++中正确实现的示例。
#include <iostream>
class Complex
{
int a;
int b;
friend std::ostream& operator<<(std::ostream&, const Complex&);
friend void swap(Complex& rhs, Complex& lhs) noexcept;
public:
Complex(): a(0), b(0) {};
Complex(i
浏览 1提问于2016-09-24得票数 2
回答已采纳
我试图学习并采用复制-交换成语，以下是对这个问题的彻底解释：。
但我发现了一些我从未见过的代码:本例中的using std::swap; // allow ADL
class dumb_array
{
public:
// ...
void swap(dumb_array& pOther) // nothrow
{
using std::swap; // allow ADL /* <===== THE LINE I DONT UNDERSTAND */
swap(mSize, pOther.mSize); // w
浏览 4提问于2011-01-24得票数 40
回答已采纳
在这个关于复制和交换的中，在可接受的答案中有一个swap()函数。
friend void swap(dumb_array& first, dumb_array& second) // nothrow
{
// enable ADL (not necessary in our case, but good practice)
using std::swap;
// by swapping the members of two classes,
// the two classes are effectively swapped
sw
浏览 1提问于2015-04-15得票数 3
回答已采纳
2回答
下面的类定义声明了一个友元函数，为它提供了内联定义。我试图从与友元函数同名的类方法中调用友元函数，但为了使其工作，我必须从封闭的命名空间访问它(这也需要一个转发声明，下面的类C )。为什么名称查找适用于类A，而不适用于类B？请注意，B::swap的参数与其friend函数的参数不同。 #include <utility>
struct A {
A(int x) : v{ x } {}
friend void swap(A& x, A& y) { std::swap(x.v, y.v); }
void swapm(A& other)
浏览 37提问于2019-03-11得票数 0
回答已采纳
3回答
通过辩论之间的区别
、、、、
嗨，我已经写了两个代码了
1.
#include<iostream>
using namespace std;
void swap(int *x, int *y)
{
int t;
t = *x;
*x = *y;
*y = t;
}
int main()
{
int a = 10, b = 20;
cout << "value of a before swap " << a <<
浏览 4提问于2020-01-31得票数 1
回答已采纳
2回答
我刚刚创建了一个数组实现，用于对自己进行复制构造函数、赋值操作符和异常安全方面的培训。请看这段代码，告诉我这里出了什么问题。
class DumbArray {
public:
DumbArray(size_t sz)
: _size(sz), _buf(new int[_size])
{
memset(_buf, 0, _size * sizeof(int));
}
DumbArray(const DumbArray& arr)
: DumbArray(arr._size)
{
int* newMem = new int[arr
浏览 0提问于2014-06-05得票数 4
函数的构造函数看起来像这样(至少在libc++中是这样的)：
namespace std {
template<class _Rp, class ..._ArgTypes>
function {
// ...
base_func<_Rp(_ArgTypes...)> __func;
public:
template<typename _Fp>
function(_Fp __f) : __func(std::move(__f)) {}
template<typename _Fp>
function& opera
浏览 0提问于2020-08-03得票数 0
如果我有一个类模板，并且我想在std命名空间中添加它自己的swap()： template<typename T>
class Widget {
void swap(Widget &) {}
};
namespace std {
template<typename T>
void swap<Widget<T> >(Widget<T> &a, Widget<T> &b)
{ a.swap(b); }
}; 无法编译，因为std::swap()是函数模板，函数模板不能
浏览 24提问于2021-11-19得票数 1
假设您有以下代码：
#include <iostream>
#include <string>
#include <vector>
int main()
{
std::vector<std::string> First{"example", "second" , "C++" , "Hello world" };
std::vector<std::string> Second{"Hello"};
First.swap(Second
浏览 7提问于2019-12-20得票数 31
回答已采纳
2回答
考虑使用链接列表的堆栈中完全工作的复制和交换成语。
//first is the pointer to the recently added node
//n is the size of the stack
template<class T>
Stack<T>& Stack<T>::operator=(Stack&& s) {
Stack<T> copy{s};
std::swap(copy.n,n);
std::swap(copy.first,first);
return *this;
浏览 3提问于2014-11-18得票数 2
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
即时通信 IM
对象存储活动推荐
腾讯云开发者
