Swift在线运行

版本:

所属目录
点击了解高性能代码运行API
运行结果
教程手册
代码仓库
极速运行
终端运行
图形+终端

                        
以下是用户最新保存的代码
自然相机拍 发布于:2024-09-24 23:09 UIkit学习 发布于:2024-10-01 21:20 实操遇到的问题 发布于:2024-09-19 16:52 协议的使用 发布于:2024-09-18 13:03 不是为了记笔记 发布于:2024-09-11 13:47 探索状态值 发布于:2024-08-29 22:39 的撒大大的 发布于:2024-08-13 11:50 SwiftUI探索3 发布于:2024-09-22 22:19 study swfit 发布于:2024-08-12 18:10 swfft创建 发布于:2024-08-12 18:09 再学习,弄懂不会的 发布于:2024-09-04 16:07 swiftUI学习2 发布于:2024-08-28 23:40 swiftUI初学 发布于:2024-08-28 20:38 闭包的理解 发布于:2024-09-10 16:58 搞怪记单词 发布于:2024-10-02 08:19 高性能计算器 发布于:2024-06-05 00:42 功能一和功能二 发布于:2024-05-29 00:57 高性能计算机 发布于:2024-05-21 19:55 简单计算器 发布于:2024-05-21 16:37 这是一个测试程序 发布于:2024-04-29 16:09 类的继承实验 发布于:2024-04-25 09:53 商店点单实验 发布于:2024-04-25 09:36 1. 在Xcode集成开发环境下,编写一个完整的Swift语言程序,在该程序中,定义了四个类。首先定义了类表示食品,该类中具有三个个属性分别表示名称、价格和数量,基本的初始化器和计算原始总价和打折后的总价方法; 2. 定义了类Vegetables,表示蔬菜,在类中先为其定义初始化器。然后覆盖父类中的两个方法,分别用来计算某一蔬菜原始总价和打九折后的总价; 3. 定义了类Fruits,表示水果,在类中先为其定义初始化器。接着覆盖父类中的两个方法,分别用来计算某一水果原始总价和打八折后的总价; 4. 定义了类Meats,表示肉类,在类中先为其定义初始化器。接着覆盖父类中的两个方法,分别用来计算某一肉类原始总价和打七折后的总价; 5. 在完成上述的四个类的定义之后,分别创建类Vegetables、类Fruits和类Meats的若干实例,并分别对每一个实例进行相应的赋值。将每一个实例的原始总价和打折后的总价进行求和赋给变量sum,最后再将变量sum的值进行输出打印。 发布于:2024-04-24 08:19 高性能计算器 发布于:2024-04-24 08:03 阶段性测试,计算器 发布于:2024-04-21 19:15 ## 大作业version 1.001 使用Swift语言设计一个高性能计算器,具有以下功能: (1)基本功能(80分) (i)具有二级运算符识别功能。在控制台下输入一个表达式,例如,输入 3+5*4,可以按输入的表达式中的运算符优先级进行处理,得到23。 (ii)具有括号优先级识别功能。在控制台上输入一个表达式,例如,输入1+(3+5)*4,可以按输入的表达式中的括号和运算符串的优先级进行处理,得到33。 (iii)设计的计算器可实现实数(含整数)的加、减、乘、除、乘方和开方运算。 (2)拓展功能(20分) (i)设计的计算器可实现复数的加、减、乘、除运算,具有正弦函数计算功能; (ii)设计的计算器可实现无穷精度的整数的加、减、乘、除、求模运算(提示,使用字符串)。 备注: 建议使用图形界面实现上述功能。 发布于:2024-04-17 09:27 复数Complx ** ** 在这个程序中,handleComplexOperations 函数负责处理用户输入,并调用 parseComplexFromString 来解析输入的复数字符串,然后调用 applyOp_Complx 来执行相应的复数运算。最后,它使用 printComplex 函数来打印结果。 请注意,applyOp_Complx 函数现在检查除数是否为零,以避免除以零的错误。在实际应用中,你可能还需要添加更多的错误处理和输入验证,以确保程序的健壮性。此外,程序假设用户会按照正确的格式输入复数和操作符,没有实现复杂的错误恢复机制。在实际应用中,你可能需要增加对用户输入的校验和提示。 发布于:2024-04-17 09:09 ### 大作业 最终版本 ** ** 使用Swift语言设计一个高性能计算器,具有以下功能: (1)基本功能(80分) (i)具有二级运算符识别功能。在控制台下输入一个表达式,例如,输入 3+5*4,可以按输入的表达式中的运算符优先级进行处理,得到23。 (ii)具有括号优先级识别功能。在控制台上输入一个表达式,例如,输入1+(3+5)*4,可以按输入的表达式中的括号和运算符串的优先级进行处理,得到33。 (iii)设计的计算器可实现实数(含整数)的加、减、乘、除、乘方和开方运算。 (2)拓展功能(20分) (i)设计的计算器可实现复数的加、减、乘、除运算,具有正弦函数计算功能; (ii)设计的计算器可实现无穷精度的整数的加、减、乘、除、求模运算(提示,使用字符串)。 备注: 建议使用图形界面实现上述功能。 发布于:2024-04-17 09:38 1. 其它 1. 基于Xcode集成开发环境下,编写一个完整的Swift语言程序,该程序实现将一个简单的学生信息查找功能,首先自定义一个结构体Students,要求结构体内具有六个属性,分别表示学生的姓名、学号、性别、语文成绩、数学成绩和英语成绩,同时还有初始化器、用于计算学生总成绩的方法等等; 2. 完成结构体的定义之后,首先创建多个结构体Students实例s1、s2…,并对其进行相应的赋值; 3. 输出信息提示用户输入想要查找的学生姓名或学号,使用输入函数读取键盘的输入并将其保存在变量str中,使用if-else结构进行判断,将用户输入的信息分为姓名和学号两类分别进行查找,查找到指定的学生后,将其个人信息、各科成绩以及总成绩进行输出,若没有找到指定的学生,则输出相应的提示性信息。 提交 发布于:2024-04-17 08:15 冒泡排序小到大 发布于:2024-04-03 09:33 使用Swift语言设计一个高性能计算器,具有以下功能: (1)基本功能(80分) (i)具有二级运算符识别功能。在控制台下输入一个表达式,例如,输入 3+5*4,可以按输入的表达式中的运算符优先级进行处理,得到23。 (ii)具有括号优先级识别功能。在控制台上输入一个表达式,例如,输入1+(3+5)*4,可以按输入的表达式中的括号和运算符串的优先级进行处理,得到33。 (iii)设计的计算器可实现实数(含整数)的加、减、乘、除、乘方和开方运算。 (2)拓展功能(20分) (i)设计的计算器可实现复数的加、减、乘、除运算,具有正弦函数计算功能; (ii)设计的计算器可实现无穷精度的整数的加、减、乘、除、求模运算(提示,使用字符串)。 备注: 建议使用图形界面实现上述功能。 发布于:2024-04-03 09:58 商店点单。 发布于:2024-04-01 11:21 创建数据库 发布于:2024-03-23 08:42 输入输出程序 发布于:2024-03-20 09:08 ###.Exp1 1.编写一个完整的Swift语言程序。首先,输出语句提示用户输入一个字符串,调用输入函数读取键盘,并将读取得到的字符串赋给变量fruit; 2. 重复上一步的操作,将读取的字符串赋给变量price,对变量price进行判断,如果该字符串含有0~9以外的字符,则提示用户重新输入一个字符串,否则就将price强制类型转换为int型再赋给p1,将以十进制数形式表示的字符串转化为整数,赋给p2; 3. 创建一个非空的字典类型变量dic和一个空的数组变量arr,将变量fruit-变量price作为一组键值对,添加到变量dic中,使用for-in结构对变量dic的值进行遍历并添加到数组变量arr中,在完成循环之后,对变量arr进行删除和元素访问操作。 发布于:2024-03-13 10:00 输入与输出实验 发布于:2024-05-29 08:21 实验四、学生信息查询实验 发布于:2023-12-06 06:47 课内作业,约瑟夫算法 发布于:2023-11-20 08:55 综合性实验 发布于:2023-11-16 11:02 找出多个数组中的最大数字 发布于:2023-09-22 17:22 实验五 Swift枚举&协议&扩展&泛 发布于:2023-09-20 18:41 swift输入输出类型 发布于:2023-09-13 13:38 实验四 函数类型 发布于:2023-09-17 13:17 斐波那契数列的动态规划和递归形式 发布于:2023-09-11 14:09 day03 数组,集合,字典,字符串 发布于:2023-09-11 11:45 实验三,数组 发布于:2023-09-17 12:58 Swift运算符&控制流 发布于:2023-09-06 16:06 实验二 Swift运算符&控制流 发布于:2023-09-10 17:00 day01实验1 发布于:2023-09-05 15:27 实验一 Swift编程步骤&数据类型 发布于:2023-09-10 17:00 [更多]
显示目录

