是否可以重写这个原始循环:
vector<double> v { ... };
for (size_t i = 1; i<v.size(); ++i) {
v[i]*=v[i-1];
}
或者更加神秘:
for (auto i = v.begin()+1; i<v.end(); ++i) {
(*i) *= *(i-1);
}
(和类似的,也许以更STLish的方式访问v [i-2],...)？
是否存在与上述形式相同或更好(在风格和表现方面)的其他形式？
为了加强我的（弱）函数式编程技能，我正在学习Piegl和Tiller的 NURBS 书，将所有算法转换为 Haskell。这是一个非常好的和有指导意义的过程，但我被困在算法 2.2 上，这是（一个类似 C 的由我重新设计的版本）伪代码：
double[] BasisFuns( int i, double u, int p, double U[]) {
double N[p+1];
double left[p+1];
double ritght[p+1];
N[0]=1.0;
for (j=1; j<=p; j++) {
left[j] = u - U[i+1-j];
right[j] = U[i+j] - u;
double saved = 0.0;
for (r=O; r<j; r++) {
double temp= N[r]/(right[r+1]+left[j-r]);
N[r] = saved+right[r+1]*temp;
saved = left[j-r]*temp;
}
N[j] = saved;
}
return N;
}
外循环看起来很简单，但内循环，对元素的所有那些必须有序的修改N让我头疼。
我开始这样设置：
baseFunc :: RealFrac a …我知道默认情况下不应该启用编程语言的实验性功能,所以我欢迎使用标志-std=c++0x和-std=c++1y.但是,C++ 11现在已经成为标准.为什么编译器仍需要-std=c++11启用对其功能的支持？
我有一个程序,其函数将指针作为arg和main.主要是创建n个线程,每个线程根据传递的内容在不同的内存区域运行arg.然后连接线程,主要在区域之间执行一些数据混合,并创建n个新线程,这些线程执行与旧线程相同的操作.
为了改进程序,我想保持线程活着,消除创建它们所需的长时间.线程应在主要工作时休眠,并在必须再次出现时通知.同样,主要应该在线程工作时等待,就像连接一样.
我无法最终实现这一点,总是陷入僵局.
简单的基线代码,任何有关如何修改它的提示将非常感激
#include <thread>
#include <climits>
...
void myfunc(void * p) {
do_something(p);
}
int main(){
void * myp[n_threads] {a_location, another_location,...};
std::thread mythread[n_threads];
for (unsigned long int j=0; j < ULONG_MAX; j++) {
for (unsigned int i=0; i < n_threads; i++) {
mythread[i] = std::thread(myfunc, myp[i]);
}
for (unsigned int i=0; i < n_threads; i++) {
mythread[i].join();
}
mix_data(myp);
}
return 0;
}
我达到了50种类型的极限boost::variant.我发现这个漂亮的自包含标题,但它缺乏多访问功能(我实际上需要双重访问).
我试着看一下它,但这种方法似乎非常雄心勃勃,与我缺乏元编程经验相冲突......
如果你可以指出一个预先制作的变体实现或者提供一些建议来扩展我喜欢的那个,那将是非常好的,谢谢!
ToFilipRoséen和upvoters:在这里您可以找到我正在考虑的设计的基本示例.随意添加更多关于此的深入评论.
这极小的例子将无法编译,因为A<int>不能访问私有成员i在A<double>
template <class T>
class A {
int i;
public:
template <class U>
void copy_i_from( const A<U> & a ){
i = a.i;
}
};
int main(void) {
A<int> ai;
A<double> ad;
ai.copy_i_from(ad);
return 0;
}
我知道我可以让所有模板实例彼此成为朋友(参见:如何访问其他模板类实例的私有成员？),但由于我只有一个需要访问的方法(如示例所示),我更愿意限制友谊到那个方法.这可能吗？
我有这个模板方法:
template <class SomeLhs, class SomeRhs,
ResultType (SomeLhs::*callback)(SomeRhs&)>
void Add() {
struct Local {
static ResultType Trampoline(BaseLhs& lhs, BaseRhs& rhs) {
return (static_cast<SomeLhs&>(lhs).*callback)(static_cast<SomeRhs&>(rhs));
}
};
_back_end.template Add<SomeLhs,SomeRhs>(&Local::Trampoline);
}
目前我这样称呼它:
tracker.Add<Quad, Multi, &Quad::track>();
tracker.Add<Quad, Singl, &Quad::track>();
tracker.Add<Sext, Multi, &Sext::track>();
...
它工作正常,但我不想重复两次类的名称SomeLhs.有没有办法避免这种情况？
对于那些可能已经认识到它的人:是的,这与Alexandrescu的BasicFastDispatcher有关,特别是我正在编写一个前端来操作成员函数.
写下面的内容是否合法？如果肯定回答你会这样做吗？
vector<int> create_vector() { vector<int> v; ... return v;}
for ( auto i : create_vector() ) {
...
}
我理解这个问题的内容,但是当使用函数重载时,它是如何工作的？
例如,std::map定义了以下方法:
iterator find (const key_type& k);
const_iterator find (const key_type& k) const;
如何使用auto关键字选择一个或另一个？像下面这样的东西对我来说似乎不正确:
auto i = mymap.find(key); //calls the non-const method?
const auto i = mymap.find(key); //calls the const method?
下面的代码合法吗？
template <auto Lambda>
struct A {};
int main () {
auto lmb = [](int i){return i*i;};
A<lmb> a;
return 0;
}
我注意到 g++ 编译得很好，而 clang++ 返回
error: a non-type template parameter cannot have type '(lambda at main.cpp:...)'.