小编son*_*yao的帖子

我正在使用Visual Studio 2015.

知道为什么这个代码编译:

#include <memory>

class Foo;
class Bar;
typedef std::pair<Foo*,std::weak_ptr<Bar>> Object;
typedef std::vector<Object> ObjectVect;

bool operator==( std::weak_ptr<Bar> left,
                 std::weak_ptr<Bar> right )
{
    return left.lock() == right.lock();
}

int main( int argc, char* argv[] )
{
    ObjectVect vect;
    Object obj;
    auto foundIter = std::find( vect.begin(), vect.end(), obj );
    return 0;
}

虽然这个给了我错误:

#include <memory>

class Foo;
namespace MyNamespace
{
    class Bar;
}
typedef std::pair<Foo*,std::weak_ptr<MyNamespace::Bar>> Object;
typedef std::vector<Object> ObjectVect;

bool operator==( std::weak_ptr<MyNamespace::Bar> left,
                 std::weak_ptr<MyNamespace::Bar> right )
{
    return left.lock() == …

背景

我正在使用Spring Batch 2.1.8,并运行作业CommandLineJobRunner.如:

java org.springframework.batch.core.launch.support.CommandLineJobRunner classpath:launchContext.xml theJobId

问题

在某些情况下,例如服务器崩溃,可能会中断正在运行的作业.但中断的作业STARTED在Spring Batch Meta-Data表中保留了状态,无法再次运行.

org.springframework.batch.core.repository.JobExecutionAlreadyRunningException: A job execution for this job is already running

我可以想到两个解决方案:

解决方法1

添加一个新的作业参数并每次更改它以使其成为Spring Batch的"新"作业.如:

java org.springframework.batch.core.launch.support.CommandLineJobRunner classpath:launchContext.xml theJobId times=0

当需要重新运行它时,请清除所有相应的输出数据,计数times一次,然后重新运行作业.

溶液2

手动更改Spring Batch元数据表.

更新状态以使作业可重新启动.如:

UPDATE BATCH_JOB_EXECUTION SET END_TIME = SYSTIMESTAMP, STATUS = 'FAILED', EXIT_CODE = 'FAILOVER' WHERE JOB_EXECUTION_ID =
    (SELECT MAX(JOB_EXECUTION_ID) FROM BATCH_JOB_EXECUTION WHERE JOB_INSTANCE_ID =
        (SELECT MAX(JOB_INSTANCE_ID) FROM BATCH_JOB_INSTANCE WHERE JOB_NAME = 'XXX'));

我试过了,看起来效果很好.

题

Solution2是个坏主意吗？有陷阱吗？

提前致谢.并且赞赏任何其他解决方案.

我理解将成员函数的地址传递给它的类之外的基本问题.我觉得mem_fn()可能是解决方案,但我遇到了具体问题.

我在类p中有一个当前声明为的成员函数

typedef void (*valNamedFlagsCallback)(const int, const bool);
bool valNamedFlags(const OptBlk *operand, const char *description_of_value_or_NULL, const int subscripts[], const char *names[], valNamedFlagsCallback callBack);

在课堂上我试图用valNamedFlags调用

pInstance->valNamedFlags(operand, "Statement types", statementsSubscripts, statementsNames, std::mem_fn(&e::setStatement));

(我从没有mem_fn()开始,但当然有经典的"指向成员函数的指针"问题.我已经尝试了两个&e :: setStatement和plain&setStatement.)

FWIW,setStatement原型为

  void setStatement(const int ifcid, const bool isAffirmative);

如果我删除mem_fn()并将setStatement声明为static,则一切正常.我只是指出这是一种说法,我已经消除了所有其他可能的问题; 我唯一的问题是"成员函数指针"问题.不幸的是,setStatement()需要是一个成员函数,而不是静态函数.

我在MS VS 2010中遇到的具体错误是

bool p :: valNamedFlags(const OptBlk*,const char*,const int [],const char*[],p :: valNamedFlagsCallback)':无法从'std :: tr1 :: _ Mem_fn3 <_Rx,_Pmf转换参数5, _Arg0,_Arg1,_Arg2>'到'p :: valNamedFlagsCallback'

我想保持回调声明独立于e类; 也就是说,我不想去

typedef void (*e::valNamedFlagsCallback)(const int, const bool);

因为我想保持比这更普遍.

mem_fn()是正确的解决方案还是我离开基地？如果是这样,我应该如何在valNamedFlags()原型中声明回调？

或者我应该采用不同的方法？

我正在尝试创建一个可以读取和编译opengl顶点和片段着色器文件的函数,但是我收到了这个错误:

'std::basic_string<char,std::char_traits<char>,std::allocator<char>>::c_str': non-standard syntax; use '&' to create a pointer to member

我不太清楚如何解决它.这是我的代码:

GLuint shader_load(const GLchar* vertex, const GLchar* fragment) {

std::string ver = file_read_all(vertex);
std::string frag = file_read_all(fragment);

const GLchar* verCode = ver.c_str;
const GLchar* fragCode = frag.c_str;

GLuint program;

GLuint verShader, fragShader;
GLint success;
GLchar log[512];

verShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(verShader, 1, &verCode, NULL);
glCompileShader(verShader);
glGetShaderiv(verShader, GL_COMPILE_STATUS, &success);

if (!success) {
    glGetShaderInfoLog(verShader, 512, NULL, log);
    std::cout << "Failed to compile Vertex Shader\n" << log << std::endl;
    return NULL;
} …

使用g ++ 3.4和4.7,我观察到以下奇怪的行为:

如果需要用户定义的转换,则函数模板不匹配,其中普通函数将是.我在C++ 98标准中找不到相应的规则.g ++是否正确,(我假设)？或者这是一个错误？

template <class T>
int x(auto_ptr_ref<T> p)
{
  return 1;
}
// this would match
/*
int x(auto_ptr_ref<int> p)
{
   return 2;
}
*/
void dummy()
{
  cout << x(auto_ptr<int>()) << endl;
}

这里我定义一个Date,并指定一个用户定义的转换.

class Date {
private:
    int day;
    int month;
    string dateStr;
public:
    Date(int _day, int _month) : day(_day), month(_month) {}

    operator const string() {
        ostringstream formattedDate;
        formattedDate << month << "/" << day;
        dateStr = formattedDate.str();
        return dateStr;
    }
};

转换为时效果很好string.

Date d(1, 1);
string s = d;

但为什么不能cout直接使用呢？

cout << d << endl; // The compiler complains that there is no suitable type marching << operator

但是,如果我使用char*而不是string用户定义的转换,我可以cout直接使用它.为什么？ …

鉴于下面的示例,我很惊讶地发现尽管显式删除了默认构造函数(或者默认为此),但仍然可以进行聚合初始化.

#include <iostream>

struct DefaultPrivate
{
      const int n_;
      static const DefaultPrivate& create();

    private:
      DefaultPrivate() = delete;
};

const DefaultPrivate& DefaultPrivate::create()
{
    static DefaultPrivate result{10};
    return result;
}

int main() {
    DefaultPrivate x; //Fails
    DefaultPrivate y{10};//Works
    return 0;
}

私有默认(或删除)构造与聚合初始化之间的关系是否未在标准中指定？

GCC 6.3和VCC 2017就属于这种情况

我问这个问题的原因是,我希望更改对默认构造函数的访问会阻止公共聚合初始化

我试图用std::remove_if它从一个简单的字符串中删除空格，但结果却很奇怪。有人可以帮我弄清楚发生了什么吗？

该代码是：

#include <iostream>
#include <algorithm>
#include <string>

int main(int argc, char * argv[])
{
    std::string test = "a b";
    std::remove_if(test.begin(), test.end(), isspace);
    std::cout << "test : " << test << std::endl; 

    return 0;
}

我希望这只是打印出来：

test : ab

但是我得到了

test : abb

尝试另一个字符串，我得到：

输入：“ a bcde uv xy”

输出：“ abcdeuvxy xy”

似乎它在复制最后一个“单词”，但有时会添加一个空格。我怎样才能在不做任何奇怪的事情的情况下删除所有空间？

我可以按如下方式验证函数签名：

template <typename>
struct FnType
{
  static bool const valid = false;
};

struct FnType<void(int)>
{
  static bool const valid = true;
};

void foo(int)
{

}

FnType<decltype(foo)>::valid; //true

如何验证类方法签名？

class Y
{
public:
  void foo(int)
  {

  }
};

FnType<decltype(&Y::foo)>::valid; //false?? 

我想验证Y::foo返回类型和参数类型是否有效。

如果我有这样的代码

class Node {
public:
    Node *subnodes[10];
};
Node x = Node();

代码运行后是否有保证x->subnodes[0] == nullptr？

我不是 C++ 专家，我发现 C++ 规范令人生畏。这在实践中是可行的，但是规范是否保证在这种情况下将 nullptr 放入数组的每个元素中（而不是说，潜在的垃圾）？到目前为止，我还没有通过找到权威的规范语言来说服自己，并且在野外我看到很多代码示例似乎不相信这是真的。所以，经过一段时间未能想出答案后，我转向你， stack overflow。提前致谢。