标签: nested-class

哪个更容易接受（最佳实践）？：

namespace NP
   public static class IO
   public static class Xml
   ...
   // extension methods

using NP;

IO.GetAvailableResources ();

对比

public static class NP
   public static class IO
   public static class Xml
   ...
   // extension methods

NP.IO.GetAvailableResources ();

同样对于#2，代码大小是通过部分类来管理的，因此每个嵌套类都可以在一个单独的文件中，扩展方法也是如此（除了它们没有嵌套类）

我更喜欢#2，有几个原因，例如能够使用已经常用的类型名称，例如IO，我不想替换或冲突。

你更倾向哪个？各有优缺点吗？这种情况的最佳做法是什么？

编辑：两者之间还会有性能差异吗？

我有两个模型Ticket和TicketComment，TicketComment 是 Ticket 的孩子。

票证.rb

class Ticket < ActiveRecord::Base
  has_many :ticket_comments, :dependent => :destroy, :order => 'created_at DESC'

  # allow the ticket comments to be created from within a ticket form
  accepts_nested_attributes_for :ticket_comments, :reject_if => proc { |attributes| attributes['comment'].blank? }
end

ticket_comment.rb

class TicketComment < ActiveRecord::Base
  belongs_to :ticket

  validates_presence_of :comment
end

我想要做的是模仿 Trac 中的功能，如果用户更改票证和/或添加评论，则会向分配给票证的人员发送电子邮件。

我想使用 after_update 或 after_save 回调，以便我知道在发送电子邮件之前信息已全部保存。

如何检测模型的更改 (ticket.changes) 以及是否创建了新评论 (ticket.comments) 并在一封电子邮件中发送此更新（x 更改为 y，用户添加的评论“文本”）回调方法？

以下代码成功打印OK：

class B(object):
        def __init__(self):
            super(B, self).__init__()
            print 'OK'

class A(object):
    def __init__(self):
       self.B()

    B = B

A()

但是下面应该和上面一样工作 NameError: global name 'B' is not defined

class A(object):
    def __init__(self):
       self.B()

    class B(object):
        def __init__(self):
            super(B, self).__init__()
            print 'OK'
A()

为什么？

C++

如何将内部（嵌套）类的定义置于其外部（封闭）类的定义之外，其中外部类至少有一个内部类实例作为数据成员？我搜索了但我找到的最相关的 SO 答案，源文件中的嵌套类定义，没有一个示例，其中外部类将内部对象作为数据成员。我遵循了那个答案，就在外部类的定义中声明但未定义内部类而言，但我的代码仍然被破坏：

struct Outer
{
    struct Inner;
    Inner myinner;
    Outer() : myinner(2) {}
};

struct Outer::Inner
{
    Inner(int n) : num(n) {}
    int num;
};

int main()
{
    Outer myouter;
}

它给出了error C2079: 'Outer::myinner' uses undefined struct 'Outer::Inner'VC11 中的错误。

为什么损坏的代码没有与在Inner的定义中定义的版本等效的效果Outer，就像下面的工作代码一样？

struct Outer
{
    struct Inner
    {
        Inner(int n) : num(n) {}
        int num;
    } myinner;
    Outer() : myinner(2) {}
};

我想将算法实现为派生自纯虚拟类的类，代表特定算法解决的问题类型。

通用界面如下所示：

template<typename A, typename B>\nclass ISolutionToProblem\n{\npublic:\n    virtual void Init(const A & input, const B & param) = 0;\n    virtual const B & ComputeSolution() = 0;\n\n    virtual ~ISolutionToProblem() {}\n};\n

其实现例如是：

template<typename T>\nclass MyAlgorithm:\n    public ISolutionToProblem<typename MyAlgorithm<T>::WorkData, T>\n{\npublic:\n    struct WorkData { /* Stuff using T... */ };\n    virtual void Init(const WorkData & input, const T & param);\n    virtual const T & ComputeSolution();\n\nvirtual ~MyAlgorithm();\n};\n

（更具体地说，问题实际上是路径查找，但我认为这不相关）

我的问题是继承部分：我使用嵌套结构作为模板参数，无论我如何很好地与编译器交谈，它都会拒绝编译我的代码。

我可以偷懒，只是将内部结构放在类之外，但如果可能的话，我更希望它整齐地放置在类中。

\n
1. 那么我想做的事情实际上是可能的吗（在 C++98 中）？
\n
2. 如果是的话我该怎么写呢？（如果你让我理解为什么语法不接受上面的形式，那就加分了）
\n …

我有一个像这样的抽象类:

