标签: initializer

我有几个翻译隐藏在初始化程序中，如下所示：

GROUP_GOVERNANCE_STYLES = [
  [I18n.t("constants.group_governance_styles.collective"), 1],
  [I18n.t("constants.group_governance_styles.electoral_democracy"), 2],
  [I18n.t("constants.group_governance_styles.dictatorship"), 3]
]

在我的 en.yml 文件中，我有：

en:
  constants:
    group_governance_styles:
      collective: "collective"
      electoral_democracy: "electoral democracy"
      dictatorship: "dictatorship"

不幸的是，当我尝试在视图中渲染这些翻译时，出现以下错误：

translation missing: en.constants.group_governance_styles.collective
translation missing: en.constants.group_governance_styles.electoral_democracy
translation missing: en.constants.group_governance_styles.dictatorship

我也尝试过删除范围，但翻译仍然缺失。还有另一种方法可以解决这个问题吗？也许初始化程序有一个我不知道的默认范围？

初始化 CBCentralManager 实例（需要委托并且通常指向所属类）的好方法是什么？

我可以将该属性声明为隐式展开的可选属性，但作为一般做法这样做似乎不太像 Swift，也不是很安全。

或者，我可以将该属性声明为可选属性。但由于 CBCentralManager 的初始值设定项未声明为可失败，因此将实例声明为可失败似乎没有意义。

隐式解包可选：

class MyUnwrappedOptional: NSObject, CBCentralManagerDelegate {
    var centralManager: CBCentralManager! 

    func init() {
        super.init()

        centralManager = CBCentralManager(delegate: self, queue: nil, options:nil)

        // Subsequent usages of centralManager in other methods of this class don't require additional unwrapping.
        centralManager.scanForPeripheralsWithServices(services, options: nil)       
    }
}

使用可选：

class MyOptionalClass: NSObject, CBCentralManagerDelegate {
    var centralManager: CBCentralManager?

