我的结构如下.
struct result{
int a;
int b;
int c;
int d;
}
和联盟如下.
union convert{
int arr[4];
struct result res;
}
我输入双关语如下.
int arr1[4] = {1,2,3,5};
union convert *pointer = (union convert *) arr1; // Here is my question, is it well defined?
printf("%d %d\n", pointer->res.a, pointer->res.b);
在C++ 11中,您可以像这样实例化std :: function:
std::function<void(int)> f1;
std::function<int(std::string, std::string)> f2;
//and so on
但是虽然网上有大量关于可变参数模板的信息,但我找不到任何关于如何编写std :: function-like模板的文章,这些模板会接受带括号的参数.任何人都可以解释一下语法及其局限性,或者至少指出现有的解释吗？
我有以下Foo带嵌套类的示例类Bar,一切都是constexpr:
class Foo
{
private:
template <typename T>
struct Bar
{
constexpr Bar(){}
constexpr int DoTheThing() const
{
return 1;
}
};
public:
constexpr static auto b = Bar<int>{};
constexpr Foo() {}
constexpr int DoTheThing() const
{
return b.DoTheThing();
}
};
我想测试那个调用Foo::DoTheThing返回1:
int main()
{
constexpr Foo f;
static_assert(f.DoTheThing() == 1, "DoTheThing() should return 1");
}
GCC和Clang都在这里抱怨,但MSVC没有
GCC说:
错误:
constexpr Foo::Bar<T>::Bar() [with T = int]在定义之前使用Run Code Online (Sandbox Code Playgroud)constexpr static auto b = …
假设我有一些任意的类,A:
class A {
//... stuff
};
我想调用一个外部API,它接受一个类型的共享指针,就像这样(我不能改变这个接口):
//...much later
void foo(std::shared_ptr<A> _a){
//operate on _a as a shared_ptr
}
但是,在我正在使用的(遗留)代码中,我正在使用的类A实例被分配在堆栈上(我无法解决):
A a;
//...some stuff on a
//Now time to call foo
除此之外,A类的实例非常大,每个实例大约1 GB.
我知道我可以打电话
foo(std::make_shared<A> a);
但这会为A副本分配内存,我真的很想避免.
有没有办法将一些调用std::make_shared(可能是move语义)一起破解,这样我就不会被迫为另一个A类实例分配内存？
我尝试过这样的事情:
foo(std::make_shared<A>(std::move(a)));
但据我所知,A仍然创造了一个新的实例.
#include <iostream>
#include <memory>
using namespace std;
class A{
public:
A(int _var=42) : var(_var){cout << "Default" << endl;}
A(const A& _rhs) : var(_rhs.var){cout << …我正在阅读C++并发性.第2.4章描述了parallell_accumulate算法.
我尝试 - 作为一个学习实验 - 用一般的lambda替换那里使用的仿函数.
我已将编译错误提炼为:
#include <thread>
template <typename T>
struct f {
void operator() (T& result) { result = 1;}
};
int main() {
int x = 0;
auto g = [](auto& result) { result = 1; };
std::thread(f<int>(), std::ref(x)); // COMPILES
std::thread(g, std::ref(x)); // FAILS TO COMPILE
}
错误消息:
In file included from /usr/include/c++/4.9/thread:39:0,
from foo.cpp:1:
/usr/include/c++/4.9/functional: In instantiation of ‘struct std::_Bind_simple<main()::<lambda(auto:1&)>(std::reference_wrapper<int>)>’:
/usr/include/c++/4.9/thread:140:47: required from ‘std::thread::thread(_Callable&&, _Args&& ...) [with _Callable = main()::<lambda(auto:1&)>&; _Args = …有一个测试句和一个参考句.如何编写一个Python脚本,以自动机器翻译评估中使用的BLEU度量标准来衡量这两个句子之间的相似性？
几年前,有人发布了Active State Recipes用于比较目的,三个python/NumPy函数; 每个都接受相同的参数并返回相同的结果,即距离矩阵.
其中两个来自公开来源; 它们都是 - 或者它们在我看来是 - 惯用的numpy代码.创建距离矩阵所需的重复计算由numpy优雅的索引语法驱动.这是其中之一:
from numpy.matlib import repmat, repeat
def calcDistanceMatrixFastEuclidean(points):
numPoints = len(points)
distMat = sqrt(sum((repmat(points, numPoints, 1) -
repeat(points, numPoints, axis=0))**2, axis=1))
return distMat.reshape((numPoints,numPoints))
第三个使用单个循环创建了距离矩阵(显然,由于只有1,000个2D点的距离矩阵,有一百万个条目,因此很多循环).乍一看这个函数看起来像我在学习NumPy时编写的代码,我会编写NumPy代码,首先编写Python代码,然后逐行翻译.
在Active State帖子发布几个月之后,在NumPy邮件列表的一个帖子中发布并讨论了比较三者的性能测试结果.
事实上,循环函数明显优于其他两个函数:
from numpy import mat, zeros, newaxis
def calcDistanceMatrixFastEuclidean2(nDimPoints):
nDimPoints = array(nDimPoints)
n,m = nDimPoints.shape
delta = zeros((n,n),'d')
for d in xrange(m):
data = nDimPoints[:,d]
delta += (data - data[:,newaxis])**2
return sqrt(delta)
线程中的一位参与者(Keir Mierle)提供了为什么这可能是真的:
我怀疑它会更快的原因是它具有更好的局部性,在移动到下一个工作集之前完全完成对相对较小的工作集的计算.一个衬垫必须重复地将潜在的大MxN阵列拉入处理器. …
我正在为我的应用程序开发一个单元测试,但是我遇到了一个我不明白的奇怪问题.
代码是:
double res = BytesTool::convertSize(1, BytesTool::Byte, BytesTool::KiloByte);
double tmp = pow((double)1000, -1);
QVERIFY(res == tmp);
我正在使用Linux机器(主机64位)编译Linux 64位,使用gcc(主机64位),并使用Linux的mingw32编译器对Windows 32位进行交叉编译.
该程序在调试和发布模式下的Linux编译工作正常(断言成功).对于Windows版本,它在调试版本中工作正常,但不适用于发行版本; 断言失败了.
奇怪的是,如果我插入一个跟踪,测试在Windows中工作:
double res = BytesTool::convertSize(1, BytesTool::Byte, BytesTool::KiloByte);
printf("test");
double tmp = pow((double)1000, -1);
QVERIFY(res == tmp); // Is TRUE when printf("test") is present, FALSE otherwise
我迷路了,我真的不明白发生了什么.为什么printf让它工作？
谢谢您帮忙.
在Visual Studio Team Foundation Server 2013中,我正在使用单元测试框架.具体来说,我正在使用将从XML文件中读取的数据驱动测试.
这是一些示例代码:
using Microsoft.VisualStudio.TestTools.UnitTesting;
[TestClass]
public class DataDrivenTestingClass{
public TestContext TestContext{get; set;}
[TestMethod]
[DataSource("Microsoft.VisualStudio.TestTools.DataSource.XML", "test.xml", "XMLTests", DataAccessMethod.Sequential)]
public void MyOnlyDataDrivenTestFromXML(){
var testName = TestContext.DataRow[0].ToString();
//... blah blah blah other logic
//<snip>
Assert.IsTrue(true); //of course this is not what I really do
}
}
输出将如下所示:
测试通过 - MyOnlyDataDrivenTestFromXML(数据行0)
测试通过 - MyOnlyDataDrivenTestFromXML(数据行1)
测试通过 - ...
测试通过 - MyOnlyDataDrivenTestFromXML(数据行N)
显然,(Data Row i)不是很具描述性.XML存储了我想要使用的名称(我可以使用其他任何东西,但已经在xml中使用它似乎很方便).不过,我不确定这是可能的.
问题是,虽然您可以从TestContextvia 获取测试名称TestContext.TestName,但您无法设置它.此外,你不能(不应该)简单地继承TestContext并制作一个允许你这样做的人.
我也试图直接从设定的名字Properties的TestContext …
考虑以下:
using vector_type = std::vector<int>;
using const_iterator = typename vector_type::const_iterator;
using const_reverse_iterator = typename vector_type::const_reverse_iterator;
using iterator = typename vector_type::iterator;
using reverse_iterator = typename vector_type::reverse_iterator;
int main()
{
static_assert(!std::is_assignable_v<iterator, const_iterator>); // passes
static_assert(!std::is_assignable_v<reverse_iterator, const_reverse_iterator>); // fails
static_assert(std::is_assignable_v<reverse_iterator, const_reverse_iterator>); // passes
}
我可以检查分配iterator{} = const_iterator{}是无效的,但不能检查reverse_iterator{} = const_reverse_iterator{}具有此类型特征的分配.
此行为在gcc 9.0.0,clang 8.0.0和MSVC 19.00.23506中是一致的
这很不幸,因为实际情况是reverse_iterator{} = const_reverse_iterator{}实际上并没有使用任何上述编译器进行编译.
类型特征的这种行为意味着表达式
std::declval<reverse_iterator>() = std::declval<const_reverse_iterator>()
根据[meta.unary.prop]很好地形成,这看起来与我自己在is_assignable类型特征上的尝试一致.