小编fre*_*low的帖子

好吧,我现在正在重构我很久以前制作的一个课程.该类是容器类型.

许多函数可以利用类结构的优点,因此实现为成员函数.然而现在它似乎是很多看似"相同"的功能,即"查找"功能:

iterator find(ITEM)
const_iterator find(ITEM) const;
iterator find_if(ITEM, PRED)
const_iterator find_if(ITEM, PRED) const;

4个"函数"来描述几乎相同(并且每个版本的代码几乎相同).更新课程时这变得非常繁琐,我必须确保每个版本都升级.有没有办法更好地处理这些事情？类CAN中的其他一些函数可能需要2个谓词,这意味着我突然有8个函数需要管理.

我试过调用"常量版本的非常量版本",但这显然不起作用.

那么如何处理这些事情呢？只需咬紧牙关并写下来？

编辑:只是为了通知:我的数据结构类似于"树".每个"对象"包含数据(查找搜索)和带有子树的"列表".find函数在树(和子子树)的所有子树上递归递归. - 就像人们在搜索树时所期望的那样.

由于没有明确的"结束"或"开始"迭代器到这样的树,使用std :: find不会产生正确的功能.

执行这个简单的代码:

int  foo(int* a){
    cout <<"a="<<a;
    *a=1;
    cout <<", *a="<<*a<<endl;
    return 0;}

int main () {
    int* ptr;
    ptr=new int[2];
    ptr[0]=0;
    ptr[1]=0;

    cout<< foo(ptr) <<" "<< ptr <<" *ptr="<< *ptr <<endl;
    cout<< foo(ptr) <<" "<< ptr <<" *ptr="<< *ptr <<endl;

    return 0;}

导致(linux):

a=0x939f008, *a=1
0 0x939f008 *ptr=0
a=0x939f008, *a=1
0 0x939f008 *ptr=1

请解释为什么*ptr = 0在第二行,但不在第四行; 可能是,"东西" cout从右到左被"取出" ？比 - 它如何真正起作用(在运行时一步一步)？

以下三个签名之间有什么区别？

static <T> void foo(List<T>,           Comparator<? super T>);
static <T> void bar(List<? extends T>, Comparator<T>        );
static <T> void baz(List<? extends T>, Comparator<? super T>);

我知道泛型中的含义extends和super含义.我的问题是foo,bar和之间是否存在差异baz.我是否应该使其中一个参数保持不变,另一个变量在适当的方向上,或者我应该使它们两个变体？这有什么不同吗？

在汇编语言中,通常有一条指令可以添加两个操作数和一个进位.如果要实现大整数加法,只需添加最小的整数而不带进位,将下一个整数与进位相加.如何在C或C++中有效地执行此操作,而我无法访问进位标志？它应该适用于几个编译器和体系结构,所以我不能简单地使用内联汇编等.

void increment(ref int i)
{
    ++i;
}

class Class
{
    immutable int member;

    this(int parameter)
    {
        member = parameter;
        ++member;           // okay
        increment(member);  // compile-time error
    }
}

为什么++member好,但increment(member)不是吗？这两种行为不应该相同吗？

我试图在节点结构上实现递归遍历:

sealed class Node(subnodes: Traversable[Node]) extends Traversable[Node] {
  def foreach[U](f: Node => U) {
    f(this)
    subnodes foreach f
  }
}

case class Atom(id: String) extends Node(Nil)

case class Molecule(atoms: List[Node]) extends Node(atoms)

调用toString类似的元素Atom("test").toString会导致堆栈溢出:

Exception in thread "main" java.lang.StackOverflowError
at java.lang.System.arraycopy(Native Method)
at java.lang.String.getChars(Unknown Source)
at java.lang.AbstractStringBuilder.append(Unknown Source)
at java.lang.StringBuilder.append(Unknown Source)
at scala.collection.mutable.StringBuilder.append(StringBuilder.scala:197)
at scala.collection.TraversableOnce$class.addString(TraversableOnce.scala:297)
at Node.addString(Fail.scala:1)
at scala.collection.TraversableOnce$class.mkString(TraversableOnce.scala:263)
at Node.mkString(Fail.scala:1)
at scala.collection.TraversableLike$class.toString(TraversableLike.scala:615)
at Node.toString(Fail.scala:1)
at java.lang.String.valueOf(Unknown Source)
at scala.collection.mutable.StringBuilder.append(StringBuilder.scala:187)
at scala.collection.TraversableOnce$$anonfun$addString$1.apply(TraversableOnce.scala:300)
[...]
at Node.foreach(Fail.scala:3)
at scala.collection.TraversableOnce$class.addString(TraversableOnce.scala:298) …

只是为了好玩,我正在尝试用Java实现泛型Pair类.我遇到了麻烦equals:

public class Pair<A, B>
{
    public final A _1;
    public final B _2;

    // ... unnecessary details left out ...

    public boolean equals(Pair<A, B> that)
    {
        return (_1.equals(that._1)) && (_2.equals(that._2));
    }

    @Override
    public boolean equals(Object o)
    {
        return (o instanceof Pair<A, B>) && equals((Pair<A, B>) o);
    }
}

但是,o instanceof Pair<A, B>似乎没有用.这是为什么？

使用(o instanceof Pair) && equals((Pair<A, B>) o)给了我一个关于演员的警告.摆脱<A, B>演员的部分仍然给我一个警告,我想也有一些道理.

这是否意味着Java无法阻止客户端比较具有不同类型参数的Pairs？

只是为了好玩,我试图取代:

if (set1.add(x) == false)
{
    set2.add(x);
}

有:

set1.add(x) || set2.add(x);

但是,Eclipse抱怨说:

Syntax error on token "||", invalid AssignmentOperator
The left-hand side of an assignment must be a variable

任何人都可以对这些错误消息有所启发吗？他们对我没有多大意义.

我有点惊讶,以下示例抛出NullPointerException:

fun main(args: Array<String>) {
    val hm = HashMap<String, Int>()
    hm.put("alice", 42)
    val x = hm.get("bob")
    println(x)   // BOOM
}

我以为NullPointerExceptionKotlin代码中没有s？

如果我使用x可选类型进行注释,则编程将打印null:

fun main(args: Array<String>) {
    val hm = HashMap<String, Int>()
    hm.put("alice", 42)
    val x: Int? = hm.get("bob")
    println(x)   // null
}

我是否发现了一个特例,或者这是Kotlin/Java互操作的一般问题？

我正在使用带有Kotlin 0.11.91.1插件的IntelliJ IDEA 14.1社区版.

前几天我注意到我有时候会把它放在s data前,object有时则不是:

object A

data object B

objecta和a 之间有什么区别data object？