标签: rationale

似乎调用Powershell脚本块(通过调用.Invoke()方法)总是生成一个集合.具体来说,是一个类型的集合

System.Collections.ObjectModel.Collection`1[[System.Management.Automation.PSObject, System.Management.Automation, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35]]

甚至调用空脚本块({}.Invoke())也会返回一个集合.使用call运算符(&)调用相同的脚本块会产生正常预期的返回(标量或[object[]]).

如果你需要一个集合而不是一个数组,这会很方便,但它似乎有点违反直觉.

有谁知道它为什么会这样？

编辑:

我知道有两种不同的调用,.Invoke()并且.InvokeReturnAsIs()从阅读语言规范.那是我第一次注意到它.

我只是不明白命名约定背后的原因以及它的机制似乎有效.查看文档,我认为默认的调用方法不是在Powershell中调用scriptblock时使用的方法.它似乎.InvokeReturnAsIs()只返回一个对象流,然后如果有多个对象,则Powershell将其包装到一个对象数组中,如果只有一个对象则将​​其包装为标量,如果没有,则创建一个空对象,就像有一个隐式管道一样那里..Invoke()始终使用返回集合,Powershell将其作为集合保留.

给定此Java代码,此输出0和4:

class A{
   A() {  print();   }
   void print() { System.out.println("A"); }
}

class B extends A{
   int i =   Math.round(3.5f); 

   public static void main(String[] args){
      A a = new B();
      a.print();
   }
   void print() { System.out.println(i); }
}

使用这个相同的C#代码,输出4和4

使用系统;

class A{
   internal A() {  print();   }
   virtual internal void print() { Console.WriteLine("A"); }
}

class B : A{
   int i =  (int) Math.Round(3.5f); 

   public static void Main(string[] args){
      A a = new B();
      a.print();
   } …

有人可能在这里解释为什么在地球上CakePHP有一个使用多个名称的数据库表和控制器和单数模型的约定？为什么不总是使用单数术语,或总是复数？对我来说,总是不得不想"现在我在这里使用复数还是单数？"似乎令人困惑.(或者有一种简单的方法可以记住吗??)然后你有连接表使用两者的组合!

我认为在某个地方有一个很好的理由,但只是没有碰到它.
(我真的希望这不仅仅是因为Ruby-on-Rails的工作原理.)

西蒙.

IMO,C++模板规则似乎限制太多,并且定义了编译器实现.但在这里,我有一个特定的行为,我很难缠绕我的脑袋.

在下面的问题中,我有意识地避免明确地专门化父类.

问题是,我可以部分专门化一个成员,但不能完全专门化.这实际上是反直觉的,因为您可以轻松地将虚拟模板添加到完全专用的模板中并使其部分专用.这里发生了什么？？

重要的编辑:这很重要,因为,正如我们所知,你不能专门化成员函数而不专门化这个类(可以看作是这个问题的组合,需要部分专业化,而且c ++没有允许部分专门的函数.我不知道这些函数是否相关,但至少它们是一致的),因此如果你想在你的班级中使用一个你可以专攻的函数,你就会被使用仿函数所困扰.最重要的是,你需要添加一个虚拟模板参数,以使其工作!

这有效:

template <class T>
class A
{
  template<typename Y, typename Z>
  struct C{
      void operator()(int x);
  };

  template<typename Z>
  struct C<int, Z>{
      void operator()(int x);
  };
};

template <class T>
template <typename Z>
void A<T>::C<int, Z>::operator()(int x){

}

但这不是:

template <class T>
class A
{
  template<typename Y>
  struct C{
      void operator()(int x);
  };

  template<>
  struct C<int>{
      void operator()(int x);
  };
};

template <class T>
template <>
void A<T>::C<int>::operator()(int x){

}

编辑:Sean F.在评论中指出,编译器很难选择专业化.但问题在于,部分专业化不会使问题消失.所以这不是答案.

我刚才正在阅读一些代码,我跑过这一行:

(str cache \, \space lru \, \space tick \, \space limit)

这对我来说很奇怪.使用连续的文字字符,而不是包含这些字符的字符串.我希望更像这样的东西:

(str cache ", " lru ", " tick ", " limit)

但这是由一些古老的Clojure老兵写的核心库,这让我觉得可能有一个原因.什么原因？性能？或者是什么？

我知道可以fmt在仅标头模式下使用格式化库：

如何在仅标头模式下使用 fmt 库？

但是 - 为什么不只是标题，句号？也就是说，在 non-header-only 模式下使用它有什么好处？

有人能否对访问C++中的类中定义的枚举的语义有所了解？

特别是,为什么枚举成员是通过类的名称而不是枚举本身来访问的？鉴于enum在容器/范围,就像namespace和class被,为什么访问区别对待容器的元素时,这是一个enum比它的一个时class？

特定

namespace mynamespace
{
    class myclass
    {
    public:
        enum myenum
        {
            enum1,
            enum2
        };

        int myint;
    };
}

为什么是完全限定名称enum1 mynamespace::myclass::enum1而不是mynamespace::myclass::myenum::enum1？

虽然后者"有效",但它不是"推荐"的方式来调用它,而一些编译器会在那里发出警告.恕我直言,它不仅应该是正确的,而且它也应该是访问它的唯一方式.

它构成了非常奇怪的访问规则,并且当你enum1在另一个枚举中添加一个新东西时会让事情变得非常奇怪(此时你必须添加限定符).

真的,它打败了枚举的目的.枚举的成员实际上是更多的成员,而不是枚举,我必须说我发现其他语言(例如C#)的行为更为可取.

我想这是为了保持与C的兼容性,但是我不明白为什么要求访问语义中的枚举名称是更好的选择...我想让类名可选是保留C兼容性的选项.

从我最近的问题中发生的讨论(为什么c ++引用被认为比指针更安全？),它在我的脑海中提出了另一个问题:在c ++中引入引用的理由究竟是什么？

在C ++ 14维基百科页面描述的新的语言功能，通过类型的寻址元组，与您可以做写：

tuple<string, string, int> t("foo", "bar", 7);
int i = get<int>(t);        // i == 7

好吧，通常这会失败，即在通常情况下，一个元组具有多个相同类型的元素。这是一种非常特殊的（虽然我承认，这是很常见的）元组，但每个类型都有一个值。并且这种get隐含了-表示get<T>(t)形式的语义，好像不同类型中的值以某种方式相关。Tt

为什么拥有这样一种方法（在一般情况下不适用，并且似乎与某些情况相关）是一个好主意，我想您可以说出元组的子类吗？