class A
{
public:
    void func() = 0;
};

我可以强制它的实现也有一个嵌套的迭代器类吗？

#include <iterator>

template<typename T>
class A
{
public:
    class Iterator : public std::iterator<std::forward_iterator_tag, T>
    {
    };

    virtual Iterator begin() const = 0;
    virtual void func() = 0;
};

template<typename T>
class B : public A<T>
{
public:
    B() {}
    class Iterator : public std::iterator<std::forward_iterator_tag, T>
    {
    };

    Iterator begin() const
    {
        return Iterator();
    }

    virtual void func()
    {
    }
};

int main()
{
    B<int> b;
}

我只是想知道这是否可行,如果是的话,我错过了什么？由于迭代器类将取决于如何实现类A,我不知道是否可以进行正式实现.

在哪种情况下接口可以嵌套类？

以下代码是允许且有效的.

public interface Iface {

    void show();

    class ifaceClass {
        int x;

        public ifaceClass() {
            System.out.println(x);
        }
    }
}

我也在努力创建类ifaceClass的对象.

编辑:

我能够制作这样的物体

public class Test implements Iface {    

    public static void main(String[] args){
        ifaceClass  ifaceClassObj = new ifaceClass();
    }

    public void show() {    

    }
}

我注意到如果Test没有实现Iface那么我需要在导入之后,

import com.jls.Iface.ifaceClass;

但它归结为同样的问题,为什么不把它用作另一个类.

这种方法的差异或增值是什么？

假设我有一个只对任何类型 T 执行加法的类。我想添加一个可选的范围检查（基于 bool 类型的模板参数），它将检查加法的结果是否属于给定的范围，或者否则它会抛出。这样做的一种方法是将类的所有基础知识包装在一个基类中，然后专门处理布尔模板参数。就像是：

// The base class; holds a starting value to add to and a maximum value
template<typename T>
class DummyImpl
{
private:
  T mval, mmax;

public:
  constexpr explicit DummyImpl(T x, T max_x) noexcept
 : mval{x}, mmax{max_x}
  {};

  // base class; use a virtual destructor
  virtual ~DummyImpl() {};

  T max() const noexcept {return mmax;}
  T val() const noexcept {return mval;}
};

// The "real" class; parameter B denotes if we want (or not)
// a range check …

我试图在Scala中实现一些有效的枚举.我想使用案例类来做到这一点,以便编译器能够检测任何非详尽的模式匹配.

这在基本形式下工作正常,例如:

sealed abstract class HorizontalAlignment
case object Left extends HorizontalAlignment
case object Right extends HorizontalAlignment
case object Center extends HorizontalAlignment
case object AsIs extends HorizontalAlignment
...
def test (x : HorizontalAlignment) = 
  x match {
    case Left => ...
    ...  
  } 

但是这并不理想,因为案例对象的名称很容易发生冲突:

sealed abstract class HorizontalAlignment
case object Left extends HorizontalAlignment
case object Right extends HorizontalAlignment
case object Center extends HorizontalAlignment
case object AsIs extends HorizontalAlignment

sealed abstract class VerticalAlignment
case object Top extends VerticalAlignment
case object Bottom extends …

具体来说,我需要声明(据我所知)intrusive_ptr_{add_ref,release}作为我引用类的朋友:

#include <boost/intrusive_ptr.hpp>
using boost::intrusive_ptr;

class Outer {
public:

    //user-exposed interface goes here

protected:
    class Inner {
    public:
        Inner():refct(0){}
        virtual ~Inner(){}

        //machinery goes here

        size_t refct;
    };

    friend void boost::intrusive_ptr_release(Inner *p);
    friend void boost::intrusive_ptr_add_ref(Inner *p);

    intrusive_ptr<Inner> handle;

};

namespace boost {

    void intrusive_ptr_release(Outer::Inner *p){
        if ((p->refct -= 1) <= 0){
            delete p;
        }
    }

    void intrusive_ptr_add_ref(Outer::Inner *p){
        p->refct++;
    }

};

我无法找到正确的语法来进行编译并保持我想要的访问权限.我的主要问题是gcc似乎很不高兴"boost :: intrusive_ptr_release(Outer :: Inner*p)应该在名称空间提升中声明".

我从这个例子中看到,intrusive_ptr帮助器是在命名空间boost中向前声明的 - 但我无法转发声明它们,因为据我所知,嵌套类(即"内部",这些函数引用的)只能是在他们的外部类中向前声明,这也是朋友声明必须去的地方.

更大的C++大师,处理这个问题的正确方法是什么？