小编bgo*_*dst的帖子

我最近发现需要std::string用自己的子串替换内容.在这里调用最合乎逻辑的函数我认为如下,来自http://www.cplusplus.com/reference/string/string/assign/:

substring(2)      string&assign(const string&str,size_t subpos,size_t sublen);
    
     复制从字符位置subpos开始的str部分并跨越sublen字符(或者直到str的结尾,如果str太短或者如果sublen是string :: npos).

     str
         另一个字符串对象,其值可以复制或移动.

     subpos
         作为子字符串复制到对象的str中第一个字符的位置.如果这大于str的长度,则抛出out_of_range.注意:str中的第一个字符用值0表示(不是1).

     sublen
         要复制的子字符串的长度(如果字符串较短,则复制尽可能多的字符).string :: npos的值表示直到str结尾的所有字符.

但是,我不确定这是否允许,或者它是否可以破坏字符串数据.我知道memcpy(),例如,不允许(或至少不能保证的情况下,非腐败)覆盖的内存区域用(的一部分)本身(见的memcpy()VS的memmove() ).但我不知道上述方法是否有相同的限制.

更一般地说,如果我能够自己找出这个问题的答案,请你评论一下吗？我没有什么链接到该文件中清楚地给我这个问题的答案是什么,除了可能的限定词"另一个"在的描述str参数(" 另一个字符串对象"),这似乎意味着它不能在此对象,虽然我不觉得这是毫不含糊的.这是文档中的弱点吗？

我试图在R中绘制一个表,列名相对于表的角度.我想添加行来分隔这些列名称,与文本的角度相同.但是,看起来text()函数中指定的角度与绘图的纵横比无关,而我在segments()函数中使用的角度取决于绘图的纵横比.

这是我的意思的一个例子:

nRows <- 5
nColumns <- 3
theta <- 30

rowLabels <- paste('row', 1:5, sep='')
colLabels <- paste('col', 1:3, sep='')

plot.new()
par(mar=c(1,8,5,1), xpd=NA)
plot.window(xlim = c(0, nColumns), ylim = c(0, nRows), asp = 1)
text(labels = rowLabels, x=0, y=seq(from=0.5, to=nRows, by=1), pos=2)
text(labels = colLabels, x = seq(from = 0.4, to = nColumns, by = 1), y = nRows + 0.1, pos = 4, srt = theta, cex = 1.1)
segments(x0 = c(0:nColumns), x1 = …

我的用例如下:我有一个程序强制在任何给定时间只能运行它的一个实例,所以在启动时它总是试图抓住标准位置的锁文件,并在文件终止时终止已被锁定.这一切都运行正常,但现在我想用一个新的命令行选项增强程序,当指定时,将导致程序打印出程序的状态报告然后终止(在主锁定保护之前)上面),其中包括锁文件是否已被锁定,正在运行的进程的pid是什么(如果存在),以及从数据库查询的某些程序状态.

正如您所看到的,当在"状态报告"模式下调用时,如果可用,我的程序实际上不应该获取锁.我只是想知道文件是否已经锁定,所以我可以通知用户状态报告的一部分.

从我的搜索来看,似乎没有办法做到这一点.相反,唯一可能的解决方案似乎是flock()使用非阻塞标志调用,然后,如果您实际获得了锁定,则可以立即释放它.像这样的东西:

if (flock(fileno(lockFile), LOCK_EX|LOCK_NB ) == -1) {
    if (errno == EWOULDBLOCK) {
        printf("lock file is locked\n");
    } else {
        // error
    } // end if
} else {
    flock(fileno(lockFile), LOCK_UN );
    printf("lock file is unlocked\n");
} // end if

我认为获取锁定并立即释放它并不是什么大问题,但我想知道是否有更好的解决方案,不涉及短暂和不必要的锁定获取？

注意:已经有几个类似的问题,其标题可能会使它看起来与这个问题完全相同,但从这些问题的内容可以清楚地看出,OP在获取锁定后有兴趣实际写入文件,所以这是一个截然不同的问题:

• 检查文件是否已使用flock()锁定？
• 如何检查文件是否被锁定？

昨天我给出了这个答案:将数据表匹配五列以更改另一列中的值.

在评论中,OP询问我们是否能够有效地实现两个表的左连接,从而获得将导致右表分配给左表的NA.在我看来,data.table并没有提供任何这样做的方法.

以下是我在该问题中使用的示例案例:

set.seed(1L);
dt1 <- data.table(id=1:12,expand.grid(V1=1:3,V2=1:4),blah1=rnorm(12L));
dt2 <- data.table(id=13:18,expand.grid(V1=1:2,V2=1:3),blah2=rnorm(6L));
dt1;
##     id V1 V2      blah1
##  1:  1  1  1 -0.6264538
##  2:  2  2  1  0.1836433
##  3:  3  3  1 -0.8356286
##  4:  4  1  2  1.5952808
##  5:  5  2  2  0.3295078
##  6:  6  3  2 -0.8204684
##  7:  7  1  3  0.4874291
##  8:  8  2  3  0.7383247
##  9:  9  3  3  0.5757814
## 10: 10  1  4 -0.3053884
## 11: …

在这里,我有一个功能,id="box"一旦页面加载就淡化一个方框.我尝试但未能找到如何再次淡入盒子或仅仅是如何淡入盒子或纯粹的JavaScript而不是jQuery的元素.这是我的fadeOut()功能代码:

var box = document.getElementById('box');

function fadeOut(elem, speed)
	{

	if(!elem.style.opacity)
	{
		elem.style.opacity = 1;
	}
	setInterval(function(){

 elem.style.opacity -= 0.02;
 
	}, speed /50);
}

fadeOut(box, 2000);

