小编fre*_*low的帖子

我可以初始化多态性boost::ptr_vector与boost::assign::list_of？

#include <boost/ptr_container/ptr_vector.hpp>
#include <boost/assign/list_of.hpp>

boost::ptr_vector<Animal> ls = boost::assign::list_of(new Ant)(new Bee)(new Cat);

这无法编译:

error: no match for call to '(boost::assign_detail::generic_list<Ant*>) (Bear*)'

更换boost::ptr_vector<Animal>用std::vector<Animal*>给出了同样的错误.

两个人建议手动提供模板参数Animal*到list_of:

boost::assign::list_of<Animal*>(new Ant)(new Bear)(new Cat)

但它仍然不起作用:

boost/ptr_container/ptr_sequence_adapter.hpp: In static member function 'static boost::ptr_container_detail::sequence_config<T, VoidPtrSeq>::U* boost::ptr_container_detail::sequence_config<T, VoidPtrSeq>::get_const_pointer(Iter) [with Iter = std::_Deque_iterator<Animal*, Animal*&, Animal**>, T = Animal, VoidPtrSeq = std::vector<void*, std::allocator<void*> >, boost::ptr_container_detail::sequence_config<T, VoidPtrSeq>::U = Animal]':
boost/ptr_container/detail/reversible_ptr_container.hpp:95:71:   instantiated from 'static boost::ptr_container_detail::reversible_ptr_container<Config, CloneAllocator>::Ty_* boost::ptr_container_detail::reversible_ptr_container<Config, CloneAllocator>::null_clone_allocator<allow_null_values>::allocate_clone_from_iterator(Iter) [with Iter = std::_Deque_iterator<Animal*, …

当没有同步块且没有volatile变量时,由一个线程执行的写入何时对另一个线程可见？这是一个简化的快速排序示例:

int middle = partitionForTheFirstTime(array);

Thread t = new Thread(new Quicksorter(array, 0, middle - 1));
Thread u = new Thread(new Quicksorter(array, middle + 1, array.size - 1));

t.start()
u.start();

t.join();
u.join();

(为简单起见,假设两个"工作线程"不会产生任何额外的线程.)

加入两个线程是否可以保证当前线程看到所有副作用？

在相关的说明中,如果我在初始分区之前创建线程会发生什么？

Quicksorter a = new Quicksorter();
Quicksorter b = new Quicksorter();

Thread t = new Thread(a);
Thread u = new Thread(b);

int middle = partitionForTheFirstTime(array);

a.setParameters(array, 0, middle - 1);
b.setParameters(array, middle + 1, array.size - 1);

t.start()
u.start();

t.join();
u.join();

这两个线程能否看到由此引起的副作用partitionForTheFirstTime()？换句话说,创建 …

在Java中为自定义集合编写迭代器非常复杂,因为您不必编写提供一个元素的直接代码,而是必须编写状态机:

public class CustomCollection<T> implements Iterable<T>
{
    private T[] data;
    private int size;

    @Override
    public Iterator<T> iterator()
    {
        return new Iterator<T>()
        {
            private int cursor = 0;

            @Override
            public boolean hasNext()
            {
                return cursor < size;
            }

            @Override
            public T next()
            {
                return data[cursor++];
            }

            @Override
            public void remove()
            {
                throw new UnsupportedOperationException();
            }
        };
    }
    // ...
}

对于比数组列表或链表更复杂的集合,正确获取这些状态机是一项艰巨的任务.事实上,C#设计团队认为编写自定义迭代器足够复杂,可以引入特殊的语言支持(yield return),让编译器构建状态机.

就像yield return下一个版本的Java一样？或者,在Java中编写自己的迭代器时,是否存在使我的生活更轻松的库解决方案？

说,我有一个A级

现在我在做什么

A a(A()); 

究竟发生了什么？

使用g ++ 4.6编译的以下程序会产生错误

request for member ‘y’ in ‘a2’, which is of non-class type ‘A<B>(B)’

在最后一行:

#include <iostream>

template <class T> class A
{
public:
  T y;
  A(T x):y(x){}
};

class B
{
public:
  int u;
  B(int v):u(v){}
};

int main()
{
  int v = 10;
  B b1(v);

  //works
  A<B> a1(b1);

  //does not work (the error is when a2 is used)
  A<B> a2(B(v));

  //works
  //A<B> a2((B(v)));

  std::cout << a1.y.u << " " << a2.y.u << std::endl;    
}

从代码中包含的工作变量可以看出,在A的构造函数的参数周围添加括号可以解决问题.

我已经看到一些由构造函数调用解释为函数声明引起的相关错误,比如在创建一个没有参数的构造函数的对象时,但是使用大括号:

myclass …

可以通过this显式传递指针在C中模拟成员函数.可以通过在每个对象中显式地存储指向全局函数指针数组的指针来模拟虚函数.精细.

现在我的问题是,人们真的这样做了吗？我想知道是否值得教这种技术,因为我不想向C新生传授一些实际上从未在现实世界中使用的东西.

(我需要为已经熟悉OOP的人填写为期两周的C门课程的最后一天.)

是否有任何相关的项目,图书馆或框架以所述方式在C中模拟OO？

不幸的是,scala.util.parsing.input.Position没有延伸Ordering[Position].

要ListBuffer根据位置对错误进行排序,请使用以下代码:

semanticErrors.sortBy(_.pos)(new Ordering[Position] {
  def compare(x: Position, y: Position): Int = x.line - y.line 
}).toList

我相信这可以做得更优雅.但是怎么样？例如,我注意到了Position工具<.是否有一个通用的包装器将支持的内容<转换为Ordering？

有趣的是,转换到List第一个时,这似乎要容易得多:

semanticErrors.toList.sort((a, b) => a.pos < b.pos)

但这可能不是最有效的解决方案.一个就地的ListBuffer理想选择.

考虑:

double data; 
double array[10]; 
std::vector<int> vec(4, 100); 
MyClass myclass;   

是否有区别:

sizeof(double);
sizeof(double[10]);
sizeof(std::vector<int>);
sizeof(MyClass);

和

sizeof(data);
sizeof(array);
sizeof(vec);
sizeof(myclass);

这两种语法是不同的还是严格等同的？是否所有这些都在编译时进行评估？如果没有,在运行时评估哪一个？

这是一个高阶函数,它将一个参数应用于给定函数两次:

dapp :: (a -> a -> a) -> a -> a
dapp = \f x -> f x x

ghci> dapp (*) 5
25

我们可以缩短它吗？我们问lambdabot:

lambdabot> @pl \f x -> f x x
join

万岁!我们来试试吧:

import Control.Monad (join)

dapp :: (a -> a -> a) -> a -> a
dapp = join

但它不起作用:(

No instance for (Monad ((->) a))
  arising from a use of `join'
Possible fix: add an instance declaration for (Monad ((->) a))
In the expression: join …

如果普通函数调用尚未声明的函数,则会出现编译时错误:

void foo(int x)
{
    bar(x);   // ERROR: bar has not been declared yet
}

void bar(int x)
{
    std::cout << x << '\n';
}

int main()
{
    foo(42);
}

修复方法是向前声明被调用的函数,或者切换定义的顺序.

但是,功能模板似乎不需要这些修复:

template<typename T>
void foo(T x)
{
    bar(x);   // OKAY
}

template<typename T>
void bar(T x)
{
    std::cout << x << '\n';
}

int main()
{
    foo(42);
}

编译得很好.这是为什么？当编译器看到时bar(x),为什么不抱怨？

(我使用的是g ++ 4.6.3)