使用C++ 14标准,std::array可以使用单个括号进行初始化(请参阅http://en.cppreference.com/w/cpp/container/array):
然而,这并没有为工作std::array的std::pair.
为什么这些工作:
std::pair<int, int> p { 1, 2 };
std::array<int, 3> a {1, 2, 3};
但是这不工作:
std::array<std::pair<int, int>, 3> b {{1, 11}, {2, 22}, {3, 33}};
虽然这确实有效吗？
std::array<std::pair<int, int>, 3> b {{{1, 11}, {2, 22}, {3, 33}}};
此外,为了完成,一个好的旧数组的初始化确实适用于单个大括号
std::pair<int, int> c[3] {{1, 11}, {2, 22}, {3, 33}};
是否有一个固定长度序列的标准容器,其长度在运行时确定.我想将参数传递给每个sequence元素的构造函数,并使用该参数初始化const成员(或引用).我还想在O(1)中的给定索引处获得序列元素.在我看来,我的所有要求都无法同时满足.
std::array有固定长度,但必须在编译时知道该长度.std::vector具有动态大小,并允许使用传递构造函数参数emplace.虽然你可以reserve记忆以避免实际的重新分配,但是类型仍然必须是可移动的,理论上允许这样的重新分配,例如防止const成员.std::list并且std::forward_list,它不需要可移动类型,但仍然可调整大小并且在随机访问模式下将表现得相当差.我还认为这些列表可能会产生相当大的开销,因为每个列表节点可能会单独分配.std::valarray到目前为止,这是我最好的选择,因为它有一个固定的长度,不会自动调整大小.虽然有一种resize方法,但除非您实际调用该方法,否则您的类型不必是可移动的.这里的主要缺点是缺少自定义构造函数参数,因此使用此方法无法初始化const成员.我错过了一些替代方案吗？有没有办法调整其中一个标准容器,以满足我的所有要求？
编辑:为了让您更准确地了解我正在尝试做什么,请参阅此示例:
class A {
void foo(unsigned n);
};
class B {
private:
A* const a;
const unsigned i;
public:
B(A* aa) : a(aa), i(0) { }
B(A* aa, unsigned ii) : a(aa), i(ii) { }
B(const std::pair<A*, unsigned>& args) : B(args.first, args.second) { }
B(const B&) = delete;
B(B&&) = delete;
B& operator=(const B&) = delete; …在C++ 参考的c_str()在std::string出现以下:
返回值
指向基础字符存储的指针.
data()[i] == operator[](i) for every i in [0, size())(直到C++ 11)
data() + i == &operator[](i) for every i in [0, size()](自C++ 11起)
我不明白两者之间的区别,除了自C++ 11以来一个元素的范围增加.
前一种说法data()[i] == operator[](i)对后者来说也不正确吗？
我在尝试学习std::variant。我不明白为什么在这个例子中，我不想初始化ab，并且我std::monostate为此使用，类A被构造一次，但被破坏两次。怎么了？
#include <iostream>
#include <variant>
struct A
{
A() { std::cout << "Constructing A\n"; }
~A() { std::cout << "Destructing A\n"; }
};
struct B
{
B() { std::cout << "Constructing B\n"; }
~B() { std::cout << "Destructing B\n"; }
};
int main()
{
std::variant<std::monostate, A, B> ab;
ab = A();
}
运行此示例会给出以下输出。
Constructing A
Destructing A
Destructing A
我有一个函数有两个类的实例作为参数:
void cookPasta(const Tomato& tomato, const Meat* meat)
{
if (meat != nullptr)
cookPastaWithMeat(tomato, *meat);
else
cookPastaWithoutMeat(tomato);
}
正如函数所示,Tomato总是需要一个实例,而是Meat可选的,nullptr而是可以传递一个实例.我这样做是为了允许cookPasta函数被调用,即使用户从未声明过Meat该类的实例.
在函数签名中混合引用和指针是不好的做法吗？
我尝试为学生创建一个教程.我想对我问他们的问题进行编号,但在两者之间,我想添加信息来介绍问题.如何制作自动编号的列表,每次放置文本时都不会重置编号.例如:
This is some info.
1. This is question one.
This is more info.
2. This is question two.
给出输出:
这是一些信息.
这是更多信息.
我有一个三维数组,我想使用一个二维数组进行掩码,该数组的尺寸与三维数组中最右边的两个相同.有没有办法在不编写以下循环的情况下执行此操作？
import numpy as np
nx = 2
nt = 4
field3d = np.random.rand(nt, nx, nx)
field2d = np.random.rand(nx, nx)
field3d_mask = np.zeros(field3d.shape, dtype=bool)
for t in range(nt):
field3d_mask[t,:,:] = field2d > 0.3
field3d = np.ma.array(field3d, mask=field3d_mask)
print field2d
print field3d
我有一个数组,它通过f2py从fortran子程序读取为1D数组.然后在python中,该数组被重新整形:
a=np.zeros(nx*ny*nz)
read_fortran_array(a)
a=a.reshape(nz,ny,nx) #in fortran, the order is a(nx,ny,nz), C/Python it is reversed
现在我想将该数组作为3D数组传递回fortran.
some_data=fortran_routine(a)
问题是f2py在传递给fortran_routine之前一直试图转置一个.fortran例程看起来像:
subroutine fortran_routine(nx,ny,nz,a,b)
real a
real b
integer nx,ny,nz
!f2py intent(hidden) nx,ny,nz
!f2py intent(in) a
!f2py intent(out) b
...
end subroutine
如何防止所有来回移调？(我很高兴在两种语言中使用不同的数组索引约定).
编辑
似乎np.asfortranarray或者np.flags.f_contiguous应该在解决方案中有一些部分,我似乎无法弄清楚它是什么部分(或者可能是ravel后面的一个reshape(shape,order='F')？
编辑
看来这篇文章引起了一些混乱.这里的问题是f2py尝试保留索引方案而不是内存布局.所以,如果我有一个带有形状的numpy数组(按C顺序)(nz, ny, nx),那么f2py也会尝试使该数组(nz, ny, nx)在fortran中具有形状.如果f2py保留了内存布局,那么数组将(nz, ny, nx)在python和(nx, ny ,nz)fortran中具有形状.我想保留内存布局.
以下代码使用g ++ 7编译器和Apple clang ++给出了不同的结果.在使用bool输出时std::boolalpha,我是否碰到了铿锵声中的错误,或者我犯了错误？
#include <string>
#include <sstream>
#include <iostream>
#include <iomanip>
template<typename T>
void print_item(std::string name, T& item) {
std::ostringstream ss;
ss << std::left << std::setw(30) << name << "= "
<< std::right << std::setw(11) << std::setprecision(5)
<< std::boolalpha << item << " (blabla)" << std::endl;
std::cout << ss.str();
}
int main() {
int i = 34;
std::string s = "Hello!";
double d = 2.;
bool b = true;
print_item("i", i);
print_item("s", s);
print_item("d", d);
print_item("b", …我有这个C++函数,我可以使用下面的代码从Python调用它.与运行纯C++相比,性能只有一半.有没有办法让他们的表现达到同一水平？我用-Ofast -march=native标志编译两个代码.我不明白我可以在哪里丢失50%,因为大部分时间都应该花在C++内核上.Cython是否制作了我可以避免的内存副本？
namespace diff
{
void diff_cpp(double* __restrict__ at, const double* __restrict__ a, const double visc,
const double dxidxi, const double dyidyi, const double dzidzi,
const int itot, const int jtot, const int ktot)
{
const int ii = 1;
const int jj = itot;
const int kk = itot*jtot;
for (int k=1; k<ktot-1; k++)
for (int j=1; j<jtot-1; j++)
for (int i=1; i<itot-1; i++)
{
const int ijk = i + j*jj + k*kk;
at[ijk] += visc …