小编bal*_*lki的帖子

如果我想使用指向类的指针而我不对其执行任何操作,我们可以转发声明该类.但如果恰好是typedef,为什么不允许呢？在下面的例子中,它仅编译我包含注释的代码,但为什么编译器想要在那时知道它？如何转发声明可能是typedef的内容.在c ++ 0x中这种行为有什么变化吗？

#include <iostream>
using namespace std;
/*
template<class T>
class temp;

typedef temp<int> later;
*/
class later;
void somefunc(later*);
int main()
{
  later* l;
  somefunc(l);
  return 0;
}
//The following is in someother file/compilation unit.
template<class T>
struct temp
{
  public:
    void print()
    {
        T t(5);
        std::cout<< "helloworld: " << t << std::endl;
    }
};
typedef temp<int> later;
void somefunc(later* l)
{
  l = new later();
  l->print();
}

我刚刚开始使用Ruby和Rails,我发现自己真正喜欢的一件事是它让你使用的约定.

我想在我自己的非Ruby项目中模仿这种行为.

我的问题是它是如何实际工作的？我知道我可以浏览一下Rails代码,但是我的理解还不够,知道它里面发生了什么.

我知道它需要一个基线脚本,然后针对它运行更新架构更改.但它怎么知道它的版本是什么？我如何在另一个框架/数据库中模仿它？

我有一个实用程序类,我想从中使用另一个类中的一个成员函数.我不想继承那个班级.我只想重用其他类的成员函数之一的代码.一种部分继承.

class HugeClass():
   def interestedFunc(self,arg1):
      doSomething(self.someMember1)
   def OtherFunctions(self):
      ...



class MyClass():
   def __init__(self):
      self.someMember1 = "myValue"
      self.interestedFunc = MagicFunc(HugeClass.interestedFunc)

c = MyClass()
print c.interestedFunc(arg)

MagicFunc在python中有这样的吗？

为什么类/函数有两个重载,一个用于左值,一个用于右值？

例如,从这个视频中,它说我们有两个重载vector<T>::push_back

void push_back( const T& value );
void push_back( T&& value );

为什么我们不能只按值重载一次,

void push_back( T value );

如果它是左值,则将复制值,如果它是右值,则将移动值.这不是标准的工作方式和保证吗？

struct level0
{
  virtual void foo() = 0;
};

struct level1 : level0
{
  virtual void foo() { cout <<" level1  " << endl; }
};

struct level2 : level1
{
  virtual void foo() { cout <<" level2 " << endl; }
};

struct level3 : level2
{
  using level1::foo;
};

int main()
{
  level1* l1 = new level3;
  l1->foo();
  level3 l3;
  l3.foo();
  return 0;
}

上面的代码使用gcc给出

level2
level1

但在icc给出

 level2
 level2

哪一个是正确的还是标准不确定？

编辑:这证明确实存在错误,请考虑以下主要功能

int main()
{
    level3 l3;
    l3.foo(); …

函数需要向调用者返回两个值.实施的最佳方式是什么？

选项1:

pair<U,V> myfunc()
{
...
return make_pair(getU(),getV());
}

pair<U,V> mypair = myfunc();

选项1.1:

// Same defn
U u; V v;
tie(u,v) = myfunc();

选项2:

void myfunc(U& u , V& v)
{
u = getU(); v= getV();
}

U u; V v;
myfunc(u,v);

我知道Option2,没有副本/移动,但它看起来很难看.Option1,1.1中是否会出现任何副本/移动？让我们假设U和V是支持复制/移动操作的巨大对象.

问:根据标准,理论上任何RVO/NRVO优化理论上是否可行？如果是,是否已实现gcc或任何其他编译器？

从该引用中,它允许constrvalue作为移动构造函数

Type::Type( const Type&& other );

可移动物体怎么样const？即使这在技术上是允许的,是否存在这样的声明有用的情况？

使用constexpr,可以在编译时或运行时根据参数计算函数.但通常,算法必须在编译时和运行时之间有所不同.例如.考虑constexpr版本的factorial.

constexpr int fact(int n)
{
return (n)?n*fact(n-1):1;
}

如果n在运行时发生,那么函数效率低于一个forloop？是否有一些模板魔术来确定函数是在编译时还是在运行时执行并使用不同的算法？

更新:
factorial只是一个例子.constexpr如果编码没有constexpr限制,所有功能是否都有效？例如:

constexpr int combinations(int n, int k)
{
//Assume all error conditions and edge conditions are taken care with ternary operator ?:
return fact(n)/(fact(k)*fact(n-k);
}

如果函数是在运行时编写的,那么它可以从Memoization中受益.即使这是可能的,我想很难表达这个功能,使其constexpr在运行时尽可能高效.

有两个线程(t1和t2)固定到两个不同的内核.它们都有一个共享变量,它是指向某个类类型的原始指针.t1只读指针,t2读/写指针.我应该将指针声明为volatile或atomic还是两者兼而有之？

当t2更新这个指针时,如果t1读取旧指针或新指针就没问题,但它不应该读取任何中间值,因为它会导致seg错误.

来自doc:https: //docs.python.org/3/library/asyncio-stream.html#asyncio.StreamWriter.write

写(数据)

Write data to the stream.

This method is not subject to flow control. Calls to write() should be followed by drain().

Run Code Online (Sandbox Code Playgroud)

coroutine drain()

Wait until it is appropriate to resume writing to the stream. Example:

writer.write(data)
await writer.drain()

Run Code Online (Sandbox Code Playgroud)

据我所知,

• 你需要drain每次打电话都要write打电话.
• 如果不是,我猜,write将阻止循环线程

那为什么写不是自动调用它的协同程序？为什么一个人打电话write而不必排水？我可以想到两个案例

1. 你想write和close立即
2. 在消息完成之前,您必须缓冲一些数据.

第一个是特例,我想我们可以有一个不同的api.缓冲应该在写入功能内部处理,应用程序不应该在意.

让我以不同的方式提出问题.这样做有什么缺点？python3.8版本有效吗？

async def awrite(writer, data):
    writer.write(data)
    await writer.drain()

注意:draindoc明确说明如下:

当没有什么可以等待时,drain()立即返回.

再次阅读答案和链接,我认为这些功能是这样的.注意:检查已接受的答案以获得更准确的版本

def write(data):
    remaining …