#box
{
  width: 100px;
  height: 100px;
  background-color: blue;
  }

<div id="box"></div>

非常感谢贡献者.干杯

我在R中寻找等效的python的'self'关键字或java的'this'关键字.在下面的例子中,我从一个不同的S4对象的方法制作一个S4对象,需要将指针传递给我自己.语言中是否有东西可以帮助我做到这一点？

MyPrinter <- setRefClass("MyPrinter",
  fields = list(obj= "MyObject"),
  methods = list(
    prettyPrint = function() {
      print(obj$age)
      # do more stuff
    }
  )
)

MyObject <- setRefClass("MyObject",
  fields = list(name = "character", age = "numeric"),
  methods = list(
    getPrinter = function() {
      MyPrinter$new(obj=WHAT_GOES_HERE) #<--- THIS LINE
    }
  )
)

我可以用一个独立的方法做到这一点,但我希望在R中做一个很好的面向对象的方法来做这个操作.谢谢

我是R的新手并试图用apply系列中的fuction替换一些for循环.我仍然完全不了解它们是如何工作的,但我设法生成了一段代码:

#create some input data
tech<-data.frame(cbind(c("p1","p2","p3","p4"),c(15,15,15,100),c(10,8,18,100)))
colnames(tech)=c("id","capacity.el","capacity.th")
tech$capacity.el<-as.numeric(tech$capacity.el)
tech$capacity.th<-as.numeric(tech$capacity.th)

heat<-data.frame(cbind(c(2,12,6,20,32,21,25,16,34,0),c(31,18,3,27,30,31,18,4,24,7),c(2,12,6,20,32,21,25,16,34,0),c(31,18,3,27,30,31,18,4,24,7)))
colnames(heat)=c("p1","p2","p3","p4")

> tech
  id capacity.el capacity.th
1 p1           2           1
2 p2           2           4
3 p3           2           3
4 p4           1           2


> heat
   p1 p2 p3 p4
1   2 31  2 31
2  12 18 12 18
3   6  3  6  3
4  20 27 20 27
5  32 30 32 30
6  21 31 21 31
7  25 18 25 18
8  16  4 16  4
9  34 …

假设我有一个简单的nullary模板函数模板化在一个参数上,有两个特化,一个用于unsigned long,一个用于size_t(内容不重要):

template<typename T> T f(void);
template<> unsigned long f<unsigned long>(void) { return 1; }
template<> size_t f<size_t>(void) { return 2; }

我的理解是该类型的确切定义size_t是依赖于平台的,因此它可能相同或不相同unsigned long.在我目前的平台上(Cygwin g ++ 5.2.0在Windows 10上进行64位编译-std=gnu++1y)这两种类型看起来是等价的,所以上面的代码无法编译:

../test.cpp:51:19: error: redefinition of ‘T f() [with T = long unsigned int]’
 template<> size_t f<size_t>(void) { return 2; }
                   ^
../test.cpp:50:26: note: ‘T f() [with T = long unsigned int]’ previously declared here
 template<> unsigned long f<unsigned long>(void) { return 1; } …

我char通过简单的添加找到a的最大值,并在数字变为负数时进行测试:

#include<stdio.h>

/*find max value of char by adding*/
int main(){
  char c = 1;

  while(c + 1 > 0)
    ++c;

  printf("Max c = %d\n",(int)c);  /*outputs Max c = -128*/
  return 0;
}

在while未来循环测试,所以第一次c+1是负的它打破了我们打印的价值c.但是,编程输出负数!

为什么这个程序不输出127？

我正在尝试编写一个小实用程序,将其参数列表中继到exec'd进程,除了在构建新进程的参数列表时重复一些传入的参数.

下面是我想要做的非常简化的版本,它简单地复制每个参数一次:

#include <stdlib.h>
#include <unistd.h>

#define PROG "ls"

int main(int argc, char* argv[] ) {

    int progArgCount = (argc-1)*2;
    char** execArgv = malloc(sizeof(char*)*(progArgCount+2)); // +2 for PROG and final 0
    execArgv[0] = PROG;
    for (int i = 0; i<progArgCount; ++i)
        execArgv[i+1] = argv[i/2+1];
    execArgv[progArgCount+1] = 0;

    execvp(PROG, execArgv );

} // end main()

注意元素execArgv是如何不唯一的.具体来说,每个重复中的两个元素是相同的,这意味着它们指向内存中的相同地址.

标准C是否说明了这种用法？是不正确的还是未定义的行为？如果不是,它是否仍然是不可取的,因为执行程序可能取决于其argv元素的唯一性？如果我错了,请纠正我,但是程序不能argv直接修改它们的元素,因为它们是非const的吗？难道这不会造成exec'd程序轻易修改argv[1](比如说)然后访问的风险argv[2],错误地假设这两个元素指向独立的字符串吗？几年前,当我开始学习C/C++时,我很确定自己这样做了,当时我并不认为这些argv元素可能不是唯一的.

我知道exec'ing涉及"替换过程图像",但我不确定这究竟是什么.我可以想象它可能涉及深度复制给定的argv参数(execArgv在上面的例子中)到新的内存分配,这可能会使事情无法解释,但我不太了解exec函数的内部说法.这将是浪费,至少如果原始数据结构可以在"替换"操作中保留,那么这是我怀疑它发生的原因.也许不同的平台/实现在这方面表现不同？请问回答者请谈谈这个吗？

我试图找到关于这个问题的文档,但我只能从http://pubs.opengroup.org/onlinepubs/9699919799/functions/exec.html找到以下内容:

程序使用其中一个exec函数指定的参数应传递给相应的main()参数中的新过程映像.

上述内容并未阐明它是否是对新进程传递的参数的单一深度复制. …