访问控制



学习嵌入式的绝佳套件,esp8266开源小电视成品,比自己去买开发板+屏幕还要便宜,省去了焊接不当搞坏的风险。 蜂鸣版+触控升级仅36元,更强的硬件、价格全网最低。

点击购买 固件广场

Swift 访问控制

访问控制可以限定其他源文件或模块中代码对你代码的访问级别。

你可以明确地给单个类型(类、结构体、枚举)设置访问级别,也可以给这些类型的属性、函数、初始化方法、基本类型、下标索引等设置访问级别。

协议也可以被限定在一定的范围内使用,包括协议里的全局常量、变量和函数。

访问控制基于模块与源文件。

模块指的是以独立单元构建和发布的Framework或Application。在Swift 中的一个模块可以使用import关键字引入另外一个模块。

源文件是单个源码文件,它通常属于一个模块, 源文件可以包含多个类和函数 的定义。

Swift 为代码中的实体提供了三种不同的访问级别:public、internal、private。

访问级别 定义
Public 可以访问自己模块中源文件里的任何实体,别人也可以通过引入该模块来访问源文件里的所有实体。
Internal :可以访问自己模块中源文件里的任何实体,但是别人不能访问该模块中源文件里的实体。
Private 只能在当前源文件中使用的实体,称为私有实体。

