我想生成一个具有固定稀疏性和随机索引和值的矩阵.
为了简化问题,以数组为例:生成一个只有3个非零值位置的arr [10].如果我只是逐个随机选择这3个索引,那么算法的效率就会因为重复而变坏.
更难,我还想生成一个排名为k的随机矩阵,因为空cols和行可能会导致我的代码出错...这次如何制作？
谢谢!
我在boost1.53中使用coroutine,请参阅下面的代码:
boost::coroutines::coroutine<int()> f(std::bind(foo, ...));
std::vector<decltype(f)> container; // it can be compiled
container.push_back(f); // compile error
错误:
no matching function for call to ‘std::vector<boost::coroutines::coroutine<int(),0> >::vector(paracel::coroutine<int>&)’
更新:错误发生,因为'boost :: coroutines :: coroutine'中没有复制构造/运算符,这里的情况是我只想将'f'保存到将索引映射到'f'的容器中.
我也试过unordered_map和emplace_back,它仍然无法正常工作!
如何使它在C++中工作？
Update2:我尝试了vector,unordered_map,与emplace_back,push_back,std :: move一起映射,并且都失败了.但是list和deque在push_back/emplace_back和std :: move中是可以的:
std::deque<decltype(f)> container1;
container.push_back(std::move(f)); // ok
std::deque<decltype(f)> container2;
container.emplace_back(std::move(f)); // ok
std::list<decltype(f)> container3;
container.push_back(std::move(f)); // ok
std::list<decltype(f)> container4;
container.emplace_back(std::move(f)); // ok
为什么？
我遇到了一些类似的问题并找到了这个问题:是否有可能找出lambda的参数类型和返回类型？.
我在这个问题的答案中使用代码:
#include <iostream>
#include <tuple>
template <typename T>
struct function_traits : public function_traits<decltype(&T::operator())> {};
template <typename ClassType, typename ReturnType, typename... Args>
struct function_traits<ReturnType(ClassType::*)(Args...) const> {
enum { arity = sizeof...(Args) };
typedef ReturnType result_type;
template <size_t i>
struct arg {
typedef typename std::tuple_element<i, std::tuple<Args...>>::type type;
};
};
在我的例子中,(lambda)函数是用户定义的,所以我必须使用模板函数来根据用户定义的函数做一些事情,所以我在下面添加一个代理函数:
template <class F>
void proxy(F func) {
typedef function_traits<decltype(func)> traits;
typename traits::result_type r;
traits::arg<0>::type p; // compile error
}
我得到以下编译错误:
error: `::type` has not been declared
error: expected `;` …为什么gcc无法编译下面的代码成功？可以在类中定义构造函数吗？
#include <string>
using std::string;
class Person{
public:
Person(const string &a, const string &b);
private:
string name, address;
};
Person::Person(const string &a, const string &b){
name(a);
address(b);
}
谢谢!
当我运行我的代码时,存在分段错误.我使用gdb跟踪我的代码并找到下面的错误代码:
(gdb)
30 wgt_indx_src = new int [num_wgts];
(gdb)
Program received signal SIGSEGV, Segmentation fault.
0x0000003735e7201e in _int_malloc () from /lib64/libc.so.6
更重要的是,在我的情况下,num_wgts是41472.我尝试如果它小于12398就可以了,但是当它设置为12399时,存在一个sefmentation故障.
我使用valgrind并获得下面的结果:我想问最后两行是否意味着
同样的指示？
==19944== Invalid free() / delete / delete[]
=19944== at 0x4A04DAC: operator delete[](void*) (vg_replace_malloc.c:256)
==19944== by 0x4039C1: main (main.C:137)
==19944== Address 0x4C36030 is 0 bytes inside a block of size 65,536 free'd
==19944== at 0x4A04DAC: operator delete[](void*) (vg_replace_malloc.c:256)
=19944== by 0x4032FB: grid::~grid() (grid.C:208)
==19944== by 0x403929: main (main.C:127)
我写了一个简单的二进制搜索程序并遇到问题,请看下面我的三个混淆:
如果我选择icc -g main.c或icc -O0 main.c代码返回错误答案,但如果我使用icc -O2 main.c我可以得到正确的答案.
当代码在答案正确mid = (beg + end) / 2;之前定义时,if(beg <= end) {无论我用什么标志来编译它.
我认为问题是mid递归期间堆栈中的局部变量.
帮帮我,谢谢!
#include <stdio.h>
#define MAX 6
int a[MAX] = {1,2,3,4,5,6};
int improved_binary_search(int key, int beg, int end) {
int mid, temp;
//mid = (beg + end) / 2;
if(beg <= end) {
mid = (beg + end ) /2;
if(a[mid] == key)
return mid;
if(a[mid] < key)
return improved_binary_search(key, …请参阅以下代码:
#include <vector>
#include <iostream>
int main(int argc, char *argv[]) {
std::vector<double> obj(10,0);
std::cout << &obj << std::endl;
std::cout << &obj[0] << std::endl;
}
我想知道这两个地址之间的区别并谢谢!据我所知,对于一个阵列状a[5],&a<=> &a[0]<=> a.
BSP和MPI有什么区别？
我知道Pregel的图形计算框架是基于BSP的.他们为什么不直接使用MPI或开发基于MPI的框架？
如果我读取二进制文件,我可以使用以下方法找到第n行:
fseek(fp, 4*sizeof(line),SEEK_SET);
但是在C中读取txt文件时,如:
1 1 2.2
2 3 3.001
3 4 5
我无法确保一行的字节大小,因为在实际情况下,double值可以是2.2或3.0001或5.这次我怎样才能找到使用fseek的第n个？
谢谢!
我想在 C++ 类中进行“懒惰构造”，一个简单的方法是这样的：
#include "b.hpp" // class B
class A {
public:
// invoke B() in b.hpp, this constructor do not actually do init
A(int v_in) : v(v_in) {}
void foo() {
if(flag == false) {
b = create_B_obj();
flag = true;
}
}
private:
B create_B_obj() {
// some expensive ops
//...
}
private:
bool flag = false;
B b;
int v;
};
但是存在的一个问题是 B 可能不包含默认构造函数 ( B())，那么在这种情况下我该如何做“懒惰构造”呢？
顺便说一句：我项目中的 B 类就像一个套接字，需要进行连接或类似绑定的调用，所以我想把这些昂贵的操作懒惰。
c++ sockets constructor default-constructor lazy-initialization
请参阅下面的代码段(请注意,s是一个带有char而不是string的数组):
#include <string>
#include <iostream>
#include <utility>
void func(std::string & s, char a) {
std::cout << "here1" << std::endl;
// ...
}
void func(std::string && s, char a) {
std::cout << "here2" << std::endl;
// ...
}
template <class T>
void foo(T && s) {
std::cout << "foo2" << std::endl;
func(s, ':');
//func(std::forward<T>(s), ':');
}
int main(int agrc, char *argv[])
{
//std::string s("a:b:c:d");
char s[8] = "abcdefg";
foo(std::move(s));
std::string s2("abcd")
foo(s2);
return 0;
}
如果我替换func(s, ':')使用std::forward,它没有区别,foo函数将执行完美转发, …
我使用valgrind来找出堆栈方向的混乱问题.
看下面的代码,我想知道为什么运算符"p1 + = 0x80;*p1 = 1"有效且运算符"p2 - = 0x80;*p2 = 1"根据valgrind无效写入？
我认为所有的变量都根据操作系统在堆栈中分配,并且它正在增长到较低的地址,所以我认为" - ="是有效的,而"+ ="是无效的,因为它可能比较大到堆栈顶部可能不在堆栈限制中.
#include <stdlib.h>
int main()
{
int a;
int *p1 = &a;
p1 += 0x80;
int *p2 = &a;
*p1 = 1;
p2 -= 0x80;
*p2 = 1;
return EXIT_SUCCESS;
}