    func init() {
        super.init()

        centralManager = CBCentralManager(delegate: self, queue: nil, options:nil)

        // Subsequent usages of centralManager in other methods of this class require …

创建一个带有属性的 Triangle 类来存储每条边的长度。当三边长度不同时，三角形称为不等边形，当两条边长度相同时称为等腰三角形，当三边长度相同时称为等边三角形。

为您的类创建一个初始化程序，它接受三个参数并正确设置类属性。接下来，创建第二个初始值设定项以在三角形为等边三角形时使用。请记住，所有三个边的长度都相同，因此此方法应该只接受一个参数，但仍应设置所有三个属性。尝试先将此构造器编写为指定构造器，然后再将其转换为便利构造器。最后，我们需要一个带两个参数的等腰三角形的初始化器。想想你应该如何为你的参数设置外部名称，以明确两个方面将使用哪个值

这个问题让我非常困惑。我的问题是：我应该如何init在一个类中创建等腰线和不等边线？还是我应该创建另一个类？我需要帮助。我是斯威夫特的新手。这是我到目前为止所得到的。

class Triangle {

    var sideA: Int
    var sideB: Int
    var sideC: Int

    init(sideA: Int, sideB: Int, sideC: Int) {

        self.sideA = sideA
        self.sideB = sideB
        self.sideC = sideC
    }

    convenience init(equilateralWithEdge edge:Int) {
        self.init(sideA: edge, sideB: edge, sideC:edge)
    }

}

我经常发现自己喜欢在structs、enums 和protocols 的初始化器中如何编写类似self = someValue. 当我有一些预定义值或克隆现有值时，这非常有用。

然而，这个语法对 es 不起作用class。我也实在想不通为什么。

无法赋值：“self”是不可变的

如果关注的是双重初始化，Swift 编译器知道我是否、何时以及在何处调用指定super或self初始化器，因此它知道我是否已完成初始化该实例。如果担心的是我还没有调用指定的初始化程序，那么应该没问题，因为我只是让这个实例成为对另一个实例的引用（2 vars 1 指针）。如果担心的是并发访问可能导致self已经被初始化...那么这是无意义的，因为我们在初始化器中，而Swift 初始化器不易受此影响。

毕竟我发现我可以通过一次性协议来解决这个问题：

class MyClass {
    let content: String
    
    init(content: String) {
        self.content = content
    }

    convenience init(from1 other: MyClass) {
        self = other // Cannot assign to value: 'self' is immutable
    }
}



protocol MyProto {}

extension MyClass: MyProto {}



extension MyProto {
    
    init(from2 other: Self) { …

要使用这样的初始化语法:

var contacts = new ContactList
{
    { "Dan", "dan.tao@email.com" },
    { "Eric", "ceo@google.com" }
};

...我的理解是我的ContactList类型需要定义一个带有Add两个string参数的方法:

public void Add(string name, string email);

对我来说有点困惑的是,在创建只读或固定大小的集合时,{ }初始化器语法似乎最有用.毕竟它意味着模仿数组的初始化语法,对吧？(好吧,所以数组不是只读的;但它们是固定大小的.)当然,它只能在编译时知道集合的内容(至少是元素的数量)时使用.

所以几乎看起来使用这个集合初始化器语法(有一个Add方法,因此是一个可变集合)的主要要求与它最有用的典型情况不一致.

我确信我没有像C#设计团队那样考虑这个问题; 看起来这个语法可能会有不同的规则,这些规则可以与其典型的使用场景进行更好的网格划分.

我离开基地吗？是否希望使用{ }语法来初始化固定大小的集合,这不像我想的那么常见？还有哪些其他因素可能会影响我对这种语法的要求的制定,而我根本就没有考虑过？

我发现MSVC 2012不支持initializer_list.但它可以以某种方式在VS中使用它(initializer_list)(例如在Boost库的帮助下).如果可以,请提供样品.

我正在审查一些代码并遇到了类似这样的东西(假设它是为TestObject类定义的)

-(id) init
{
    if (self == [super init])
    {
        self.testString = @"Hello";
    }
    return self;
}

我立刻改变了

if (self == [super init])

至

if (self = [super init])

但后来意识到(虽然我知道它不对)代码工作原样,我在一个超简单的程序中隔离了原始代码

    TestObject* testObject = [[TestObject alloc] init];
    NSLog(@"%@", testObject.testString);

令我惊讶的是,这很有效.为什么等式检查而不是赋值不会破坏事物？为什么是

self == [super init]

在我开始之前,在我分配它之前是真的吗？

正如ideone所见:

cout << string(50, 'x'); // xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
cout << string{50, 'x'}; // 2x

WAT？

我已经发现50是ASCII'2',所以:

cout << static_cast<int>('2'); // 50
cout << static_cast<char>(50); // 2

但就我而言,这就是我的意思.

这是否会导致针对C++ 11初始值设定项的可靠论据？

我有以下代码定义一个数组

 public class PalphabetsDic
 {
     public static string[] PAlphCodes = new string[3] {
         PAlphCodes[0] = "1593",
         PAlphCodes[1] = "1604",
         PAlphCodes[2] = "1740",
     };
 }

当我使用这个数组

var text = PalphabetsDic.PAlphCodes[1]

给出错误:

'Dota2RTL.PalphabetsDic'的类型初始值设定项引发了异常.---> System.NullReferenceException:对象引用未设置为对象的实例.

请有人帮我这个吗？

请注意什么是NullReferenceException,我该如何解决？涵盖数组,但PAlphCodes = new string[3]应该将其设置为不null.

我有以下代码(编辑:更新代码,以便每个人都可以编译并查看):

import UIKit

struct Action
{
    let text: String
    let handler: (() -> Void)?
}

class AlertView : UIView
{
    init(actions: [Action]) {
        super.init(frame: .zero)

        for action in actions {
//            let actionButton = ActionButton(type: .custom)
//            actionButton.title = action.title
//            actionButton.handler = action.handler
//            addSubview(actionButton)
        }
    }

    required init?(coder aDecoder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
}

class TextAlertView : AlertView
{
    init() {
        super.init(actions: [
            Action(text: "No", handler: nil),
            Action(text: "Yes", handler: { [weak …