public为最高级访问级别,private为最低级访问级别。

语法

通过修饰符public、internal、private来声明实体的访问级别:

public class SomePublicClass {}
internal class SomeInternalClass {}
private class SomePrivateClass {}

public var somePublicVariable = 0
internal let someInternalConstant = 0
private func somePrivateFunction() {}

除非有特殊的说明,否则实体都使用默认的访问级别internal。


函数类型访问权限

函数的访问级别需要根据该函数的参数类型和返回类型的访问级别得出。

下面的例子定义了一个名为someFunction全局函数,并且没有明确地申明其访问级别。

func someFunction() -> (SomeInternalClass, SomePrivateClass) {
    // 函数实现
}

函数中其中一个类 SomeInternalClass 的访问级别是internal,另一个 SomePrivateClass 的访问级别是private。所以根据元组访问级别的原则,该元组的访问级别是private。

因为该函数返回类型的访问级别是private,所以你必须使用private修饰符,明确的声明该函数:

private func someFunction() -> (SomeInternalClass, SomePrivateClass) {
    // 函数实现
}

将该函数申明为public或internal,或者使用默认的访问级别internal都是错误的。


枚举类型访问权限

枚举中成员的访问级别继承自该枚举,你不能为枚举中的成员单独申明不同的访问级别。

