我最近阅读了一篇文章,其中指出使用比使用\n更好,std::endl因为它endl也会刷新流.
但当我找到关于该主题的更多信息时,我发现了一个网站,其中说明:
如果您处于必须避免缓冲的情况,可以使用std :: endl而不是'\n'
现在我的问题出现了:在哪种情况下最好不要写入缓冲区？因为我只看到了那种技术的优点.写入缓冲区不是更安全吗？因为它比硬盘驱动器小,所以它会比存储在HD上的数据更快地被覆盖(我不确定这是否属实).
我有一个外部库,我无法修改.该库声明了一个模板函数,该函数由于某种原因返回const非引用对象:
template<class C>
const C foo();
我有另一个外部库,我无法修改.该库声明了一个不可复制的类,并且只有非const对象的移动构造函数:
struct bar {
bar();
bar(const bar&)=delete;
bar(bar&&);
};
现在我需要使用foo<bar>.一个简单的用法:
bar buz() {
return foo<bar>();
}
失败了
Run Code Online (Sandbox Code Playgroud)main.cpp: In function 'bar buz()': main.cpp:13:21: error: use of deleted function 'bar::bar(const bar&)' return foo<bar>(); ^ main.cpp:8:5: note: declared here bar(const bar&)=delete; ^~~
这是有道理的,并没有简单的解决方法使代码编译.
但是,如果我添加一些更复杂的解决方法:
bar buz() {
return const_cast<bar&&>(std::move(foo<bar>()));
}
它编译并且整个代码按预期工作(不仅是上面的简化示例,而且我的真实代码也是如此).
但是,它是安全的,还是我遇到了一些未定义的行为？有没有更好的解决方法？
我已阅读并理解有关返回的问题const从功能(1,2),以及常见的答案似乎是返回const对象在现代C++气馁,但我的问题是不是这件事,但我如何能解决该情况当外部库返回const对象时.
我想编写一个函数,它在两个参数a和b不同类型之间执行除法,a/b如果定义了除法运算符,则使用表达式,或者a * (1/b)如果没有这样的运算符则返回.
这是我的想法,但我不知道如何定义两个*和/运算符时禁用第二个定义(或优先第一个定义):
template<typename T, typename U>
auto smart_division(T a, U b) -> decltype (a/b) {
return a/b;
}
template<typename T, typename U>
auto smart_division(T a, U b) -> decltype (a * (U(1)/b)) {
return a * (U(1)/b);
}
假设我有一个声明函数返回const类型的库:
class Foo { ... };
const Foo makeFoo();
现在我想const从makeFoo()返回类型中删除(请参阅我之前的问题).我可以const从头文件和cpp文件中删除它们,重建库,并将我的代码链接到新库.但是,我还有动态链接到此库的旧代码,我希望它继续使用新版本的库.
那么,第一个问题,是否const从返回类型中删除了ABI？
第二个问题,实际代码是完全不同的:它是一个具有静态成员函数的模板类,稍后将显式实例化:
// fooMaker.h
template<class Foo>
class FooMaker {
public:
static const Foo make();
};
// fooMaker.cpp
template<class Foo>
const Foo FooMaker<Foo>::make() { ... }
template class FooMaker<Foo1>;
template class FooMaker<Foo2>;
它改变了什么吗？
如果这很重要,我在linux下使用g ++.
我试图理解使用system("some command")在c ++中进行的系统调用.这是代码
#include <iostream>
#include <cstdlib>
using namespace std;
int main()
{
cout << "Hello ";
system("./pause");
cout << "World";
cout << endl;
return 0;
}
可执行文件"pause"是从以下代码创建的
#include <iostream>
using namespace std;
int main()
{
cout<<"enter any key to continue\n";
cin.get();
return 0;
}
我得到以下输出
enter any key to continue
1
Hello World
有人可以向我解释输出吗？我在期待这个 -
Hello
enter any key to continue
1
World
请考虑以下代码:
struct A {
constexpr operator int() { return 42; }
};
template <int>
void foo() {}
void bar(A a) {
foo<a>();
}
int main() {
foo<A{}>();
const int i = 42;
foo<i>(); // (1)
A a{};
static_assert(i == a, "");
bar(a);
foo<a>(); // error here
}
带有c ++ 14的Clang 3.7接受此,而带有c ++ 14的gcc 5.2.0则不接受,产生以下消息:
Run Code Online (Sandbox Code Playgroud)/tmp/gcc-explorer-compiler1151027-68-1f801jf/example.cpp: In function 'int main()': 26 : error: the value of 'a' is not usable in a constant expression foo<a>(); ^ 23 : note: 'a' was …
Python click 允许将一些命令行选项指定为“功能开关”。来自官方文档的示例：
@click.command()
@click.option('--upper', 'transformation', flag_value='upper',
default=True)
@click.option('--lower', 'transformation', flag_value='lower')
def info(transformation):
click.echo(getattr(sys.platform, transformation)())
顾名思义，它用于某些功能有多个选项的情况，并且只能选择一个。上面的代码允许将脚本运行为
$ test.py --upper
LINUX2
$ test.py --lower
linux2
$ test.py
LINUX2
但是，同一个脚本允许用户在命令行上指定这两个选项。Click 将静默使用指定的最后一个选项：
$ test.py --upper --lower
linux2
有没有办法强制单击以检查命令行上传递的此类选项不超过一个？
[expr.const]/4 表示：
T 类型的转换常量表达式是隐式转换为 T 类型的表达式，其中转换后的表达式是常量表达式，并且隐式转换序列仅包含
- ...（清单略）
以及引用绑定（如果有）直接绑定的位置。
（强调我的。）
这里有两点我不太明白。
首先，“转换后的表达式”（强调）指的是哪个表达式？
例如考虑
class A; // assume it can be implicitly converted to `int`
A foo(); // or maybe constexpr
template<int n> void bar();
现在，如果我写
bar<foo()>();
那么哪个表达式应该是常量表达式呢？整个foo()表达式应该是恒定的，还是只是类似的东西static_cast<int>(foo())？
据我从最近的问题中了解到，只有后者需要保持不变。这是真的？
第二，“引用绑定”指的是整个过程的哪个阶段？它是否仅指模板参数本身是引用（template<int& x>...）的情况？或者是否要求在类型转换或转换表达式求值期间发生的任何引用绑定都应该是直接的？或者它是否指的是尚未转换的表达式本身就是引用的情况（A& a=...; bar<a>();）？
我有一个包含数字 0 和 1 的邻接矩阵。如果从一个节点到另一个节点没有边，则该字段为 0，否则该字段将标记为 1。
那么，如果邻接矩阵中的某个域为0，则节点之间没有边，否则存在权值为1的边。
现在，我已经应用 Floyd 算法来找出从任何节点到其他节点的最短路径。但我没有得到正确的解决方案。
这是我的 Floyd 算法实现。
void Floyd_Warshal(int graph[Nodes][Nodes], int D[Nodes][Nodes])
{
for (int i = 0; i < Nodes; i++)
{
for (int j = 0; j < Nodes; j++)
{
if (graph[i][j] == 0) { graph[i][j] = INT_MAX; }
D[i][j] = graph[i][j];
}
}
for (int k = 0; k < Nodes; k++) {
for (int i = 0; i < Nodes; i++)
{
for (int j = 0; j …在我工作的项目中,我在代码审查过程中看到了如下代码:
class A
{
shared_ptr<B> instanceB;
}
A::A ()
{
instanceB = make_shared<B>();
static C localVariable(instanceB.get());
}
我知道静态变量就像全局变量一样,将在程序启动时创建,并且在实例化时将创建instanceB.这可能会崩溃.
在解释我开始考虑instanceB.get()将返回什么值时.最可能垃圾对吗？当我更多地考虑它时,我相信这个代码甚至不应该被编译为什么允许静态变量在其ctors中采用非静态参数？
看看以下四个程序.在Windows下使用Freepascal构建它们并运行,将输出重定向到任何文件,并注意它将花费的时间.
我的结果是:所有程序运行的时间大约相同(大约6秒),尽管第四个程序输出的字节数是100倍.这意味着第四个程序的每个输出字节的运行速度比其他字节的运行速度快得多.
对于第二个节目,缓慢的原因很明显:flush电话.对于第三个程序,原因并不那么明显,但假设每次调用writelnstdout都隐式刷新输出缓冲区可能是合理的.
但是,目前尚不清楚为什么第一个程序比第四个程序慢得多.然而,添加flush(output);(参见程序2)并不会改变时序的事实似乎意味着FPC甚至在每次刷新后都会刷新输出缓冲区write,这可以解释所有行为.仅当输出为stdout,甚至重定向时才会发生这种情况; 如果我使用assign/rewrite显式输出到特定文件,那么没有flush的程序运行速度比具有flush的程序要快得多 - 正如应该的那样.
在Linux下,运行时间为0.01秒,0.65秒,0.01秒,0.30秒(输出大100倍).这里显然flush()减慢程序,所以在Linux下FPC似乎不会每次刷新stdout.
我试图谷歌是否FPC真的刷新stdout缓冲区在每个输出(是它write或writeln),但没有找到任何信息,除了示例程序中的注释来自http://www.freepascal.org/docs-html的 flush函数文档/rtl/system/flush.html,评论提到a writeln到'output'总是会导致刷新[而不是write].但是,这个例子既没有在Windows下产生预期的输出,也没有在Linux下产生.实际上,输出似乎在Windows下的每次写入和写入之后刷新,重定向或不重定向,并且在输出未重定向时也在Linux下刷新.在具有重定向输出的Linux下,似乎根本没有隐式刷新.
所以,我的问题是:
write或者writeln在Windows上是否将输出重定向到文件？我的系统是在Kubuntu 14.04下的VirtualBox下使用FPC 2.6.4的Windows XP,以及使用FPC 2.6.2的Kubuntu 14.04本身.我没有机会尝试在真正的Windows机器上运行它,但我有理由相信那里的情况是一样的.
节目:
var i,j:integer;
s:string;
begin
for j:=1 to 1000 do begin
for i:=1 to 10 do
write('!');
end;
end.
var i,j:integer;
s:string;
begin
for j:=1 to 1000 do begin
for i:=1 to 10 do begin
write('!');
flush(output); …我使用以下简单代码遇到段错误：
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include <iostream>
#include <thread>
#include <unistd.h>
void run() {
sleep(1); // see below
cv::Mat source(10, 10, CV_32FC1, -1);
cv::Mat result(10, 10, CV_32FC1);
cv::Mat trX(result.rows, result.cols, CV_32FC1, 5);
cv::Mat trY(result.rows, result.cols, CV_32FC1, 5);
cv::remap(source, result, trX, trY, cv::INTER_LINEAR, cv::BORDER_TRANSPARENT);
std::cout << "done" << std::endl;
}
int main(int argc, char* argv[]) {
std::thread t1(run);
t1.join();
std::thread t2(run);
t2.join();
return 0;
}
如果我run()直接从 调用两次main()，而根本不使用线程，则效果很好。如果我交换t1.join();and std::thread t2(run);（也就是说，在第一个线程完成之前启动第二个线程；这就是sleep变得重要的地方），它也会运行良好。
此外，如果我main改为 …
宣言:
class base{
public:
base(){a=0;}
base(int a);
int getA();
virtual ~base() ;
protected:
int a ;
};
//
class derived : public base {
public:
derived(){}
derived(int a, int b) ;
int getC() ;
~derived();
private:
int c ;
};
定义:
base::base(int a){
cout << " in base constructor a = " << a << endl ;
a = a ;
}
base::~base(){
a = 0 ;
}
int base::getA(){
return a ;
}
//
derived::derived(int a, int b)
:base(a) …