接受DenseBase<Derived>的非常数引用并将其填充到函数中不起作用
是一个编程问题，涉及到模板和引用的使用。
在C++中，模板是一种通用的编程工具，可以用来创建泛型代码。DenseBase<Derived>表示一个模板类，它接受一个派生类作为参数。非常数引用表示函数参数是一个对对象的引用，可以修改该对象的值。
根据问题描述，函数接受一个对DenseBase<Derived>对象的非常数引用，并将其填充到函数中。然而，无论在函数中如何修改该对象，对原始对象没有任何影响。
这可能是因为函数参数使用了非常数引用，但没有对参数进行修改。在C++中，非常数引用可以用于传递对象并允许对其进行修改。但是，如果函数内部没有对参数进行修改，那么对原始对象也不会产生任何影响。
解决这个问题的方法是在函数中对参数进行修改，或者将参数声明为常数引用。如果函数需要修改参数的值并影响原始对象，可以使用非常数引用。如果函数只需要读取参数的值而不修改它，可以使用常数引用。
以下是一个示例代码，演示了如何正确使用非常数引用来修改参数并影响原始对象：
template<typename Derived>
void fillMatrix(DenseBase<Derived>& matrix) {
// 在函数中修改参数
matrix.fill(0);
}
int main() {
Eigen::Matrix<int, 3, 3> matrix;
matrix << 1, 2, 3,
4, 5, 6,
7, 8, 9;
fillMatrix(matrix);
// 输出修改后的矩阵
std::cout << matrix << std::endl;
return 0;
}在上面的示例中，fillMatrix函数接受一个对DenseBase<Derived>对象的非常数引用，并使用fill函数将矩阵的所有元素设置为0。在主函数中调用fillMatrix函数后，原始矩阵的所有元素都被修改为0，并输出修改后的矩阵。
这是一个简单的示例，展示了如何正确使用非常数引用来修改参数并影响原始对象。具体的实现可能因使用的编程语言和库而有所不同。
关于DenseBase、Derived和函数的具体细节，需要根据具体的编程语言和库来确定。在C++中，DenseBase可能是一个模板类，Derived是其派生类，函数可能是一个模板函数。具体的实现和用法可以参考相关的文档和教程。
腾讯云相关产品和产品介绍链接地址：
- 腾讯云云计算产品：https://cloud.tencent.com/product
- 腾讯云数据库产品：https://cloud.tencent.com/product/cdb
- 腾讯云服务器产品：https://cloud.tencent.com/product/cvm
- 腾讯云人工智能产品：https://cloud.tencent.com/product/ai
- 腾讯云物联网产品：https://cloud.tencent.com/product/iot
- 腾讯云移动开发产品：https://cloud.tencent.com/product/mobdev
- 腾讯云存储产品：https://cloud.tencent.com/product/cos
- 腾讯云区块链产品：https://cloud.tencent.com/product/baas
- 腾讯云元宇宙产品：https://cloud.tencent.com/product/vr
相关·内容
我正在编写一个函数来对Eigen中的密集矩阵或数组进行排序，并返回排列的索引。该函数如下：
template<typename Derived1, typename Derived2>
typename Derived1::PlainObject sort(const DenseBase<Derived1> &x, DenseBase<Derived2> &indices)
{
typename Derived1::PlainObject y = x.derived();
typename Derived2::PlainObj
浏览 2提问于2020-05-18得票数 0
回答已采纳
1回答
线性代数模
、、、
我正在做一个线性代数模块，以提高我的数学知识，因为我将需要一个轻量级线性代数模块，我的未来工作与Vulkan！
我试图保持一种类似blas的例程风格，例如，相关的函数称为：
template <typename T, std::size_t M, std::size_t N>
Matrix<T, N, M> transposed(const DenseBase<T, M, N>& mat)
整个模块是模板，并与编译时大小矩阵工作。我使用std::vector作为存储容器，因为我希望将它分配到堆中(用于大型矩阵)。
第二个目标是通过引用提供对行/列元素
浏览 0提问于2015-05-16得票数 7
3回答
复制本征中的模板函数参数
、、、、
我正在编写一个使用特征数据类型的泛型类。我已经在为类成员变量分配构造函数参数时遇到了问题。我的代码的一个简化版本是：
template <typename Derived>
class A
{
public:
Eigen::Matrix<Derived> M; // error C2976: too few template parameters
A(const Eigen::DenseBase<Derived> & V)
{
M = V.eval(); // I would want to snapshot the value of V.
浏览 0提问于2019-04-01得票数 7
回答已采纳
在试图追踪一个bug的过程中，我想出了以下简单的程序来说明这个问题：
#include <iostream>
#include <Eigen/Dense>
using Mat = Eigen::Matrix<double, 1, 1, Eigen::AutoAlign>;
template <typename Derived>
auto Modify(const Eigen::DenseBase<Derived>& value)
-> decltype(2*value.derived().array())
{
浏览 4提问于2014-09-10得票数 2
回答已采纳
我想要创建一个可以同时接受Matrix<>或Block<>对象的函数。
示例：
#include <iostream>
#include <Eigen/Dense>
//A simplified example of the function I'm making
double example_function(const Eigen::MatrixXd & input){
double d1 = input.array().pow(2).sum();
double d2 = input.rowwise().no
浏览 2提问于2019-07-17得票数 0
回答已采纳
2回答
派生类作为默认参数g++
、、、、
请看下面的代码：
template<class T>
class A
{
class base
{
};
class derived : public A<T>::base
{
};
public:
int f(typename A<T>::base& arg = typename A<T>::derived())
{
return 0;
}
};
int main()
{
A<int> a;
a.f();
return 0;
}
编译会在g++中生成以下错误消息：
test.cpp:
浏览 0提问于2010-04-16得票数 6
回答已采纳
1回答
扩展特征参考类
、、、、
为了使用自定义类，我尝试扩展Ref Eigen类。我有以下代码：
#include <iostream>
#include <eigen3/Eigen/Dense>
class Interface {
public:
virtual ~Interface() {
}
virtual void customMethod() const = 0;
};
class MyVectorType: public Eigen::Matrix<double, 3, 1, Eigen::DontAlign>,
public Int
浏览 0提问于2019-02-04得票数 4
回答已采纳
5回答
我有两个类Base和Derived：
class Base{
public:
Base(int = 0);
Base(Base&);
Base& operator=(const Base&);
protected:
int protectedData;
private:
int baseData;
};
/////////////DERIVED CLASS
class Derived: public Base{
public:
Derived(int = 0);
Derived(Derived&);
浏览 3提问于2010-10-03得票数 3
回答已采纳
我尝试过编写一个函数，它以ColXpr值作为输入：
typedef Eigen::Array<float, Eigen::Dynamic, Eigen::Dynamic> Signal2D;
void Threshold(Signal2D::ColXpr& params)
{
params = (params >= 0.0f).template cast<float>();
}
当我试图调用这个函数时，我会这样做：
Signal2D arr;
// fill it with stuff
Threshold(arr.col(0));
然后我得到这个编译
浏览 0提问于2014-05-04得票数 2
2回答
我想编写一个可以接受的函数：
密集数组/矩阵，或
稠密阵列/矩阵的转置
是否有可能避免使用完美的转发？
我尝试过使用DenseBase类型参数。但这不能接受矩阵的转置。
我不喜欢使用完美的转发，因为使用sfinae实现类型检查会很繁琐。
目前的解决办法：
#include <Eigen/Eigen>
#include <iostream>
using namespace Eigen;
template <typename U>
auto f(U&& x) {
auto x2 = std::forward<U&
浏览 1提问于2018-09-02得票数 3
回答已采纳
我有一个AP班
template<typename T>
class AP : public std::auto_ptr<T>
{
typedef std::auto_ptr<T> Super;
public:
AP() : Super() { }
AP(T* t) : Super(t) { }
AP(AP<T>& o) : Super(o) { }
};
以及一个返回它的函数。
namespace AIR {
namespace Tests {
namespace
{
AP<A>
浏览 1提问于2011-03-10得票数 1
2回答
代码如下：
#include <vector>
int main()
{
vector<int> v1(5,1);
v1.swap(vector<int> ()); //try to swap v1 with a temporary vector object
}
上面的代码无法编译，错误：
error: no matching function for call to ‘std::vector<int, std::allocator<int> >::swap(std::vector<int, std::al
浏览 6提问于2012-01-15得票数 8
回答已采纳
我编写了用特征矩阵排序行的简单算法。这应该与函数相同：
template <typename D>
void _sort(
const D &M,
Eigen::VectorX<ptrdiff_t>& idx,
std::function<bool(ptrdiff_t, ptrdiff_t)> cmp_fun)
{
// initialize original index locations
idx = Eigen::ArrayX<ptrdiff_t>::LinSpaced(
M.r
浏览 8提问于2022-08-06得票数 0
回答已采纳
1回答
我看到了以下代码，但在谷歌上找不到为什么下面的语句是有效的C++：
Base&& b = Derived();
请解释或提供参考
下面是一个示例代码：
#include <iostream>
using namespace std;
class Base{
public:
virtual ~Base(){}
virtual void say_hi() { cout << "hi base"; }
};
class Derived : public Base{
public:
virtual ~Derived(){
浏览 3提问于2016-01-20得票数 1
回答已采纳
2回答
我有这个：
//function definition
//Point and Range are classes made of 2 ints
Point barycenter_of_vector_in_range(vector<cv::Point> &points, cv::Range range);
//In other place...
vector<vector<Point> > tracks_; //it has some content
for (vector< vector<Point> >::const_
浏览 0提问于2010-10-10得票数 0
回答已采纳
3回答
我正在努力将稀疏矩阵支持添加到开源数学库中，并且不希望对Dense和Sparse矩阵类型都有重复的函数。
下面的示例显示了一个add函数。一个包含两个函数的工作示例，然后是两次失败的尝试。下面提供了一个与代码示例的godbolt链接。
我查看了关于编写采用特征类型的函数的特征文档，但是它们使用Eigen::EigenBase的答案不起作用，因为MatrixBase和SparseMatrixBase都有在EigenBase中不存在的特定方法
我们使用C++14，任何帮助和您的时间是非常感谢！！
#include <Eigen/Core>
#include <Eigen/Spa
浏览 0提问于2019-08-09得票数 9
回答已采纳
我正在尝试转换一个用VS写的数学库，这样它就可以通过GCC编译了。问题是，我有很多重载操作符，如下所示：
template<typename T>
inline quaternion<T> operator+(quaternion<T> &a, quaternion<T> &b)
{return quaternion<T>(a.x+b.x,a.y+b.y,a.z+b.z,a.w+b.w);}
诸若此类。
问题是:这些运算符是在假设其他编译器将支持为如下表达式创建的自动中间件的情况下设计的：
...
quaternion
浏览 0提问于2010-07-18得票数 1
回答已采纳
1回答
考虑如下所示：
template <typename T> struct Foo;
template <typename S> struct Bar
{
template <typename T> operator Foo<T>();
// ...
};
class Baz
{
Baz(Foo<int>&);
};
int main()
{
Bar<float> bar;
Baz baz(bar); // Won't work
}
我想使用一个模板化的运算符来指定一
浏览 3提问于2015-05-01得票数 1
我想有一些关于临时对象的东西我不理解。给定这些关系：
class C {};
class F {
public:
C getC() { return C(); };
};
class N {
public:
N( C & base ){};
};
这是可行的：
N n(C());
这不起作用：
F f;
N n(f.getC()); //compile error
为什么？
浏览 0提问于2012-06-12得票数 0
回答已采纳
引言
我有以下形式的C++17代码：
Base& makeDerived(int val) {
std::shared_ptr<Derived> derived = secondLayer(val);
std::cout << typeid(derived).name() << std::endl;
return *derived;
}
int main(void) {
Base& derived = makeDerived(7);
std::cout << typeid(derived).name(
浏览 6提问于2021-10-04得票数 1
回答已采纳
2回答
带有模板参数的CRTP
、、、
以下代码没有编译..。
namespace {
template<typename T, template<typename> class D>
struct Base {
Base(const T& _t) : t(_t) { }
T t;
};
template<typename T>
struct Derived : Base<T, Derived> {
Derived(const T& _t) : Base<T, Derived
浏览 2提问于2016-01-12得票数 19
2回答
广义复制构造函数
、、、
为什么像shared_ptr这样的类在它们的构造函数中有另一个模板？
例如：
template<class T> class shared_ptr {
public:
template<class Y>
explicit shared_ptr(Y * p);
我一直在阅读Scott的“有效C++”(第45项)，其中指出其背后的想法是通过它们使多态性成为可能；也就是说，如果B是从A派生的，则从shared_ptr<B>构造shared_ptr<A>。
但定义构造函数的方式不像
explicit shared_ptr(T * p);
足够的?
浏览 0提问于2017-05-28得票数 15
所以我只是在写一些代码，把自己难倒了
我有一个类Node和另一个类BinaryTree：
class Node
{
public:
Node();
Node(int thedata, Node* right, Node* left):data(thedata), right_pointer(right), left_pointer(left){};
int get_data(){return data;}
Node* get_right() {return right_pointer;}
Node* get_left() {return left_p
浏览 1提问于2013-03-14得票数 1
回答已采纳
1回答
我正在从我控制之外的基类派生一个类。这个类将由我传入的工厂函数指针创建(在我也无法控制的部分代码中)。 在我的派生类中，我需要向工厂函数传递一个额外的构造函数参数。 我的第一个尝试是尝试通过lambda修改工厂函数，但这不能捕获额外的参数。其他答案解释了为什么这不起作用。接下来，我尝试用std::function来增强这一点，其他答案让我相信它可以工作，但我找不出正确的语法，并且发现示例是不可理解的(甚至不确定我真的理解它在做什么)。 我在这里做错了什么？有没有更好的方法来解决这个问题？ 演示代码： #include <functional>
#include <strin
浏览 15提问于2019-10-09得票数 0
一段时间以来，我一直在努力解决C++的问题。我创建了基类和派生对象类，并试图将对基类和派生对象的引用存储在基类指针的向量中(避免对象切片)。使用指针，我能够运行虚拟方法，并且我可以确认指针指向派生类对象，但是我无法获得派生类特定变量。有什么办法吗？
基类对象：
class Base
{
public:
Manager* manager;
Base(){}
Base(Manager* mManager){
manager = mManager;
}
virtual void init(){}
virtual void sp
浏览 8提问于2020-04-13得票数 0
回答已采纳
为什么当我将shared_ptr<drived>计数器传递给期望使用const shared_ptr<base>&的函数时，它会增加
在中，有一个答案提到：
shared_ptr<Base> and shared_ptr<Derived> are not covariant
我怀疑这与我的问题有关。它们不是协变量是什么意思？
下面是显示场景的代码片段：
#include <iostream>
#include <memory>
class Base {};
class Derived : public Base
浏览 2提问于2019-06-27得票数 4
回答已采纳
2回答
在模板中转换成员函数指针
、、、
假设我有以下两个类：
template<typename T>
struct Base
{
void foo();
};
struct Derived : Base<Derived> {};
我可以这么做：
void (Derived::*thing)() = &Derived::foo;
编译器也很高兴(正如我所期望的)。
当我把它放在两个模板级别时，它突然爆炸了：
template<typename T, T thing>
struct bar {};
template<typename T>
void foo()
{
浏览 0提问于2018-09-13得票数 6
回答已采纳
5回答
引用常量修饰符
、、
FirstOne:：
double & val = 66.6; //illegal
const double & val = 66.6; //legal
我只是在做一些演示程序，通过上面的概念，但不能确定上述概念的确切需求。const在第二个案例中到底做了什么魔法？
SecondOne:：
int nVar = 12;
int &rVar = nVar ;//Ok
double &dVar = nVar ;//Error
const double &cdVar = nVar ;//Ok
为什么第三条语句不起作用，而第四条语句在起作用？
浏览 2提问于2012-12-24得票数 3
回答已采纳
2回答
铸造泛型和泛型
、、、
考虑一下，我有以下3个类/接口：
class MyClass<T> { }
interface IMyInterface { }
class Derived : IMyInterface { }
我希望能够将MyClass<Derived>转换为MyClass<IMyInterface>或visa--相反：
MyClass<Derived> a = new MyClass<Derived>();
MyClass<IMyInterface> b = (MyClass<IMyInterface>)a;
但是，如
浏览 2提问于2010-04-19得票数 6
回答已采纳
3回答
引用临时对象和参数的规则
、、、
假设我有一个类：
class A
{
public:
A() {}
};
和一个函数：
void x(const A & s) {}
我确实是这样做的：
x(A());
有人能给我解释一下通过引用传递临时对象的规则吗？从编译器允许什么，你需要const的地方，如果发生隐式复制等方面来看，你似乎需要const，这是有意义的，但是对于所有这些，有正式的规则吗？
谢谢!
浏览 4提问于2009-04-02得票数 2
回答已采纳
3回答
有人能告诉我为什么这个不起作用吗？我的印象是C++会自动将按值返回函数结果的引用传递给构造函数，但它抱怨找不到匹配的运算符。
class bucket_string {
public:
bucket_string();
bucket_string(bucket_string & rhs);
bucket_string & operator=(bucket_string & rhs);
virtual ~bucket_string();
浏览 0提问于2013-03-26得票数 4
回答已采纳
2回答
我想将NA值填充到我的数据集中。我不知道是否可以这样做：
我有三列，我想填一段距离。
duration distance mode
15 7 car
20 6 walk
13 NA car
20 8 car
18 NA walk
浏览 1提问于2019-09-12得票数 0
回答已采纳
在将coeffRef()与CWiseUnaryView函数一起使用时，我遇到了一些问题，但仅当该函数声明为const时才会遇到问题 可重现的例子： #include <Eigen/Core>
struct dummy_Op {
EIGEN_EMPTY_STRUCT_CTOR(dummy_Op)
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE const double&
operator()(const double &v) const { return v; }
EIGEN_DEVICE_FUNC
EIG
浏览 34提问于2019-06-18得票数 2
4回答
使用*this初始化引用
、、、、
我正在尝试用它的构造函数初始化我的类ShadeRec的一个实例：
ShadeRec(World& world);
所以我传递给它：
ShadeRec sr(*this);
其中"this“是类World的实例。
我得到以下错误：
World.cpp: In member function ‘ShadeRec World::hitObjects(const Ray&) const’:
World.cpp:52: error: no matching function for call to ‘ShadeRec::ShadeRec(const World&)’
Sh
浏览 2提问于2013-03-26得票数 0
回答已采纳
我浏览了已经存在的关于这个主题的帖子，但对解释并不信服。
我能从那里学到的是：
当非静态成员函数被声明为const时，此this指针将受到限制。因为静态成员函数不涉及this指针，所以它们不能被声明为const。
是这样吗？对我来说听起来不太令人信服。我是说，我不是在质疑为什么会这样。我只想找出原因。
浏览 2提问于2015-03-15得票数 0
1回答
请帮助我转换这个函数，以便它可以接受MatrixXf，Matrix3f，Matrix4f，我读了Eigen手册，它建议使用MatrixBase，但这不起作用，Eigen::Ref类也不起作用。谢谢。
void MatrixIO::FEigentoFile(const Eigen::MatrixXf& in_mat,
const std::string filename)
{
fmat fmat_pb;
fmat_pb.set_rows(in_mat.rows());
fmat_pb.set_cols(in_mat.co
浏览 0提问于2017-03-29得票数 0
我想编写两个不同的函数来处理一个常量值和一个给定类型的变量(即int)。
下面是测试用例：
int main(void) {
int x=12;
F(5); // this should print "constant"
F(x); // this should print "variable"
}
我认为这足以定义：
void F(int v) { cout << "constant\n"; }
void F(int& v) { cout << "vari
浏览 3提问于2009-05-30得票数 2
回答已采纳
1回答
根据，C++中的输出参数通常被认为是一种代码气味。然而，我们在中有这样的函数
template< class BidirIt,
class Alloc, class CharT, class Traits >
bool regex_match( BidirIt first, BidirIt last,
std::match_results<BidirIt,Alloc>& m,
const std::basic_regex<CharT,Traits>&
浏览 15提问于2021-07-04得票数 0
2回答
我正在做一个二进制堆的链表类型的实现，在写的时候，我得到了一些错误。现在，我的main.cpp是一个向堆中添加元素的简单测试，但是当我调用"add to heap“函数时，它说找不到它。代码如下：
main.cpp
#include <QtCore/QCoreApplication>
#include "Queue.h"
#include "Heap.h"
#include <bitset>
#include <cmath>
int main(int argc, char *argv[])
{
QCoreAp
浏览 3提问于2013-03-02得票数 1
3回答
我正在尝试编写一个同时接受int和int&的容器。在一个类中这样做是可行的：
template <class T>
class unified_class
{
public:
virtual void f(T &i){}
virtual void f(T &&i) {}
};
呼叫：
unified_class<int> u;
u.f(8); // going to the second method
int a = 9;
u.f(a); // going to the first method
但是当我试图将它分成两个类
浏览 0提问于2012-05-06得票数 0
5回答
我的函数声明是
siteObject(std::string& url, std::string& get, std::string& post);
那么为什么这是site("String 1", "String 2", "String 3")；创建一个不匹配的类型错误。它说它需要一个字符串引用，但它正在接收一个char数组。如果你需要更多细节，请在评论中提问。
浏览 2提问于2011-01-20得票数 2
回答已采纳
2回答
我想从编译下面这行代码
enh::eout << enh::setw(26);
gcc给出了以下错误：
error: no match for 'operator<<' in 'enh::eout << enh::setw(26)'
但是EnhSimOutput类( enh::eout是它的一个实例)确实声明了：
EnhSimOutput& operator<< (setw& p);
如果我实现了一个按值接受对象的操作版本，这个问题就解决了：
EnhSimOutput& operator&l
浏览 0提问于2009-01-15得票数 7
回答已采纳
2回答
R值参考和多态性
、、、、
当我运行以下代码时，会出现以下运行时崩溃：
“称为终止调用的纯虚拟方法，没有活动异常”
我不明白为什么多态在这里不起作用。有人能帮帮我吗。
struct Base
{
virtual void print()=0;
virtual ~Base(){}
};
struct Derived: public Base
{
void print(){cout << "this is Derived\n";}
};
struct Foo
{
Foo(Base&& r): bref{r} {}
void print()
浏览 1提问于2019-07-03得票数 1
回答已采纳
在中，restore_base类的析构函数不是virtual，所以我一直想知道它到底是如何工作的。通常情况下，你会期望restorer_base的析构函数只在对象超出作用域之后执行，但看起来派生的restorer_holder析构函数确实被调用了。有谁愿意给我点启发吗？
浏览 9提问于2011-02-14得票数 8
回答已采纳
为了澄清起见，我引用的是string类中的全局getline()函数。
我想做的是拥有这样的东西：
int main()
{
wifstream in(L"textfile.txt");
someFunc(in);
return 0;
}
void someFunc(const wistream& read)
{
wstring buff;
while(getline(read, buff))
{
//do some processing here
}
}
但是我得到了一个：
Error 2 error
浏览 0提问于2009-08-21得票数 0
回答已采纳
为构造函数创建一个包装器函数，就像下面这样编译得很好：
#include <iostream>
template <typename T>
class wrapper
{
public:
template <typename A0>
T* operator () (const A0& a0) const
{
return new T(a0);
}
};
class Foo
{
public:
Foo(int i) { std::cout << "Foo:Foo(" << i &l
浏览 2提问于2012-02-20得票数 2
考虑以下两类：
class Base
{
Base(const Base& other) {...} // relatively expensive operations here...
Base(int i) {...} // ...here,
virtual ~Base() {...} // ...and here
...
};
class Derived : public Base
{
...
Derived(const Base& other) :Base(other) {...} // so
浏览 1提问于2011-04-24得票数 4
回答已采纳
2回答
Const过载与多态物理
、、、
我有一个访问器成员函数(例如operator[])，它是const重载的：
class Container {
public:
Foo& operator[](int i);
const Foo& operator[](int i) const{
return const_cast<Container *>(this)->operator[](i);
}
};
在这里，const Foo& operator[] const是以这种方式定义的，因此同一件事情不会被定义两次。
现在我想让Containe
浏览 5提问于2019-06-25得票数 3
回答已采纳
以下是模板参数推导的解决方法。
这种变通方法有必要吗？
这会阻止Eigen跨越func的边界来优化表达式吗？
#include <Eigen/Eigen>
#include <iostream>
template <typename T> using Mat = Eigen::Matrix<T, 3, 1>;
template <typename T = int>
inline void func(const Eigen::Ref<const Mat<T> >& a) {
// calcul
浏览 0提问于2018-01-30得票数 0
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