实例

比如下面的例子,枚举 Student 被明确的申明为 public 级别,那么它的成员 Name,Mark 的访问级别同样也是 public:

public enum Student {
    case Name(String)
    case Mark(Int,Int,Int)
}

var studDetails = Student.Name("Swift")
var studMarks = Student.Mark(98,97,95)

switch studMarks {
case .Name(let studName):
    print("学生名: \(studName).")
case .Mark(let Mark1, let Mark2, let Mark3):
    print("学生成绩: \(Mark1),\(Mark2),\(Mark3)")
}

以上程序执行输出结果为:

学生成绩: 98,97,95

子类访问权限

子类的访问级别不得高于父类的访问级别。比如说,父类的访问级别是internal,子类的访问级别就不能申明为public。

public class SuperClass {
    private func show() {
        print("超类")
    }
}

// 访问级别不能低于超类 internal > public
internal class SubClass: SuperClass  {
    override internal func show() {
        print("子类")
    }
}

let sup = SuperClass()
sup.show()

let sub = SubClass()
sub.show()

以上程序执行输出结果为:

超类
子类

常量、变量、属性、下标访问权限

常量、变量、属性不能拥有比它们的类型更高的访问级别。

比如说,你定义一个public级别的属性,但是它的类型是private级别的,这是编译器所不允许的。

同样,下标也不能拥有比索引类型或返回类型更高的访问级别。

如果常量、变量、属性、下标索引的定义类型是private级别的,那么它们必须要明确的申明访问级别为private:

private var privateInstance = SomePrivateClass()

Getter 和 Setter访问权限

常量、变量、属性、下标索引的Getters和Setters的访问级别继承自它们所属成员的访问级别。

Setter的访问级别可以低于对应的Getter的访问级别,这样就可以控制变量、属性或下标索引的读写权限。

class Samplepgm {
    private var counter: Int = 0{
        willSet(newTotal){
            print("计数器: \(newTotal)")
        }
        didSet{
            if counter > oldValue {
                print("新增加数量 \(counter - oldValue)")
            }
        }
    }
}

let NewCounter = Samplepgm()
NewCounter.counter = 100
NewCounter.counter = 800

以上程序执行输出结果为:

计数器: 100
新增加数量 100
计数器: 800
新增加数量 700

构造器和默认构造器访问权限

初始化

我们可以给自定义的初始化方法申明访问级别,但是要不高于它所属类的访问级别。但必要构造器例外,它的访问级别必须和所属类的访问级别相同。

如同函数或方法参数,初始化方法参数的访问级别也不能低于初始化方法的访问级别。

默认初始化方法

Swift为结构体、类都提供了一个默认的无参初始化方法,用于给它们的所有属性提供赋值操作,但不会给出具体值。

默认初始化方法的访问级别与所属类型的访问级别相同。

实例

在每个子类的 init() 方法前使用 required 关键字声明访问权限。

class classA {
    required init() {
        var a = 10
        print(a)
    }
}

class classB: classA {
    required init() {
        var b = 30
        print(b)
    }
}

let res = classA()
let show = classB()

以上程序执行输出结果为:

10
30
10

协议访问权限

如果想为一个协议明确的申明访问级别,那么需要注意一点,就是你要确保该协议只在你申明的访问级别作用域中使用。

如果你定义了一个public访问级别的协议,那么实现该协议提供的必要函数也会是public的访问级别。这一点不同于其他类型,比如,public访问级别的其他类型,他们成员的访问级别为internal。

public protocol TcpProtocol {
    init(no1: Int)
}

public class MainClass {
    var no1: Int // local storage
    init(no1: Int) {
        self.no1 = no1 // initialization
    }
}

class SubClass: MainClass, TcpProtocol {
    var no2: Int
    init(no1: Int, no2 : Int) {
        self.no2 = no2
        super.init(no1:no1)
    }

