Swift:递归值类型

Question

我有一个结构，其中我想要一个Struct类型的全局变量？这个例子本质上是我实际创建的结构的一个更简单的版本。

struct SplitString { //splits a string into parts before and after the first "/"

    var preSlash: String = String()
    var postSlash: SplitString? = nil

    init(_ str: String) {
        var arr = Array(str)
        var x = 0
        for ; x < arr.count && arr[x] != "/"; x++ { preSlash.append(arr[x]) }
        if x + 1 < arr.count { //if there is a slash
            var postSlashStr = String()
            for x++; x < arr.count; x++ {
                postSlashStr.append(arr[x])
            }
            postSlash = SplitString(postSlashStr)
        }
    }

}

但是，它会抛出错误：

Recursive value type 'SplitString' is not allowed

有什么办法可以绕过这件事吗？任何帮助都会很好。谢谢:)

编辑:如果是相关的话，我是在iOS上编程，而不是OSX。

编辑:如果我有：

var split = SplitString("first/second/third")

我希望分裂是：

{preSlash = "first", postSlash = {preSlash = "second", postSlash = {preSlash = "third",
postSlash = nil}}}

Answer 1

TL;DR：

您想要实现的目标可以很容易地通过拆分来完成：

for s in split("first/second/third", { c in c == "/" } ) {
    println("\(s)")
}

讨论：

似乎您正在尝试编写一个值类型的链接列表。问题是Swift将复制语义的概念与值/引用访问相结合。(与C++不同，它允许在堆栈或堆上创建相同的对象)。解决方案似乎是将其封装在一个引用容器(参考容器，又名)中。

class SplitString { //splits a string into parts before and after the first "/"

    var preSlash: String = String()
    var postSlash: Wrapped? = nil

    init(_ str: String) {
        var arr = Array(str)
        var x = 0
        for ; x < arr.count && arr[x] != "/"; x++ { preSlash.append(arr[x]) }
        if x + 1 < arr.count { //if there is a slash
            var postSlashStr = String()
            for x++; x < arr.count; x++ {
                postSlashStr.append(arr[x])
            }
            postSlash = Wrapped(postSlashStr)
        }
    }

}

class Wrapped {
    var split:SplitString

    init(var _ str:String) {
        split = SplitString(str)
    }
}

请注意，这段代码是作为概念的证明进行编译的，但我还没有深入研究您的算法，也没有对其进行测试。

编辑：

为了响应上面的编辑，此代码将在上面执行您的代码并产生您想要的分割：

for (var s:SplitString? = split; s != nil; s = s?.postSlash?.split) {
    println("\(s!.preSlash)")
}

显然，根据上面的讨论，拥有海龟一直往下走是没有意义的，所以您需要打破循环，就像包含您的结构的类一样。

请注意，我一直试图回答您发布的问题，而不是您的问题。解决这个问题的方法是使用SequenceOf和GeneratorOf创建一个序列包装生成器，该生成器遍历斜杠并返回之间的子字符串。这实际上是通过拆分函数为您完成的：

for s in split("first/second/third", { c in c == "/" } ) {
    println("\(s)")
}

Answer 2

我认为这是因为可选的行为类似于值类型。因此，您拥有的是值类型的值类型。值类型。

为了对值类型进行布局，您需要知道所涉及的事物的大小。

因此，您已经(简化)：

sizeof(SplitString) = sizeof(String) + sizeof(SplitString?)

使用

sizeof(SplitString?) > sizeof(SplitString)

由于您需要存储值是否存在或不存在的事实(而且，不，对于这个值来说，sizeof(SplitString)零的模式不是一个有效的表示形式，就像对类类型的表示一样)--为什么？想象一下，Int = 0)

所以，现在你已经

sizeof(SplitString?) > sizeof(String) + sizeof(SplitString?)

但所有涉及的数量都肯定是> 0。而不是荒谬，对吧？