小编Rob*_*Rob的帖子

我有两个具有双向关联的jpa实体.

Container包含项目集合的实体(oneToMany)Ommiting getter/setters

@javax.persistence.Entity
@Table(name = "CONTAINER")
public class Container implements Serializable {
    private static final long serialVersionUID = -3288335692695653843L;

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "ID")
    private Long id;

    @OneToMany(fetch = FetchType.LAZY, mappedBy = "container", cascade = CascadeType.ALL)
    private List<Item> items;

}

实体Item包含对容器(ManyToOne)的引用,具有属性值和日期.提出二传手/吸气剂

@javax.persistence.Entity
@Table(name = "ITEM")
public class Item implements Serializable {

    private static final long serialVersionUID = -758343957629274274L;

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "ID")
    private Long id;

    @Basic
    private Long value;
    @Basic
    private …

我正在尝试使用纯虚方法和'复制和交换'惯用法实现虚拟类,但我遇到了一些问题.代码将无法编译,因为我在包含纯虚方法的类A的assign运算符中创建实例.

有没有办法如何使用纯虚方法和复制和交换成语？

class A
{
public:
    A( string name) :
            m_name(name) { m_type = ""; }
    A( const A & rec) :
            m_name(rec.m_name), m_type(rec.m_type) {}
    friend void swap(A & lhs, A & rhs)
    {
        std::swap(lhs.m_name, rhs.m_name);
        std::swap(lhs.m_type, rhs.m_type);
    }

    A & operator=( const A & rhs)
    {
        A tmp(rhs); 
        swap(*this, tmp);
        return *this;
    }

    friend ostream & operator<<( ostream & os,A & x)
    {
         x.print(os);
         return os;
    }

protected:
    virtual void print(ostream & os) =0;    

    string m_type;
    string m_name;
}; …

在函数中，boo()我按下一个键，然后doSthTimeConsuming()调用该函数。

现在我在doSthTimeConsuming(). 问题是键被缓冲并且在下一次迭代中boo()已经有一个输入。

我可以先清除或禁用键盘缓冲boo()吗？

void boo()
{
    while(1)
    {
        c = getch();

        switch(c)
        ...
        break;
    }
}

void doSthTimeConsuming()
{
    usleep(1000000);
}

int main()
{
    WINDOW* main_win = initscr();
        cbreak();
        noecho();
        keypad(main_win, TRUE);

    while(1)
    {
        boo();
        doSthTimeConsuming();
    }

    return 0;   
}

EDIT: 我找到了一种解决方法，但我仍在寻找清除缓冲区的解决方案。

是否有可能将映射从1个实例A合并到另一个实例,而不需要对B的复制构造函数进行不必要的调用？

class A
{
    ...
    A & operator=(A && rhs);

    map<string, B> map;
};

class B
{
    B();
    B & B(B && rhs);
    ... 
}

...

A instanceOfA1;
A instanceOfA2;

B instanceOfB1;
B instanceOfB2;
B instanceOfB3;
B instanceOfB4;

instanceOfA1.map.insert( pair<string, B>("one", instanceOfB1));
instanceOfA1.map.insert( pair<string, B>("two", instanceOfB2));
instanceOfA1.map.insert( pair<string, B>("three", instanceOfB3));

instanceOfA2.map.insert( pair<string, B>("four", instanceOfB4));

instanceOfA2 = instanceOfA1;

因此instanceOfA2中的map包含B的所有四个实例.

编辑:修复代码中的实例.