    // Requires only one parameter for convenient method
    required override convenience init(no1: Int)  {
        self.init(no1:no1, no2:0)
    }
}

let res = MainClass(no1: 20)
let show = SubClass(no1: 30, no2: 50)

print("res is: \(res.no1)")
print("res is: \(show.no1)")
print("res is: \(show.no2)")

以上程序执行输出结果为:

res is: 20
res is: 30
res is: 50

扩展访问权限

你可以在条件允许的情况下对类、结构体、枚举进行扩展。扩展成员应该具有和原始类成员一致的访问级别。比如你扩展了一个公共类型,那么你新加的成员应该具有和原始成员一样的默认的internal访问级别。

或者,你可以明确申明扩展的访问级别(比如使用private extension)给该扩展内所有成员申明一个新的默认访问级别。这个新的默认访问级别仍然可以被单独成员所申明的访问级别所覆盖。


泛型访问权限

泛型类型或泛型函数的访问级别取泛型类型、函数本身、泛型类型参数三者中的最低访问级别。

public struct TOS<T> {
    var items = [T]()
    private mutating func push(item: T) {
        items.append(item)
    }

    mutating func pop() -> T {
        return items.removeLast()
    }
}

var tos = TOS<String>()
tos.push("Swift")
print(tos.items)

tos.push("泛型")
print(tos.items)

tos.push("类型参数")
print(tos.items)

tos.push("类型参数名")
print(tos.items)
let deletetos = tos.pop()

以上程序执行输出结果为:

["Swift"]
["Swift", "泛型"]
["Swift", "泛型", "类型参数"]
["Swift", "泛型", "类型参数", "类型参数名"]

类型别名

任何你定义的类型别名都会被当作不同的类型,以便于进行访问控制。一个类型别名的访问级别不可高于原类型的访问级别。

比如说,一个private级别的类型别名可以设定给一个public、internal、private的类型,但是一个public级别的类型别名只能设定给一个public级别的类型,不能设定给internal或private 级别的类型。

注意:这条规则也适用于为满足协议一致性而给相关类型命名别名的情况。

public protocol Container {
    typealias ItemType
    mutating func append(item: ItemType)
    var count: Int { get }
    subscript(i: Int) -> ItemType { get }
}

struct Stack<T>: Container {
    // original Stack<T> implementation
    var items = [T]()
    mutating func push(item: T) {
        items.append(item)
    }

    mutating func pop() -> T {
        return items.removeLast()
    }

    // conformance to the Container protocol
    mutating func append(item: T) {
        self.push(item)
    }

    var count: Int {
        return items.count
    }

    subscript(i: Int) -> T {
        return items[i]
    }
}

func allItemsMatch<
    C1: Container, C2: Container
    where C1.ItemType == C2.ItemType, C1.ItemType: Equatable>
    (someContainer: C1, anotherContainer: C2) -> Bool {
        // check that both containers contain the same number of items
        if someContainer.count != anotherContainer.count {
            return false
        }

        // check each pair of items to see if they are equivalent
        for i in 0..<someContainer.count {
            if someContainer[i] != anotherContainer[i] {
                return false
            }
        }

        // all items match, so return true
        return true
}

var tos = Stack<String>()
tos.push("Swift")
print(tos.items)

tos.push("泛型")
print(tos.items)

tos.push("Where 语句")
print(tos.items)

var eos = ["Swift", "泛型", "Where 语句"]
print(eos)

以上程序执行输出结果为:

["Swift"]
["Swift", "泛型"]
["Swift", "泛型", "Where 语句"]
["Swift", "泛型", "Where 语句"]
由JSRUN为你提供的Swift在线运行、在线编译工具
        JSRUN提供的Swift 在线运行,Swift 在线运行工具,基于linux操作系统环境提供线上编译和线上运行,具有运行快速,运行结果与常用开发、生产环境保持一致的特点。
yout