为什么模板参数中的 cv 限定符被忽略？
在C++编程中，模板参数中的cv（const和volatile）限定符被忽略是因为模板参数推导过程中会自动去除cv限定符。这种设计是为了保证模板参数的匹配，避免因为cv限定符的不同而导致模板参数无法匹配。
例如，当我们定义一个模板类如下：
template<typename T>
class MyClass {
// ...
};当我们使用const或volatile限定的类型作为模板参数时，编译器会自动去除cv限定符：
const int a = 10;
MyClass<const int> m1; // 等价于 MyClass<int> m1;
volatile double b = 3.14;
MyClass<volatile double> m2; // 等价于 MyClass<double> m2;这种设计可以确保模板参数的匹配，避免因为cv限定符的不同而导致模板参数无法匹配。但是，这也意味着在模板参数中的cv限定符被忽略了。如果需要在模板参数中保留cv限定符，可以使用引用cv限定符的方式：
template<typename T>
class MyClass {
// ...
};
const int a = 10;
MyClass<const int&> m1; // 不等价于 MyClass<int> m1;
volatile double b = 3.14;
MyClass<volatile double&> m2; // 不等价于 MyClass<double> m2;使用引用cv限定符的方式可以保留cv限定符，但需要注意引用的语义和使用方式。
相关·内容
来自C++语言标准，第5.2.8节，来自ISO/IEC 14882:2003，引用，
lvalue表达式的顶级cv限定符或作为type id的操作数的类型id总是被忽略。
做出这项决定的理由是什么。它在类型系统中打了一个洞，这是违反直觉的.const信息(或易失性部分)在编译时是已知的，因此，如果typeid只考虑cv-限定符，就不会有开销。
浏览 0提问于2018-02-10得票数 2
在解释和创建函数参数的类型时，我很难理解为什么C++以比C更“轻松”的方式工作。
C做世界上最简单的事情，它坚持你写的东西，就这样，另一方面，C++的操作方式是扭曲的，我真的无法理解。
例如，当传递给一个函数时，流行的argv是一个char* []，它变成了char**，我真的不明白为什么，我所期望和“想要的”是char * const *，但是我得到了这种行为。
您还可以阅读，其中讨论了C和C++之间的这种差异，本文还以以下短语结尾：
虽然C++在确定函数签名时会忽略参数声明中的顶级cv-限定符，但它不会完全忽略那些cv-限定符。
由于我在网上找不到这个问题(嵌入式系统编程--200
浏览 2提问于2013-12-03得票数 3
回答已采纳
下面给出了预期的错误：
int* const const p = new int; // g++ error: duplicate cv-qualifier
但是下面不会给出任何错误，即使它等同于上面的错误：
typedef int* const intp_const;
intp_const const p = new int; // ok !
// ^^^^^ duplicate ?
为什么编译器会忽略额外的const？
注意：intp_const const与const char* const不同，因为*p = <value>;是可能的。
浏览 0提问于2012-07-18得票数 5
回答已采纳
1回答
在中，据说没有指向非成员const函数的指针这样的东西。此外，C++11 8.3.5/6表示
cv-限定符-seq在函数声明器中的作用与在函数类型的顶部添加cv限定不一样。在后一种情况下，cv-限定符将被忽略。注意:具有cv-限定符-seq的函数类型不是cv限定类型；没有cv限定函数类型。-end注记
如果我正确理解它，这就意味着不存在非成员的const函数。(虽然这类函数不是const函数，但不能按照3.10/6的规定进行修改)。特别是，指向const函数的指针是没有意义的。
但是，似乎有些编译器确实在类型演绎上下文中创建了指向const函数的指针。例如，考虑一下代码：
#inclu
浏览 0提问于2013-03-22得票数 18
回答已采纳
根据，它说
在重载解析过程中，类X的非静态cv限定成员函数被视为一个函数，如果它没有ref-限定符，或者如果它有lvalue ref-限定符，则接受lvalue引用类型的隐式参数。否则(如果它有rvalue ref-限定符)，则将其视为一个函数，其类型为rvalue引用类型的隐式参数，用于cv限定X。
问题：
1.没有任何参考限定符的成员函数怎么办？它们将被视为使用lvalue ref-限定符隐式声明的函数。我说的对吗？
2.为什么它仅限于非静态cv限定的成员函数(即以粗体表示的文本)，而不是非静态成员函数？他们之间有什么不同？
浏览 10提问于2022-04-07得票数 1
在cp偏好中，我们可以将其实现为：
template< class T> struct add_const { typedef const T type; };
当我尝试一个引用类型时，比如std::add_const<int&>，它就是int&。
我的问题是，既然int& const是非法的，为什么它可以在没有特定版本的情况下工作呢？
浏览 5提问于2020-03-30得票数 4
回答已采纳
2回答
template <typename T>
T go(T a, T *b){ T *t; return *t;}
int main() {
const int x = 10;
go(x, &x);
return 0;
}
给出编译器错误：
错误:调用‘go( const &，const*)’没有匹配函数
为什么第一个参数是引用类型const int&而不是const int？
为了修复这个编译错误，我通过指定参数go<const int>(x, &x);的类型来覆盖编译器推导过程，但是为什么我需要这样做呢
浏览 7提问于2017-09-19得票数 14
回答已采纳
3回答
可能重复：
为什么代码发出错误？
int main()
{
//test code
typedef int& Ref_to_int;
const Ref_to_int ref = 10;
}
错误是：
错误:从临时类型“int”对“int&”类型的非const引用的初始化无效
我在上读到这篇文章，其中说临时人员可以绑定到对const的引用。那么为什么我的代码没有被编译呢？
浏览 2提问于2011-05-20得票数 4
回答已采纳
2回答
为什么忽略返回类型的'cv‘？
、、、、
至少在“Clang”和“GCC”中。下面是一个示例：
char *const InString(char *const p) {
return gets(p);
}
int main()
{
static char arr[260];
char * &&str = InString(arr); //compiles without error - what??????
}
正如大多数人可能知道的，在'main'‘的第二行中，我们将返回值临时('prvalue')绑定到一个'rvalue引用’中，从而延长了它的
浏览 0提问于2015-01-15得票数 3
回答已采纳
我最近一直在学习C++，就在今天，我还介绍了const和const正确性的概念。为了更好地理解这一理论，我一直在编写一系列简单的程序，以确保我正确理解这个概念。我以为我什么都懂，但是当我在其中一个程序中使用auto关键字时，我似乎有点卡住了。
为了测试我是否理解const指针的工作原理，我编写了一个简单的程序。我不会费心发布整个事情，因为它只有两个部分是相关的。我有一个具有int类型的const数据成员的类：
const int tryToChangeMe;
在这个类中，我还有一个成员函数，它返回指向上述const int的const指针：
const int* const MyClass::
浏览 6提问于2015-05-14得票数 19
回答已采纳
在下面的代码中，为什么两种调用fun的方法：fun(num)和fun<const int>(num)，在编译时会产生不同的结果？
#include <iostream>
using namespace std;
template<typename T, typename = typename enable_if<!std::is_same<int, T>::value>::type>
void fun(T val)
{
cout << val << endl;
}
int main(void)
{
浏览 19提问于2018-06-15得票数 9
2回答
这是正确的行为，还是这段代码打印1是g++4.5的怪癖？
#include <iostream>
#include <typeinfo>
using namespace std;
int main(){
struct A{};
cout<<(typeid(A)==typeid(const A)&&typeid(A)==typeid(const volatile A)&&typeid(A)==typeid(volatile A));
}
我认为不同于cv限定符的类型被认为是非常不同的类型，即使较少的cv限定类型
浏览 2提问于2012-04-04得票数 4
回答已采纳
1回答
我有下面这段c++11代码：
#include <iostream>
struct object {
void talk(const char* text) const { std::cout << "talk " << text << std::endl; }
};
void makeItTalk(object& obj) { obj.talk("non-const"); }
void makeItTalk(const object& obj) { obj.talk("cons
浏览 2提问于2013-06-27得票数 1
考虑以下代码：
#include <iostream>
#include <functional>
int main() {
auto run = [](auto&& f, auto&& arg) {
f(std::forward<decltype(arg)>(arg));
};
auto foo = [](int &x) {};
int var;
auto run_foo = std::bind(run, foo, var);
run_foo();
浏览 0提问于2017-04-29得票数 24
回答已采纳
1回答
#include <iostream>
using namespace std;
int main()
{
cout << typeid(int).name() << endl;
cout << typeid(int&).name() << endl;
cout << typeid(int&&).name() << endl;
cout << typeid(const int).name() << endl;
cout
浏览 1提问于2019-07-31得票数 4
据说"auto“不会检索cv-限定符，所以我做了一个实验：
const int i = 0;
auto r1 = i;
auto& r2 = i;
r1 = 3;//ok
r2= 3;//compilation error
似乎在构造值时，cv-限定符不是与新变量一起使用的，而是与引用"&“一起使用的，cv-限定符与它一起使用。为什么要自动检索“cv-限定符”呢？
浏览 3提问于2016-07-28得票数 3
回答已采纳
2回答
隐式对象参数和此指针
、、、
关于，在
const-、volatile-和ref-限定成员函数
有人提到：
可以使用不带ref-限定符的非静态成员函数，使用lvalue ref-限定符(令牌&后参数列表)或rvalue ref-限定符(令牌&后参数列表)声明非静态成员函数。在过载解析过程中，X类的非静态cv限定成员函数处理如下：
没有ref-限定符:隐式对象参数具有对cv限定X的类型lvalue引用，并且还允许绑定rvalue隐含对象参数。
lvalue ref-限定符:隐式对象参数具有对cv限定X的lvalue引用类型。
rvalue ref-限定符:隐式对象参数具有对cv限定X的类型rvalu
浏览 0提问于2019-09-14得票数 2
回答已采纳
1回答
我一直在阅读斯科特上一篇关于c++11和14的主要文章中的通用引用，尽管有一个参数被分配给lvalue或rvalue类型的引用参数，但在这两者之间有一种叫做泛引用的东西，它可以根据传递的论点的类型特征推导出任何一个l/rvalue。我可以理解是什么使参数成为一个通用引用，但我不清楚的一点是，为什么将const添加到类型参数const T&& p中，将p作为rvalue：
template<typename T>
void f(T&& param); // param is an universal reference
template<typ
浏览 2提问于2016-08-07得票数 32
回答已采纳
如果我想提取常量引用的类型(比如const double &中的double)，我是否必须使用：
typename std::remove_cv<typename std::remove_reference<Type>::type>::type
或
typename std::remove_reference<typename std::remove_cv<Type>::type>::type
浏览 0提问于2013-06-25得票数 19
回答已采纳
给定的
template< class Type >
void constref( Type const ) {}
void constref_call() { double x; constref<double&>( x ); } // OK
template< class Type >
using reference = Type&;
void foo( reference< const int > const x ) { (void) x; } // OK
template< class
浏览 3提问于2015-03-17得票数 3
回答已采纳
我有三个编译器(大致是C++98)，我试图在其中编译一些模板。模板以函数类型作为参数。
如果我尝试在C++11编译器中编译，那么它只是在函数类型是cv限定的情况下工作。三个C++98编译器中的两个如果符合cv条件，就无法编译。
这在C++98编译器中正确吗？
浏览 2提问于2015-10-08得票数 0
回答已采纳
3回答
我尝试使用一个自定义类的实例作为模板参数。
class X {
public:
X() {};
};
template <class Foo, Foo foo>
struct Bar {
};
const X x;
Bar<X, x> foo;
编译器声明x不能出现在常量表达式中。为什么呢？可以在编译时构造该对象。
浏览 2提问于2010-03-26得票数 1
回答已采纳
1回答
#include<type_traits>
template <typename T, T>
struct A { };
template <typename T, T t>
void f(A<T, t>) {
}
int main() {
f(A<const int, 0>{});
}
该程序在C++14和C++17模式下被GCC和ICC接受，在C++14模式下被Clang接受，但在C++17模式下被Clang拒绝，在任何模式下都被MSVC拒绝。
拒绝包括这样的诊断：
<source>:12:5: e
浏览 6提问于2022-02-11得票数 13
1回答
依赖于参数的朋友函数查找
、、、
请考虑以下几点：
namespace N {
struct A { };
struct B {
B() { }
B(A const&) { }
friend void f(B const& ) { }
};
}
int main() {
f(N::B{}); // ok
f(N::A{}); // error
}
在第一种情况下，这种情况成功了--我们考虑N::B的相关名称空间并找到N::f(B const&)。太棒了。
第二个案子失败了。为什么？根据
如果非本地类中的frie
浏览 2提问于2016-03-16得票数 8
回答已采纳
1回答
下面的声明如何用const first来表达(不带typedef)？
double* const (&data)[6]
// ?? const double* (&data)[6] // incorrect, elements, not reference, are const
谢谢
浏览 0提问于2010-08-24得票数 3
回答已采纳
1回答
考虑以下代码片段：
class A;
class B {
public:
B(){}
B(A&) // conversion constructor that takes cv-unqualified A
{
cout << "called B's conversion constructor" << endl;
}
};
class A {
public:
operator
浏览 0提问于2018-03-16得票数 0
我读过关于这个标准转换的现有问题。然而，我没有找到令人满意的答案。
我有一段代码，它显示T*重载是选择而不是T&&重载。据我所知，转发引用重载应该绑定所有内容，除非另一个重载是完全匹配的。
在下面的代码中，tab是一个char const(&)[4]。
有人能解释一下为什么在这里执行数组到指针的转换吗？如果有办法解决这个问题，我会全神贯注的！
(coliru )
#include <utility>
template <typename T>
void f(T&& lol)
{
}
template <typename
浏览 3提问于2016-08-30得票数 3
回答已采纳
在中，我找到了几个对top-level cv-qualifiers的引用，但没有定义。
浏览 5提问于2014-07-10得票数 15
回答已采纳
2回答
C规范将const和volatile称为cv-qualifier。
specifier和qualifier (cv-qualifier)之间的区别到底是什么？限定符也是说明符吗？
qualifier有必要只有一个左值吗？
除了cv-qualifier之外，还有哪些限定符
我上面的理解有什么意义吗？
浏览 1提问于2010-09-01得票数 14
回答已采纳
5回答
这是一个错误：
error: static member function ‘static void myClass::myfunct()’ cannot have cv-qualifier
请有人解释一下这个错误，以及为什么不能使用const。
#include<iostream>
class myClass{
static void myfunct() const
{
//do something
}
};
int main()
{
//some code
return 0;
}
浏览 2提问于2013-11-06得票数 38
回答已采纳
1回答
下面的代码编译(gcc 4.7.2或icc 13)并产生“12”输出。这意味着删除了const限定符，即f<int&>具有参数类型int&。
为什么会发生这种事？据我所知，根据第14.3.1.4节：
如果模板参数T的模板-参数命名为类型“对cv1 S的引用”，则创建类型“对cv2 T的引用”的尝试将创建“对cv12 S的引用”类型，其中cv12是cv-qualifiers cv1和cv2的联合。冗余的cvfi用户被忽略。
不应放弃const。以下是代码：
#include <iostream>
using namespace std;
templa
浏览 1提问于2013-02-07得票数 6
2回答
有没有可能在下面的设置中
template <typename T>
inline void id() {
//...
}
template <typename T>
bool check() {
return &id<T> == &id<T const>;
}
check会为一些T返回true吗？它依赖于id内部正在做的事情吗？标准对此有何评论？
浏览 0提问于2012-09-30得票数 2
回答已采纳
我目前正在为一个自定义的集合式类编写迭代器。我有一个可以完美工作的可变迭代器类，但我认为最好也实现一个const版本，它将阻止对其内容正在迭代的对象进行修改。我决定使用我在网上找到的一个使用条件类型的建议来避免单独的类和代码重复。
我以典型的C++11方式定义了iterator_traits类型别名，它允许代码共享和依赖于模板参数的常量或可变行为(ItemType是外部容器类上的模板参数)：
template<bool Const = false>
class iterator {
public:
using reference = std::conditional_t&l
浏览 0提问于2019-09-07得票数 0
2回答
当T是double(float)const时，当我尝试使用function<T>时，我会得到这个错误。
implicit instantiation of undefined template 'std::function<double (float) const>'
但是，当T是double(float)时，就可以了。我试图使用std:: remove_cv<T>::type来删除这个const，但这是行不通的。没错，我有#include<functional>。
因此，我的主要问题是:如何修复这个问题并删除const，以便我可
浏览 6提问于2014-09-03得票数 9
回答已采纳
我正在使用Xcode 4.6.2 (4H1003)中包含的Clang。
Apple LLVM version 4.2 (clang-425.0.28) (based on LLVM 3.2svn)
目前，我的编译器不会对此代码产生编译错误。
using AA = int const;
static AA const aa = 0;
因为我不熟悉准确的C++11规范，我不知道什么是正确的行为。
双const关键字出错。
const on using是不允许的。
这是个特例。
这是编译器的错误。
什么是标准的预期行为？
浏览 1提问于2013-05-31得票数 1
回答已采纳
1回答
考虑一个例子：
#include <iostream>
#include <vector>
template <class, class T>
using alias = T;
template <template <class...> class>
struct tt_wrapper{};
template <class...>
struct t_wrapper{};
struct A {
template <template <class...> class TT, class T&g
浏览 3提问于2017-10-18得票数 4
回答已采纳
5回答
我想知道C++是如何使用它的const关键字的。
我有下面的函数定义。这一点看起来很疯狂，但工作起来很好。
const int const * const Get(){ return new int(1); } const
我知道const的每个位置意味着什么，这个问题不是关于const关键字的位置的意义。
我对const关键字的使用感到非常困惑，因为您可以复制它们。
const int const const * const Get(){ return new int(1); } const
// or even
const const int const const * const c
浏览 2提问于2015-06-12得票数 3
1回答
转发引用的绑定优先级
、、、
请有人帮助我理解为什么下面的代码输出T&&而不是const A&
class A{};
template< typename T >
void foo( T&& )
{
std::cout << "T&&" << std::endl;
}
void foo( const A& )
{
std::cout << "const A&" << std::endl;
}
int main()
{
A a;
fo
浏览 4提问于2017-10-29得票数 2
回答已采纳
有人能帮我理解下面的代码吗？
#include <iostream>
void foo(const char * c)
{
std::cout << "const char *" << std::endl;
}
template <size_t N>
void foo(const char (&t) [N])
{
std::cout << "array ref" << std::endl;
std::cout << sizeof(t) <<
浏览 0提问于2011-03-03得票数 35
我想要创建一个模板，在那里我可以使用不同的向量类型，和常量作为相同类型的向量。我希望能够将常量作为模板参数传递，以便让编译器对其进行优化，而不需要显式的专门化。
所以我试着重复使用类型参数，但是我得到了非法类型。
#include <vector>
using namespace std;
template<typename WEIGHT, WEIGHT multiplier>
void test_multipier(vector<WEIGHT> &v)
{
uint16_t num = 16;
/*...*/
WEIGHT
浏览 5提问于2015-10-01得票数 0
回答已采纳
1回答
假设我有一个变量函数模板，它使用函数指针指向带有上述变量参数的函数。以下代码不是在gcc (11.2)下编译的，而是在clang和msvc ()下编译的。
#include <type_traits>
void dummyFunc(const int);
template<typename... Args>
void callFunc(void(*)(Args...), Args&&...); // <- this one is problematic
// see https://stackoverflow.com/questions/670
浏览 0提问于2022-03-28得票数 4
回答已采纳
2回答
简化的示例代码：
#include <iostream>
template<typename T>
void func(T &x)
{
std::cout << "non-const " << x << std::endl;
}
template<typename T>
void func(const T &x)
{
std::cout << "const " << x << std::endl;
}
template
浏览 0提问于2012-04-20得票数 16
回答已采纳
2回答
在用微软VisualStudio 2008构建一个小的示例程序时，我注意到了一个关于传递给模板的类型推导的奇怪事情。考虑这个例子：
template<class T>
void f( T v ) {
x; // trigger a compile error
(void)v;
}
template<class T>
void g( T v ) {
f( v );
}
void h() {
int i;
g<const int &>( i );
}
使用cl /c foo.cpp编译此示例会产生编译错误(正如预期的那
浏览 0提问于2010-11-12得票数 7
回答已采纳
1回答
我很难理解为什么以下内容没有编译。我有如下代码(一些代码已完成)：
标题：
template <typename KeyType, typename ElementType>
class TUnorderedMap
{
public:
ElementType* Find(const KeyType Key);
const ElementType* Find(const KeyType Key) const;
};
struct Foo
{
};
源文件：
void Lookup()
{
TUnorderedMap <Foo*, Foo> Nod
浏览 1提问于2022-08-23得票数 0
回答已采纳
3回答
我正在学习非类型模板参数的C++17新特性decltype(auto)。我编写了一个简单的代码片段如下：
#include <type_traits>
template<decltype(auto) arg>
struct Foo {};
int
main()
{
constexpr int x = 42;
static_assert(std::is_same_v<Foo<42>, Foo<x>>);
}
据我所知，Foo<42>应该是与Foo<x>相同的类型。
然而，static_asse
浏览 4提问于2020-10-18得票数 22
我正在阅读关于模板中类型推断的文章，下面是一个困扰我的问题。
template<typename T>
void funt(T const &t);
int x = 10;
func(x);
T将被推断为const int，t的类型将是int const & --我理解为什么t必须是int const &，因此传递给函数的x将保持不变，因为函数接受const T&。但我不明白为什么T也必须是const。在我看来，将T推断为int不会破坏这段代码中的任何内容？就像在另一个例子中：
template<typename T>
void funt
浏览 0提问于2017-02-23得票数 1
回答已采纳
2回答
我最近发现，您可以在函数声明及其实现中从值参数中添加和删除cv-限定符。例如：
F.h
f(const int i);
F.cpp
f(int i) { i++; }
test.cpp
#include "F.h"
f(0);
将调用f(int i)实现。由于它是一个按值计算的副本，所以我认为代码编译没有问题。但是，有人能想象出这样一种情况吗?就像上面所做的那样，在声明中添加const是有帮助的吗？为什么这是可能的？也许有人能给出一个更有用的应用？
浏览 3提问于2014-01-15得票数 3
回答已采纳
假设我有两个函数重载
template <typename T>
void f(const T&) {
cout << "f(T&)" << endl;
}
template <typename T>
void f(const T*) {
cout << "f(T*)" << endl;
}
为什么f(new int)要解决f(const T&)而不是f(const T*)？在标准的任何地方谈论这种违反直觉的行为？
浏览 1提问于2017-02-16得票数 9
回答已采纳
在cp偏好中，我们可以将其实现为：
namespace detail {
template <class T>
struct type_identity { using type = T; }; // or use std::type_identity (since C++20)
template <class T>
auto try_add_pointer(int) -> type_identity<typename std::remove_reference<T>::type*>;
template <class T>
浏览 4提问于2020-03-30得票数 2
回答已采纳
2回答
同类型限定符
、、
一个类型有两个const，会发出警告/错误。但是，如果该类型是用typedef定义的，编译器就会接受它( Visual 2013和在线编译器C++ shell)。
#include <iostream>
typedef const int value_type;
int main()
{
const value_type n = 0; //ok
const const int n2 = 0; //error C4114
return 0;
}
有谁知道为什么吗？是const (const int)，与const const int不同吗？
浏览 0提问于2017-08-03得票数 24
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
