该文件std::hypot说:
计算x和y的平方和的平方根,在计算的中间阶段没有过度溢出或下溢.
我很难设想一个std::hypot应该用于琐碎的测试用例sqrt(x*x + y*y).
以下测试表明,这std::hypot比天真计算慢大约20倍.
#include <iostream>
#include <chrono>
#include <random>
#include <algorithm>
int main(int, char**) {
std::mt19937_64 mt;
const auto samples = 10000000;
std::vector<double> values(2 * samples);
std::uniform_real_distribution<double> urd(-100.0, 100.0);
std::generate_n(values.begin(), 2 * samples, [&]() {return urd(mt); });
std::cout.precision(15);
{
double sum = 0;
auto s = std::chrono::steady_clock::now();
for (auto i = 0; i < 2 * samples; i += 2) {
sum += std::hypot(values[i], values[i + 1]);
} …通过使用Copy&Swap习语,我们可以轻松实现具有强大异常安全性的副本分配:
T& operator = (T other){
using std::swap;
swap(*this, other);
return *this;
}
但是这需要T是可交换的.如果std::is_move_constructible_v<T> && std::is_move_assignable_v<T> == true感谢,自动哪种类型std::swap.
我的问题是,使用"复制和移动"成语有没有任何缺点？像这样:
T& operator = (T other){
*this = std::move(other);
return *this;
}
只要你实现了move-assignment,T因为很明显你最终会得到无限递归.
这个问题不同于复制和交换成语是否应该成为C++ 11中的复制和移动成语？因为这个问题更通用,并且使用移动赋值运算符而不是手动移动成员.这避免了在链接线程中预测答案的清理问题.
在使用打包任务时,我遇到了一些非常奇怪的事情.当读取~packched_task时,我得到的印象是,如果a std::packaged_task在执行之前被销毁,那么承诺将被破坏并且尝试从未来获得结果应该抛出std::future_error.
但是,在Visual Studio 2013上,情况似乎并非如此.请使用以下代码:
#include <iostream>
#include <future>
#include <functional>
int main() {
std::future<int> f;
{
std::packaged_task<int()> task([](){return 3; });
f = task.get_future();
}
std::cout<<f.get()<<std::endl;
return 0;
}
我期待得到一个std::future_error开启,f.get()但它阻止,等待打包的任务被执行.
尝试另一个编译器:http://ideone.com/Wt0WOc确实扔了std::future_error("Broken promise")...
我是否在Visual Studio 2013中看到了一个错误或者我错过了什么？
我有一个Java应用程序,Preferences通过使用:
Preferences prefs = Preferences.userNodeForPackage(MyClass.class);
prefs.get((String)key, "");
在新的Windows 8计算机上,这失败了:
WARNING: Could not open/create prefs root node Software\JavaSoft\Prefs
at root 0x80000002. Windows RegCreateKeyEx(...) returned error code 5.
错误代码5被拒绝访问.
我找不到任何我做错的事.谷歌和搜索引擎搜索只给出了与Windows Vista/7相关的旧结果,其中一个错误地使用了systemRoot(如何使用Java编写系统首选项？我可以调用UAC吗？).
可以通过创建HKLM/Software/JavaSoft/Prefs以及设置HKLM/Software/JavaSoft的权限来"修复"错误,如此处所述Java:java.util.Preferences失败.但这不是我可以要求用户在安装程序时执行的操作.
所以我正在寻找更好的解决方案.我最后的努力是简单地写入文件,但我想避免这样做.这似乎也是相关的我正在尝试使用来自XML的Java Prefences而不使用Windows注册表,但我看到一个与注册表相关的消息,但它被拒绝投票而没有答案.
目前我怀疑Win8 JVM错误......
在这里击败死马.在C中执行整数幂的典型(和快速)方法是经典的:
int64_t ipow(int64_t base, int exp){
int64_t result = 1;
while(exp){
if(exp & 1)
result *= base;
exp >>= 1;
base *= base;
}
return result;
}
但是我需要一个编译时整数幂,所以我继续使用constexpr进行递归实现:
constexpr int64_t ipow_(int base, int exp){
return exp > 1 ? ipow_(base, (exp>>1) + (exp&1)) * ipow_(base, exp>>1) : base;
}
constexpr int64_t ipow(int base, int exp){
return exp < 1 ? 1 : ipow_(base, exp);
}
第二个函数只是以可预测的方式处理小于1的指数.exp<0在这种情况下,传递是一个错误.
我在[0,15]范围内生成10E6随机值基数和指数的向量,并在向量上计算两个算法的时间(在进行非定时运行以尝试去除任何缓存效果之后).没有优化,recursice方法的速度是循环的两倍.但是使用-O3(GCC)时,循环比recursice方法快4倍.
我向你们提出的问题是:任何人都可以提出一个更快的ipow()函数来处理指数和0的基数并且可以用作constexpr？
(免责声明:我不需要更快的ipow,我只是想看看这里的聪明人能想出什么).
我有一个问题,如果清除编辑器文本并提交然后单击增量或减量按钮,可编辑的JavaFX 8 Spinner会导致未被捕获NullPointerException.这是j8u60 j8u77.幸运的是,递增/递减按钮将陷入压低状态,NPE会继续锁定应用程序.
以下代码为我重现了这个问题:
import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Spinner;
import javafx.scene.control.SpinnerValueFactory;
import javafx.scene.control.SpinnerValueFactory.IntegerSpinnerValueFactory;
import javafx.stage.Stage;
public class Test extends Application {
public static void main(String[] args) {
launch(args);
}
@Override
public void start(Stage aPrimaryStage) throws Exception {
IntegerSpinnerValueFactory valueFactory = new IntegerSpinnerValueFactory(0, 10);
Spinner<Integer> spinner = new Spinner<>(valueFactory);
spinner.setEditable(true);
aPrimaryStage.setScene(new Scene(spinner));
aPrimaryStage.show();
}
}
运行它,清除文本,按回车键(NullPointerException),单击增量或减量按钮现在也会导致NPE.
任何人都可以确认这是一个JavaFX错误并建议一个解决方法吗？
编辑:异常堆栈跟踪
Exception in thread "JavaFX Application Thread" java.lang.NullPointerException
at javafx.scene.control.SpinnerValueFactory$IntegerSpinnerValueFactory.lambda$new$215(SpinnerValueFactory.java:475)
at com.sun.javafx.binding.ExpressionHelper$Generic.fireValueChangedEvent(ExpressionHelper.java:361)
at com.sun.javafx.binding.ExpressionHelper.fireValueChangedEvent(ExpressionHelper.java:81)
at javafx.beans.property.ObjectPropertyBase.fireValueChangedEvent(ObjectPropertyBase.java:105) …对于我的生活,我无法让这个简单的奥术模板魔法工作:
template<typename T, int a, int b>
int f(T v){
return v*a-b; // just do something for example
}
template<typename T, int a, int b, template<typename,int,int> class func>
class C{
int f(){
return func<T,a,b>(3);
}
};
int main(){
C<float,3,2, f> c;
}
这可能不涉及仿函数吗？
我发现std::mutexVisual Studio 2013 中的实现太慢了.它使用重量级互斥锁,以确保即使在完全正常和花花公子的过程之间也可以实现同步; 除非你没有与其他进程交谈,并且可以真正使用CRITICAL_SECTION它在Win32上的自旋锁定优惠的额外速度.
我试图实现一个fast_recursive_mutex符合C++ 11互斥概念的东西,并且根据规范履行所有义务.从各方面来说,std::mutex只要您没有在进程之间进行同步,它就是替代品.
它与std::lock_guard和std::unique_lock.但是我在尝试使用它时会遇到问题,std::condition_variable因为由于硬编码的使用std::condition_variable::wait(std::unique_lock<std::mutex>&)而不承认我.fast_recursive_mutexstd::mutex
所以我的问题是:
wait()承认另一种互斥类型std::mutex呢？我有一个公开可用的 Java 8 桌面应用程序，其中包含 MSI 安装程序，我想将其更新到 Java 17。
目前的用户体验是这样的：
application.exe这是一个基本上运行的垫片java jar application.jar。我很难理解的是用户应该在 Java 9+ 世界中安装什么。例如，如果我将用户发送到： https: //www.oracle.com/java/technologies/downloads/，他们会收到下载 Java 开发工具包的欢迎，这对用户来说安装起来是一件令人困惑的事情（“这是对的吗？我不想开发东西？？”）。
此外，当你登陆http://java.com时，它会说“如果你被要求下载 java，很可能就是这个”，这意味着如果你发布应用程序，你应该使用 Java 8（并且忘记 JavaFX 灾难）是 OpenJDK 11 之前的版本，并且只需使用 Orcale Java）...
我的印象是，在 Java 9 之后，Jigsaw 的承诺是构建一个包含本机运行时和 jar 的包，所有这些都整齐地捆绑在一起，以便最终用户必须安装 JVM 的日子结束了。然而在网上搜索，我发现 Gradle 或 IntelliJ（或 Eclipse）不支持这一点，所以这看起来有点像一个死的白日梦？
如果我想发布 Java 17 应用程序，用户是否需要安装 JDK？如果没有，我该如何打包和运送我的申请？
我有一个严格对齐要求的类型(由于使用了AVX操作),它大于平台默认对齐.
为了使这个类的使用更简单,我想专门std::make_shared总是为这种类型使用合适的分配器.
像这样的东西:
namespace std{
template<class... Args> inline
auto make_shared<X, Args...>(Args&&... args){
return std::allocate_shared(allocator_type<X, 32>, std::forward<Args>(args)...);
}
}
我的问题是,标准是否允许这样做？它会按预期工作吗？
考虑用GCC 4.7.2编译的这个简短程序 g++ -std=c++11 test.cc
#include <memory>
#include <queue>
struct type{
type(int a) : v(a) {}
int v;
};
typedef std::shared_ptr<type> type_ptr;
int main(){
int value = 3;
std::queue<type_ptr> queue;
auto ptr{std::make_shared<type>(value)};
queue.push(ptr);
}
编译器输出以下错误:
src/test.cc: In function ‘int main()’:
src/test.cc:15:17: error: no matching function for call to ‘std::queue<std::shared_ptr<type> >::push(std::initializer_list<std::shared_ptr<type> >&)’
src/test.cc:15:17: note: candidates are:
In file included from /usr/include/c++/4.7/queue:65:0,
from src/test.cc:2:
/usr/include/c++/4.7/bits/stl_queue.h:211:7: note: void std::queue<_Tp, _Sequence>::push(const value_type&) [with _Tp = std::shared_ptr<type>; _Sequence = std::deque<std::shared_ptr<type>, std::allocator<std::shared_ptr<type> > >; std::queue<_Tp, _Sequence>::value_type …我是Dagger 2的新手，我正在寻找一种具有“可配置组件”的方法。
本质上，这就是我想要实现的目标：
public interface ErrorReporter{
...
}
public class ConsoleErrorReporter implements ErrorReporter{
... // Print to System.err
}
public class DialogErrorReporter implements ErrorReporter{
... // Show modal dialog to user
}
@Module
public interface UIModule{
@Provides
ErrorReporter provideErrorReporter();
}
@Module
public class ConsoleUIModule{
@Override
@Provides
ErrorReporter provideErrorReporter(ConsoleErrorReporter cer){
return cer;
}
}
@Module
public class GraphicalUIModule{
@Override
@Provides
ErrorReporter provideErrorReporter(DialogErrorReporter der){
return der;
}
}
@Component(modules = {UIModule.class, OtherUniversalModule.class})
public interface ApplicationComponent{
ErrorReporter errorReporter();
}
void main(String[] args){
final …我有一个方程组，其形式为：
eq1 : q = a*x+b*y;
eq2 : r = c*x+d*y;
我希望它获得系数矩阵，在这个简单的情况下是：
T : matrix([a,b], [c,d]);
这样我就可以将方程组表示为：
eq3 : Q = T . X;
T因为我想在进一步的矩阵运算中使用。（原始方程是我从问题中得到的，我不想手动将它们转换成矩阵形式，因为这就是这种程序的用途。但我就是无法弄清楚）