标签: instantiation

据我了解，c ++模板通过为每种所需的类型编译一个单独的类或函数来工作。对于只需要少数几种不同类型/参数调用的类或函数来说，这似乎是合乎逻辑的，但是std::array似乎这可能导致同一类被编译成数百种不同版本。

我了解std::array过C样式数组的优点，但是如果我的上述假设正确的话，使用前者似乎会产生比后者更大的二进制大小。

例如，如果说在一个大型程序中，我们最终在整个代码中使用了99个大小不同的数组，那么我们实际上就有：

int arr[1]   = { ... }
int arr[2]   = { ... }
int arr[...] = { ... }
int arr[99]  = { ... }
int arr[100] = { ... }

要么

 std::array<int, 1> arr   = { ... }
 std::array<int, 2> arr   = { ... }
 std::array<int, ...> arr = { ... }
 std::array<int, 99>  arr = { ... }
 std::array<int, 100> arr = { ... }

该std::array示例是否将整个类及其所有函数编译为二进制文件99次而结束？

我理解这可能被解释为"你的偏好是什么"问题之一,但我真的想知道为什么你会选择以下方法之一而不是另一种方法.

假设你有一个超级复杂的类,例如:

class CDoSomthing {

    public:
        CDoSomthing::CDoSomthing(char *sUserName, char *sPassword)
        {
            //Do somthing...
        }

        CDoSomthing::~CDoSomthing()
        {
            //Do somthing...
        }
};

我应该如何在全局函数中声明本地实例？

int main(void)
{
    CDoSomthing *pDoSomthing = new CDoSomthing("UserName", "Password");

    //Do somthing...

    delete pDoSomthing;
}

- 要么 -

int main(void)
{
    CDoSomthing DoSomthing("UserName", "Password");

    //Do somthing...

    return 0;
}

我有一个简单的问题:实例化C#委托与仅传递函数引用相比有什么好处？我的意思是:

为什么:

Thread t = new Thread(new ThreadStart(SomeObject.SomeMethod));

当你能做到:

Thread t = new Thread(SomeObject.SomeMethod);

两者都会根据我的经验编译和工作......我错过了什么？

像这样的课程有什么缺点:

class Example1
{
  protected string UserId = (string)Session["user"];
}
//versus

class Example2
{
  protected string UserId;
  public Example2()
  {
      UserId = (string)Session["user"];
  }
}

如果我总是想设置这个值,那么Example1有什么缺点吗？

更新:
会话["user"]在Global.asax Session_Start中设置.所以如果失败了.无论如何都不应该有效.

我newInstance()在代码的一个性能关键区域中使用.方法签名是:

<T extends SomethingElse> T create(Class<T> clasz)

我Something.class作为参数传递,我得到了一个SomethingElse创建的实例newInstance().

今天我从列表中回过头来清除这个性能TODO,所以我运行了几个new运算符对的测试newInstance().我对性能损失感到非常惊讶newInstance().

我在这里写了一些关于它的内容:http://biasedbit.com/new-vs-newinstance/

(抱歉自我推销......我会在这里放置文字,但这个问题会不成比例.)

我想知道的是,-server当创建的对象数量大幅增加而不是"低"值(例如100或1000)时,为什么标志会提供这样的性能提升.

我确实从整个思考过程中吸取了教训,这只是对JVM在运行时执行的优化的好奇心,特别是对于-server标志.另外,如果我在测试中做错了什么,我会很感激您的反馈!

编辑:我添加了一个预热阶段,结果现在更加稳定.感谢您的投入!

亲爱的朋友们,我应该怎么处理关闭编译器输出的这些错误警告？非常感谢您对此特定类型的错误的想法和代码侵权:

1. JSC_WRONG_ARGUMENT_COUNT:函数parseInt:使用1个参数调用.函数至少需要2个参数且不超过2个参数.在第593行第12号
   if (parseInt(jQuery.browser.version) < 7) {

2. JSC_NOT_A_CONSTRUCTOR:无法在第708行第15个字符串实例化非构造函数
   lightbox = new Lightbox(this, opts.lightbox);

3. JSC_NOT_A_CONSTRUCTOR:无法在第1265行第19行实例化非构造函数
   var scroller = new Scroller($(this), opts);

可能我的问题很简单,但我之前从未使用过应用程序范围bean.我需要应用程序bean,因为我必须花时间在数据库上进行事务处理.我的搜索根本不能满足我的好奇心.我不知道为什么,但我没有设法初始化bean(它是null)或应用程序崩溃.所以我有一个应用程序范围bean

@ManagedBean(eager=true)
@ApplicationScoped
public class ApplicationContainer {
...
}

eager = true我读过,告诉JSF每次启动应用程序服务器(我使用GlassFish)时都会启动bean.

我在几个地方读过,我只需要把这个注释和bean初始化.对我来说它不...我读了之后如果我想将应用程序bean注入另一个bean我必须使用@PostConstuct注释

@ManagedBean
@SessionScoped
public class TestsBean implements Serializable {

    private static final long serialVersionUID = 1L;
    @ManagedProperty(value = "#{container}")
    private ApplicationContainer container;

    @PostConstruct
    public void init() {
    container.contructContainer();
    }

这给我将其注入TestsBean的其他bean中的错误...

• 如果应用程序bean在服务器启动时被初始化,它会在应用程序bean的主体中调用它来执行它需要的操作吗？或者在注入的bean中,它是在post构造方法中完成的吗？

请告诉我处理应用程序bean的正确方法.我真的很困惑......

谢谢大家的时间!

假设我有这段代码:

class Animal {
    int legs = 4;
    int head = 1;
}

public class Dog extends Animal {
    public static void main (String []args) {
        Dog dog = new Dog();
    }
}

我知道super()隐式置于no-args构造函数的第一行,所以我知道Animal构造函数将被执行,因此Animal将设置实例变量.

为了这个目的,我想,了解如果一旦这些变量已经被超级构造函数(初始化Animal),这些实例变量会在动物对象有保留或复制到子类(Dog).

在第一种情况下,对象Animal将被隐式实例化,super();并且每当实例Dog需要访问其中一个变量时,它将访问实例中保存的变量Animal(在后台创建).或者第二种情况,如果对象Animal将被临时创建,则将所有实例变量(in Animal)复制到Dog实例,然后删除Animal临时创建的实例.

我个人认为,例如,一个Dog对象将直接链接到一个Animal直接连接到一个对象的对象.

是这样的吗？

gcc是否对静态成员初始化时间有任何保证,特别是关于模板类？

我想知道在多个编译单元实例化类PWrap_T<T>::p_s之前main(),是否可以保证静态成员()将被初始化.在main的开头尝试手动触摸每个编译单元的符号是不切实际的,但我不清楚其他任何东西是否有效.

我已经用bar()不同单位的方法进行了测试,并且总是得到了预期的结果,但是我需要知道什么时候/如果gcc会将地毯拉出来以及它是否可以预防.

此外,在库完成加载之前,是否会初始化DSO中的所有静态成员？

#include <iostream>
#include <deque>

struct P;
inline std::deque<P *> &ps() { static std::deque<P *> d; return d; }
void dump();

struct P {
  P(int id, char const *i) : id_(id), inf_(i) { ps().push_back(this); }
  void doStuff() { std::cout << id_ << " (" << inf_ << ")" << std::endl; }
  int  const        id_;
  char const *const inf_;
};

template <class T>
struct PWrap_T { static P p_s; }; …

一张图片胜过千言万语,如何将这段代码从Objective-C重写为Swift？

- (id) instanceOfClass: (Class) class withInitializer: (SEL) initializerSelector withObject: (id) object {
    id obj = nil;
    if([class instancesRespondToSelector:initializerSelector]) {
        obj = [[class alloc] performSelector:initializerSelector
                                  withObject:object];
    }
    return obj;
}

id myViewController = [self instanceOfClass:[ViewController class]
                              withInitializer:@selector(initWithObject:)
                                   withObject:@"super-string!"];
NSLog(@"%@", myViewController);