特征矩阵“模板参数推导/替换失败”
特征矩阵是指在机器学习中常用的一种数据表示形式，它将每个数据样本表示为一个向量，其中每个维度对应于一个特征。模板参数推导/替换失败是指在编译过程中，当使用模板函数或类时，编译器无法根据函数调用或类实例化的参数推导出准确的模板参数，导致编译失败。
特征矩阵的分类：特征矩阵可以根据数据类型和特征提取方法进行分类。根据数据类型，特征矩阵可以是数值型特征矩阵、文本型特征矩阵、图像型特征矩阵等。根据特征提取方法，特征矩阵可以是手工设计的特征矩阵、基于统计方法的特征矩阵、基于深度学习的特征矩阵等。
特征矩阵的优势：特征矩阵能够将复杂的数据表示为数值向量，方便机器学习算法的处理和分析。通过提取不同类型的特征，特征矩阵能够捕捉到数据的丰富信息，并在分类、聚类、回归等任务中发挥重要作用。
特征矩阵的应用场景：特征矩阵广泛应用于各个领域的机器学习问题，如图像识别、语音识别、自然语言处理、推荐系统等。在图像识别中，特征矩阵可以表示图像的像素分布、颜色直方图等特征；在语音识别中，特征矩阵可以表示语音信号的频谱特征、声学特征等；在自然语言处理中，特征矩阵可以表示文本的词频、词向量等特征。
推荐的腾讯云相关产品和产品介绍链接地址：腾讯云提供了一系列云计算产品，包括云服务器（Elastic Compute Cloud, EC2）、云数据库（Cloud Database, CDB）、人工智能平台（AI Platform）、图像识别服务（Image Recognition Service）等。这些产品可以帮助用户快速构建和部署云计算应用，并提供稳定可靠的云计算基础设施。
详细了解腾讯云相关产品和服务，请参考腾讯云官方文档：腾讯云产品与服务
注意：本答案只针对给出的问答内容，不涉及其他云计算品牌商。
相关·内容
1回答
在重写template函数时，我有时会用到这样一种技术：
#include <utility>
template<int> struct unique_enum { enum class type {}; };
template<int index> using UniqueEnum = typename unique_enum<index>::type;
template<bool b, int index=1>
using EnableFuncIf = typename std::enable_if< b, UniqueEn
浏览 14提问于2013-06-15得票数 8
回答已采纳
1回答
libstdc++实现了std::experimental::optional ，这是一种SFINAE技术，似乎适用于gcc，但不适用于clang。
我将其简化为以下最小示例：
// Standard enable_if class
template <bool> struct enable_if {};
template <> struct enable_if<true> { typedef int type; };
// An example trait
template <typename> struct trait { static c
浏览 3提问于2015-07-01得票数 2
以下代码可以使用gcc 4.7.2 (mingw)编译得很好
#include <unordered_map>
#include <tuple>
struct test
{
test() =default;
private:
test(test const&) =delete;
};
int main()
{
std::unordered_map<char, test> map;
map.emplace(
std::piecewise_construct,
浏览 0提问于2013-02-11得票数 10
回答已采纳
的C++17标准(最终草案)提到了使用显式指定的模板参数列表来演绎函数模板参数：
在进行演绎并失败的上下文中，或.，如果指定了模板参数列表，并与任何默认模板参数一起标识单个函数模板专门化，则模板id是函数模板专门化的lvalue。
这如何应用于参数包？
考虑一下
template<typename...>
struct S {
S(int) {}
};
template<typename... A>
void f(S<A...>) {}
int main() {
f<int>(0);
}
这是在MSVC上编译的，但不是
浏览 2提问于2020-01-03得票数 7
回答已采纳
1回答
我有以下代码：
class A {
public:
A(std::vector<std::shared_ptr<int>>){}
};
auto x = std::make_shared<int>(0);
auto y = std::make_shared<int>(1);
auto list = {x, y};
auto res = std::make_shared<A>({x, y});
在这个示例中，如果我传递给res变量列表，它会编译，否则，
浏览 0提问于2014-08-07得票数 1
回答已采纳
1回答
关键的问题是，是否被CUDA编译器所支持？
我在Ubuntu上用CUDA 7.5和gcc-4.8。在编译过程中，我的所有模板类都是在头文件中定义的，#included被定义为一个单独的翻译单元。
我有一个简单的cuda_array类，它为std::vector提供了一个薄包装器。它本质上是thrust::host_vector与thrust::device_vector相结合的一个非常简单的版本。其声明是
template <typename T, const size_t N>
class cuda_array {
std::vector<T> host;
浏览 5提问于2015-10-08得票数 2
回答已采纳
除非添加括号，否则我试图理解为什么替换在以下代码段上失败：
template<typename T>
struct A {};
template<typename T>
struct B {
B(A<T>);
};
template<typename T>
void example(A<T>, B<T>);
struct C {};
struct D {
D(C);
};
void example2(C, D);
int main(int argc, char *argv[]) {
ex
浏览 2提问于2020-02-20得票数 6
回答已采纳
#include <typeinfo>
#include <iostream>
using namespace std;
template<typename T, typename U = T> void f1(T a, U b)
{
cout<<typeid(a).name()<<endl;
cout<<typeid(b).name()<<endl;
}
int main()
{
f1<float>(1,2);
}
输出
f->为什么int不像模板实例化那样默认浮动？
浏览 6提问于2021-04-10得票数 1
回答已采纳
为什么下面的C++11程序不编译？
template<template<typename> class X, typename Y> struct C;
template<template<typename> class X, typename Z> struct C<X, X<Z>> {};
template<typename T> using A = T*;
int main()
{
C<A, A<int>> c;
}
错误是：
aggregate ‘C<A, in
浏览 3提问于2014-03-09得票数 2
回答已采纳
2回答
据我所知，下面的代码应该是“不是推导出来的上下文”(或者不是？)
template <class... X, class Y>
void f(X... args, Y y)
{
}
int main()
{
f(12);
f<int, int, int>(1, 2, 3, 4);
}
但是g++ 4.9为main中的两个f实例化编译了它...有谁能解释一下吗？
浏览 0提问于2015-05-20得票数 5
2回答
GCC接受以下代码：
template <typename T>
struct meta
{
typedef typename T::type type;
};
struct S {};
template <typename T>
typename meta<T>::type foo(T, S);
int foo(int, int);
int main()
{
foo(0, 0);
}
但clang拒绝了它，并显示以下错误：
test.cpp:4:22: error: type 'int' cannot b
浏览 270提问于2012-08-18得票数 21
回答已采纳
2回答
考虑以下程序：
template <class T> struct A { using X = typename T::X; };
template <class T, typename A<T>::X* = nullptr> void f(T, int);
void f(...);
template <class T> void g(T, int, typename A<T>::X* = nullptr); // #
void g(...);
int main() {
// f(0, nullptr); // error
浏览 1提问于2018-10-28得票数 9
1回答
考虑下面的代码：
#include <iostream>
#include <type_traits>
using namespace std;
template<typename T_orig> void f(T_orig& a){
a=5;
}
template<typename T_orig, typename T=T_orig&> void g(T a){
a=8;
}
int main() {
int b=3;
f<decltype(b)>(b);
cout&l
浏览 0提问于2012-11-30得票数 7
回答已采纳
我正在尝试创建一个带有可选参数的模板化函数，并且我很难理解为什么编译失败。这是我的测试代码(人为的)：
#include <iostream>
#include <vector>
template <class UnaryPredicate>
int GetCountIf(std::vector<int> v, UnaryPredicate pred = [](auto) { return true; }) {
int count=0;
for (auto i: v) {
if (pred(i)) {
count++
浏览 0提问于2019-02-21得票数 8
回答已采纳
1回答
我在玩一些指向非静态方法的函数指针，偶然发现了一些对我来说不太有意义的GCC信息。让我们看看一些代码：
#include<iostream>
struct X{ int print() const { std::cout << "hello"; return 0; } };
struct Y: public X{};
template<class T>
struct print_one
{
const T& t;
print_one(const T& _t): t(_t) {}
template<c
浏览 0提问于2020-04-16得票数 2
回答已采纳
我找到了一篇关于这个主题的很棒的文章，在第10页，作者注意到了两件重要的事情：
当使用启用器重载函数模板时，使能器被放置在声明部分中。
不需要实现通常的dispatcher --一个分配给实现的单独接口函数。
点1可以在SO上找到这个。作者声明(打印出来的文章的第10页)，也可以使用使能器作为函数参数，这就是我要做的事情，但是在那个示例中，ADL失败了。
第2点是依赖于SFINAE和减少函数模板集。当使能器失败时，SFINAE将不会报告错误，并且当选择最适合的模板时，将导致参数的推导。
话虽如此，我还是修改了以前的：
#include <type_traits>
#
浏览 1提问于2014-03-26得票数 0
回答已采纳
2回答
我希望有一个模板参数，接受一个具有数值模板参数的模板。
这个例子可能过于简化了，但我想这样做：
template <int X>
struct XX
{
static const int x = X;
};
template<typename TT, TT V, template<V> TX>
void fnx(TX<V> x)
{
static_assert(V == TX::x, "IMPOSSIBLE!");
}
void fny()
{
fnx(XX<1>())
}
我不能理解这方面的语法，因为
浏览 0提问于2016-05-22得票数 6
回答已采纳
1回答
我写了以下模板参数推导失败的代码：
template<int>
struct num {};
template<int m>
void match(num<2*m>) {
}
int main()
{
match(num<2>());
return 0;
}
我凭直觉知道编译器无法推导出正确的m，但我想了解它失败的理论基础。有人能澄清一下吗？
浏览 0提问于2012-11-28得票数 5
回答已采纳
2回答
没有角括号的模板类实例化
、、、、
我想知道这个代码是否合法(当然是在C++17中)：
template<typename T = int>
class C {};
int main() {
C c;
}
这在GCC 8.1.0中编译得很好，但Clang 6.0.0却失败了。我试图在“标准”中找到答案，但我不是语言律师，我也想不出答案。另一方面，声明如下：
std::less l; // same as std::less<void> l;
那么，是否可以定义一个对象，其类型是一个模板类，其中所有模板参数都有默认值，而不使用角括号。
编辑
我试图澄清我的疑问:我的代码，只
浏览 2提问于2018-06-21得票数 4
我遇到了另一个我不明白的问题。
下面的代码没有实例化(实例化参数失败)，为什么？
template<class E>
void operator[](typename boost::mpl::identity<E>::type e) const;
谢谢你的帮助
浏览 0提问于2010-06-09得票数 3
回答已采纳
1回答
我有一个类，Jav::String，我使用了模板。
class String
{
String();
String(std::size_t);
template <class ITER_WRAP>
String(const ITER_WRAP &iterator_begin_end);
}
我期望当我调用带符号整数的字符串时，就像MAX_PATH一样，它会调用std::size_t，也就是unsigned int重载；因为我期望替换不会失败！基本上，int没有begin和end元素，所以替换应该失败，该函数不应该是候选函数的一部分。
然而，令我恐惧的
浏览 0提问于2019-04-12得票数 0
我试图或多或少地序列化一个模板化的类MState<T>。为此，我有一个父抽象类MVariable，它用以下形式实现了几个序列化函数：
template <class Serializer, class SerializedType>
void serialize(Serializer& s, const SOME_SPECIFIC_TYPE &t) const;
我想让T成为几乎任何东西。序列化是通过在JSON中完成的。因此，我需要使用特定的成员函数(例如Writer::String、Writer::Bool、Writer::Uint.)以便为每种类型的
浏览 4提问于2017-12-17得票数 1
回答已采纳
1回答
我正在为我的个人代码库在特征上编写一个小型线性代数实用程序库。为了使它尽可能灵活，我键入了不同的特征矩阵类型作为参数。然而，我一直遇到的一个问题是，当我使用它时，我不能将一个固定大小的(即编译时设置的)矩阵作为参数传递给一个函数，该函数的参数是动态大小的(在运行时设置的)矩阵ty对联。我能理解逆-不能通过一个固定的动态大小的矩阵，因为编译时间检查，但这似乎应该是可行的。
下面的pdist2函数是一个可测试的示例(它实际上应该在特征API中有一个本机实现)。
#include <Eigen/Core>
namespace Eigen
{
template <typen
浏览 4提问于2017-06-27得票数 5
回答已采纳
对于不同类型的特征矩阵(准确地说，是列和矩阵)，我遇到了函数过载的问题。当输入是一些简单算法的结果时，重载失败。特别是：
#include <Eigen/Eigen>
#include <iostream>
typedef Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> MatD;
typedef Eigen::Matrix<double, Eigen::Dynamic, 1, Eigen::ColMajor> ColD;
浏览 1提问于2018-04-26得票数 1
回答已采纳
我正在尝试构建一个模板化的C++函数，该函数接受指向内部类的对象的指针作为其参数。下面是所涉及的类结构的简化版本，类似于典型的链表或树型类：
template <typename T>
struct Outer
{
struct Inner
{
T val;
Inner (T v) : val(v) { }
};
Inner* ptr;
Outer(T val)
{
ptr = new Inner(val);
}
};
为了排除任何访问控制问题，我让它们成为结构体，并删除了一些无关的实例变量。考虑到这个类结构，这里有三个函数，
浏览 0提问于2014-07-25得票数 3
1回答
选择哪类模板专门化的规则是首选的，包括将专门化重写为函数模板，并通过函数模板temp.class.order的排序规则确定哪个函数模板更专业化。那么，考虑一下这个例子：
#include <iostream>
template <class T> struct voider { using type = void; };
template <class T> using void_t = typename voider<T>::type;
template <class T, class U> struct A { };
tem
浏览 6提问于2017-02-23得票数 42
回答已采纳
1回答
我有一个函数foo，它以变量函数指针作为参数。
我希望在函数声明之前使用“使用”来定义参数的类型。
template <typename ... vARGS>
using TFuncType = void(*)(vARGS ... V_args);
template <typename ... vARGS>
void foo(TFuncType<vARGS ...> funcptr) {}
void bar(int i) {}
int main() {
foo(&bar); // This line fails to compile.
}
浏览 2提问于2015-07-04得票数 15
回答已采纳
MSVC CL版本19.14.26433.0
情况是这样的：
auto string_tester = []( auto std_string ) { };
// creates proper std::initializer_list instance
auto init_list = { "narrow string" };
// compiles and works
string_tester(init_list);
但。这是不是也应该编译呢？
// does not compile
string_tester({ "narrow string" }
浏览 0提问于2018-07-25得票数 1
1回答
对可变模板和模板类型推导的误解
、、、、
我正在用C++17编译，代码类似于下面的示例：
#include <iostream>
#include <iterator>
class Foo {};
template <typename... Args,
typename ostream_type = ::std::basic_ostream<Args...>,
typename ostreambuf_iterator_type = ::std::ostreambuf_iterator<Args...>>
ostream_type &operator<
浏览 9提问于2019-10-22得票数 0
回答已采纳
首先，我使用用户定义的转换函数将对象隐式地转换为int，然后使用<<操作符将其插入到cout中。程序已成功编译并打印为“%0”。
#include <iostream>
using namespace std;
class T {
public:
operator int () {
return 0;
}
};
int main()
{
T a;
cout << a << endl;
return 0;
}
然后，我尝试做同样的事情，只是对象被转换为std::string。程序出现编译
浏览 2提问于2019-02-10得票数 1
1回答
我正在经历一个过载的解决行为，这似乎是非常意外的。gcc和clang都拒绝了以下代码，并产生了歧义错误：
template <typename T>
struct A
{
typedef T key_type;
};
template <typename T>
void foo(A<T> rng, T val);
template <typename T, typename U = T>
void foo(T, typename U::key_type);
int main()
{
A<int> i;
f
浏览 1提问于2013-03-29得票数 5
2回答
这是对另一个的一个分支。
我有下面的工作代码，具有预期的输出。
#include <iostream>
template <typename T>
T twice(T in)
{
return 2*in;
}
struct Foo
{
Foo operator+(int (*func)(int in)) const
{
Foo ret{data};
ret.data += func(ret.data);
return ret;
}
int data;
};
int main()
{
Foo f
浏览 1提问于2014-06-24得票数 4
回答已采纳
1回答
模板参数演绎问题
、、
我有一个很简单的模板问题。我想要一些与标量和向量一起工作的数学函数。对于参数，我希望通过复制传递标量，通过引用传递向量。因此，我最终使用了一个模板化的助手结构。
但是，当我使用我的函数时，编译器无法自行推断模板参数。我不知道我做错了什么，或者我应该采取什么不同的做法，或者这种方法从一开始就注定要失败。
下面是一个示例：
#include <type_traits>
template <typename T>
struct CopyOrConstRef
{
using Type = std::conditional_t<
浏览 1提问于2020-09-17得票数 0
回答已采纳
在以下代码中
#include <initializer_list>
#include <utility>
template<typename T> void f(T&& x) {}
template<typename T> void g(std::initializer_list<T> x) {}
int main()
{
auto x = {0}; // OK
auto&& y = {0}; // OK
g(x); // OK
g(std::move(x));
浏览 2提问于2013-07-06得票数 11
回答已采纳
这是中提到的更复杂的问题
以下代码为
void foo() {}
void foo(int) {}
void foo(double) {}
void foo(int, double) {}
// Uncommenting below line break compilation
//template<class T> void foo(T) {}
template<class X, class Y> void bar(void (*f)(X, Y))
{
f(X(), Y());
}
int main()
{
bar(foo);
}
对于模板参数演
浏览 1提问于2016-11-01得票数 22
回答已采纳
2回答
当我使用auto推导指针类型时，我发现了一个奇怪的现象。我的代码是这样的：
#include <iostream>
using namespace std;
int main()
{
int i = 100;
auto p1 = &i;
auto *p2 = &i;
cout << *p1 << " " << *p2 << endl;
return 0;
}
经过编译和执行，我们可以发现*p1和*p2的结果是相同的，都是100。这意味着p1和p2都是指向int
浏览 1提问于2015-11-13得票数 46
3回答
我用模板创建了一个矩阵类：
template <typename T>
class Matrix
{
static_assert(std::is_arithmetic<T>::value,"");
public:
Matrix(size_t n_rows, size_t n_cols);
Matrix(size_t n_rows, size_t n_cols, const T& value);
// Functions
// Operators
Matrix<T>& operato
浏览 0提问于2012-08-18得票数 4
回答已采纳
我试着写一些预处理前的怪物来制作简单的计算机。
这是用g++ -std=c++17编译的
template<typename T>
struct foo{
T x;
foo(T _x):x(_x){}
};
auto x=foo(3);
但是，怪物很难知道x的类型，所以我尝试了如下方法：
template<typename T>
struct foo{
T x;
foo(decltype(x) _x):x(_x){}
};
auto x=foo(3);
失败(class template argument deduction failed
浏览 2提问于2019-11-04得票数 2
回答已采纳
1回答
希望这能引起社区中的一些人的兴趣。希望这不是太明显，因为我不确定发生了什么。我创建了带有递归定义的可变模板类，主要是作为一种有趣的自我挑战。有点像一个元组，这个类创建unordered_maps的unordered_maps，深度任意，每一层都有任意的键类型。例如，您可以创建nested_map<int, std::string, float, int>，然后使用map["fred"][3.4][42] = 35;对其进行设置。这是代码-不太疯狂。
template<typename T, typename K, typename ... KS> str
浏览 0提问于2019-04-08得票数 4
我试图生成一个智能代理函数，以便参数按给定的方式被转发。
下面是代码：
#include <utility>
#include <iostream>
void func(int foo) {
std::cout<<foo<<"\n";
}
template<typename... ARGS>
void proxy( void(*callback)(ARGS...), ARGS&&... args) {
callback( std::forward<ARGS>(args).
浏览 0提问于2019-07-07得票数 1
回答已采纳
1回答
我不明白为什么下面的代码不能工作。编译器(gcc)似乎实例化了这两个方法，显然整数要么是有符号的，要么是无符号的，所以总是失败。我以为enable_if在这里就是为了避免这种情况。
问:为什么会出现编译错误，如何避免？
using namespace boost; // or std as you want
template<typename T>
struct test {
// if signed
template< typename enable_if
< is_signed<T>
浏览 0提问于2014-12-08得票数 4
为什么下面的代码在Visual Studio 2019中编译，而不是在gcc 8.3中编译？
#include<array>
template<typename T> class myClass {
public:
template<unsigned int N> myClass(const std::array<T, N>& elems) { /* do something */ }
};
int main() {
std::array<int, 10> A;
myClass<int> Tabu
浏览 0提问于2020-03-16得票数 6
1回答
具有多个转换的模板参数推导
、、、、
我正在尝试编写一个带有参数的泛型函数，该参数包含模板类型上的多个转换，例如：
#include <iostream>
#include <string>
#include <type_traits>
template< typename _T_ >
void foo
(
const std::basic_string< typename std::remove_cv< typename std::remove_extent< _T_ >::type >::type > & str
)
{
浏览 1提问于2020-02-10得票数 2
回答已采纳
2回答
我尝试在函数参数上使用std::enable_if来触发SFINAE。编译失败，出现此错误：
type_nonsense.cpp:20:5: error: no matching function for call to 'c'
c(SOME::VALUE);
^
type_nonsense.cpp:13:6: note: candidate template ignored: couldn't infer
template argument 'T'
void c(typename std::enable_if<std:
浏览 10提问于2014-10-29得票数 2
回答已采纳
标准说braced-init-list没有任何类型。所以我预计像auto a = {1, 2};这样的东西是畸形的。但这根本不是真的。
#include <iostream>
#include <initializer_list>
using namespace std;
auto a = {1, 2};
std::initializer_list<int> init_list = {1, 3, 6, 7};
decltype(a) b = init_list;
int main(){ }
此外，decltype(a)是std::initiali
浏览 0提问于2014-11-29得票数 2
回答已采纳
1回答
下面是关于以下代码片段的关注：
template<std::size_t Dim, std::size_t N,
typename RangeType1, typename RangeType2>
void multilinear_interp(
const RangeType1 (&coordsFrom)[Dim],
const std::array<RangeType2, N>& field)
{
// do something
}
int main()
{
std::vector<double> x{},
浏览 0提问于2018-10-25得票数 1
3回答
考虑下面的MCVE
struct A {};
template<class T>
void test(T, T) {
}
template<class T>
class Wrapper {
using type = typename T::type;
};
template<class T>
void test(Wrapper<T>, Wrapper<T>) {
}
int main() {
A a, b;
test(a, b); // works
test<A>(a, b)
浏览 0提问于2019-04-30得票数 22
回答已采纳
1回答
我遇到了一个非常奇怪的编译器错误。由于某些原因，发布的代码确实使用g++ (7.3.0)正确编译，而clang (7.0.0)失败：
../TemplateAlias/main.cpp:64:9: error: no matching function for call to 'freeFunc'
freeFunc(new Func, dummyField);
^~~~~~~~
../TemplateAlias/main.cpp:73:12: note: in instantiation of member function 'Helpe
浏览 4提问于2018-11-26得票数 11
回答已采纳
1回答
考虑以下示例()：
template <class... T> struct S { using type = int; };
template <class... T>
void f(typename S<T...>::type) {
static_assert(sizeof...(T) == 0);
}
template <class... T>
void g(typename S<T...>::type, S<T...>*) {}
int main() {
f(42);
g(42, nu
浏览 0提问于2019-07-24得票数 23
的后续行动。假设占位符可用于推断函数指针的结果类型，构成非类型模板参数。c++17是否允许在传递给模板函数名时执行重载解析--而不知道结果类型，这是执行隐式转换所需的吗？
template <auto(*)(int)>
struct Foo { };
int bar(int);
float bar(float);
int main() {
static_cast<void>(Foo<bar>{});
}
和似乎都接受这个代码。
浏览 1提问于2018-01-28得票数 5
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
