C++ 常数自动和对象恒常性

想象一下某个函数（

RetrieveResult

），通过指针/引用/值返回一个对象-我不知道也不想知道，因为事情可能会改变。我只想使用

auto

存储结果，并保护该对象不受当前范围内意外更改的影响，例如，如果对象向上传播

只需写下以下内容就相当直观：

const auto result = RetrieveResult();

如果

RetrieveResult

通过值或引用返回一个对象，那么一切正常。但如果函数返回指针，则恒常性将应用于该指针，而不是指针指向的对象。我还能用什么方法来改变这个对象。书写

const auto const result = ....

导致编译错误的原因：

重复“const”

当然，我可以这样声明变量： 常数自动*。。。 常数自动*常数

但这样我就接近指针了，也就是说，它不是一个通用的解决方案

---

是否有可能保持真正的恒定性，同时提供灵活性（具体类型的独立性）？

库基础v2中有一个名为

std:：propagate_const

的实用程序的实验支持。您可以在它上面写一个类型特性（如果您没有<代码> STD::ExpPATION CONST >您可以考虑自己编写：）

名称空间{
模板
传播常数{
使用类型=T；
};
模板
传播常数>{
使用type=std:：propagate\u const\t；
};
模板
使用PropagateConst\u t=typename PropagateConst:：type；
模板
decltype（自动）传播常数（Type&&in）{
返回const_t{in}；
}
} // 
//然后像这样使用它
常数自动结果=传播常数（RetrieveResult（））；

---

请注意，我上面的解决方案仅检查可能的指针类型中是否存在

运算符*

。你可能想考虑写一个更广泛的测试。 还请注意，这在

propagate_const

示例中使用了引用折叠，因此在您可能期望省略的情况下，至少会发生移动。您可以根据您的用例对其进行优化。我只是想勾勒出我脑子里的想法。也许那会有帮助

template<class T>
struct very_const_t { using type=T; };
template<class T>
struct very_const_t<T*> { using type=typename very_const_t<T>::type const*; };
template<class T>
struct very_const_t<T&> { using type=typename very_const_t<T>::type const&; };

template<class T>
typename very_const_t<T>::type&&
very_const( T&& t ) { return std::forward<T>(t); }

请注意，这可能会阻止省略。然而，我并没有仔细地阻止move语义

这不会将

const

移动到智能指针中。如果您想要：

template<class T, class D>
struct very_const_t<std::unique_ptr<T,D>> { using type=std::unique_ptr<typename very_const_t<T>::type const, D>; };

template<class T>
struct very_const_t<std::shared_ptr<T>> { using type=std::shared_ptr<typename very_const_t<T>::type const>; };

模板
结构very_const_t{using type=std:：unique_ptr；}；
模板
结构very_const_t{using type=std:：shared_ptr；}；

---

将为

unique

和

shared

执行此操作“我不知道也不想知道”如果不知道对象是什么，您应该如何访问该对象？据您所知，它可能是一个重载

->

的类，您认为它是一个指针：P@Rakete1111，例如，我可能只是向前移动对象，而不是触摸it@Alexey如果转发它，为什么要关心它指向的指针是否为

const

？在VS2015中，

const auto-const

不会产生任何编译器错误，只是警告：<代码>警告C4114：同一类型限定符使用不止一次 @ RaKeE1111，总是有一些原因）C++有强大的语法，我试图感知所有这些魔鬼事物。

const auto result = very_const(RetrieveResult());

template<class T, class D>
struct very_const_t<std::unique_ptr<T,D>> { using type=std::unique_ptr<typename very_const_t<T>::type const, D>; };

template<class T>
struct very_const_t<std::shared_ptr<T>> { using type=std::shared_ptr<typename very_const_t<T>::type const>; };