我正在研究一个相当不确定的问题,即当你想要进行无限循环时,是否最好使用(;;)或while(1),我在C中看到了一个有趣的解决方案,你可以将#define"永远"作为常量等于 ";;" 字面上循环for(EVER).
我知道定义一个额外的常量可能不是最好的编程实践,但纯粹出于教育目的,我想看看是否可以用Perl完成.
我试图使Perl等效,但它只循环一次然后退出循环.
#!/usr/bin/perl -w
use strict;
use constant EVER => ';;';
for (EVER) {
print "FOREVER!\n";
}
输出:
FOREVER!
为什么这不适用于perl？
我正在查看一些使用File :: Path制作和删除文件路径的示例代码.
http://perldoc.perl.org/File/Path.html
我可以让函数正常工作但我在使错误消息正常工作时遇到了一些困难.在捕获错误消息的示例中,他们使用\之前的my.这是什么目的\？
# Sample code from the link above
remove_tree( 'foo/bar', 'bar/rat', {error => \my $err} ); # why escape the my?!?!
if (@$err) {
for my $diag (@$err) {
my ($file, $message) = %$diag;
if ($file eq '') {
print "general error: $message\n";
}
else {
print "problem unlinking $file: $message\n";
}
}
}
else {
print "No error encountered\n";
}
我以前从未见过这个,我无法在任何地方找到解释.我尝试删除了\,我得到一个语法错误,所以很明显它是必要的,但为什么？
我正在使用Thread::Queue将数组推送到队列并使用线程处理它的每个元素.下面是我的程序的简化版本,用于演示正在发生的事情.
#!/usr/bin/perl
use strict;
use warnings;
use threads;
use threads::shared;
use Thread::Queue;
# Define queue
my $QUEUE :shared = new Thread::Queue();
# Define values
my @values = qw(string1 string2 string3);
# Enqueue values
$QUEUE->enqueue(@values);
# Get thread limit
my $QUEUE_SIZE = $QUEUE->pending();
my $thread_limit = $QUEUE_SIZE;
# Create threads
for my $i (1 .. $thread_limit) {
my $thread = threads->create(\&work);
}
# Join threads
my $i = 0;
for my $thread (threads->list()) {
$thread->join();
}
print "COMPLETE\n";
# …如何隐藏用户的"绑定"调用,以便调用访问者将隐式为他们执行此操作？
我想这样做,因为我有一个可以由用户访问的数据结构,但是可以在用户不知情的情况下修改存储在该结构中的值.
如果数据结构中的属性发生更改,我希望修改引用该属性的任何变量,以便用户始终使用新数据.由于用户总是想要新鲜数据,如果用户甚至不需要知道它正在发生,那么它更简单,更直观.
这是我到目前为止...它似乎没有工作,但输出是:
hello
hello
我想要的是:
hello
goodbye
码:
#!/usr/bin/perl
use warnings;
use strict;
use feature qw{ say };
{
package File;
use Moose;
has '_text' => (is => 'rw', isa => 'Str', required => 1);
sub text {
my ($self) = @_;
tie my $text, 'FileText', $self;
return $text;
}
}
{
package FileText;
use Tie::Scalar;
sub TIESCALAR {
my ($class, $obj) = @_;
return bless \$obj, $class;
}
sub FETCH {
my ($self) = @_;
return $$self->_text(); …我的问题是关于Perl如何在内部管理对象的数据.
在Perl中创建对象时,新子例程通常会返回对受祝福对象的引用.
以下面的代码为例:
# Create a new object
my $object = Object->new(%data1);
# Create a new object with the same variable
$object = Object->new(%data2);
从第一次打电话到new我们创建一个$object引用一些祝福的人%data1
视觉表现:
"\"表示引用.
$object ????> \{bless %data1}
这在内存中看起来如下:
"&"表示地址
MEMORY:
----------------------------------
&{bless %data1} ????> bless %data1
然后用第二次调用new的值$object改为引用其他一些祝福%data2
视觉表现:
$object ??/ /??> \{bless %data1} # The connection to %data1 is broken
?
????????????> \{bless %data2}
现在内存看起来像这样:
MEMORY:
----------------------------------
&{bless %data1} ????> bless %data1
&{bless %data2} ????> bless …我正在编写一个简单的Hello World Python脚本,尝试了几个不同的东西来看看我会得到什么.
结果:
print "Hello World" ===> Hello World
print "Hello"," ","World ===> Hello World
print "Hello" "World" ===> HelloWorld
结果让我感到惊讶......从其他语言的经验来看,我希望得到更像这样的东西:
print "Hello World" ===> Hello World
print "Hello"," ","World ===> Hello World
print "Hello" "World" ===> Syntax Error!
在尝试了几个例子之后,我意识到每当你用","分隔字符串时,似乎都会添加一个空格.
......更奇怪的是,如果你给它多个字符串而没有","它就像第三个例子那样分开它们似乎并不在乎.
为什么Python的打印功能会这样？
还有办法阻止它为","分隔字符串添加空格吗？
textvariable在 tkinter 中创建组合框时使用该属性似乎完全没用。有人可以解释一下目的是什么吗？我查看了 Tcl 文档，它说textvariable用于设置默认值，但看起来在 tkinter 中您只需使用该.set方法即可。
示例显示我的意思：
这不起作用...
from Tkinter import *
import ttk
master = Tk()
test = StringVar()
country = ttk.Combobox(master, textvariable=test)
country['values'] = ('USA', 'Canada', 'Australia')
country.pack()
# This does not set a default value...
test="hello"
mainloop()
这确实有效。
from Tkinter import *
import ttk
master = Tk()
country = ttk.Combobox(master)
country['values'] = ('USA', 'Canada', 'Australia')
country.pack()
# This does set a default value.
country.set("hello")
mainloop()
如果您应该只使用.set和.get方法，那么将任何内容分配给 有什么意义 …
我注意到一些Perl模块使用基于类的结构,但不管理任何数据.该类仅用于访问其中的方法,仅此而已.
请考虑以下示例:
Class.pm
package Class;
use Moose;
sub do_something {
print "Hi!\n";
}
1;
test.pl
use Class;
# Instantiate an object from the class
my $obj = Class->new();
$obj->do_something();
在此示例中,您可以看到首先实例化该类的实例,然后从创建的对象中调用该方法.
可以像这样实现相同的最终结果:
Module.pm
package Module;
use strict;
use warnings;
sub do_something {
print "Hi!\n";
}
1;
test.pl
use Module;
Module::do_something();
我想知道为什么人们使用第一种方法编写模块,并且如果它提供了一些好处.对我来说,似乎它增加了一个额外的步骤,因为为了使用这些方法,首先需要实例化该类的对象.
我不明白为什么人们会像这样编程,除非它有一些我没有看到的好处.
我有一种情况，我需要重载解析来更喜欢带有隐式转换的重载而不是同名的模板函数。
考虑以下示例：
#include <iostream>
#include <functional>
void call_function(const std::function<void()>& function)
{
std::cout << "CALL FUNCTION 1" << std::endl;
function();
}
template <typename Function>
void call_function(const Function& function)
{
std::cout << "CALL FUNCTION 2" << std::endl;
function();
}
int main()
{
// Pass a lambda to "call_function"
// This lambda is implicitly convertible to 'std::function<void()>'
// Even though it is implicitly convertible, the template function is selected by the compiler.
call_function([]{
std::cout << "TEST" << std::endl;
});
}
输出：
CALL FUNCTION …我试图boost::any通过网络 API 传递包含数据成员的对象，以在两个应用程序之间交换数据。我知道 APImemcpy在内部使用来复制数据，但我不确定我想要做的是否是调用未定义的行为。
我写了一个简单的例子来演示memcpy这种方式的使用：
#include <boost/any.hpp>
#include <cstring>
#include <string>
#include <iostream>
class Data
{
public:
template <typename T>
Data(T value)
: m_value(value)
{}
template <typename T>
T Read() const
{
return boost::any_cast<T>(m_value);
}
private:
boost::any m_value;
};
int main()
{
Data src(std::string("This is some data."));
std::cout << "Size: " << sizeof(src) << std::endl;
std::cout << "SRC: " << src.Read<std::string>() << std::endl;
void* dst = malloc(sizeof(src));
std::memcpy(dst, &src, sizeof(src));
const auto data = …