当前位置： 首页>后端>正文

swift - 混编

后端2024-10-23 04:48:21

Swift 和 OC 混编 - Swift 调用 OC

在以下示例中，我们将演示如何在 Swift 项目中调用 OC 代码

假设我们有一个 Objective-C 类：

// MyClass.h
#import <Foundation/Foundation.h>

@interface MyClass : NSObject

@property (nonatomic, strong) NSString *name;
- (instancetype)initWithName:(NSString *)name;
- (void)sayHello;

@end

// MyClass.m
#import "MyClass.h"

@implementation MyClass

- (instancetype)initWithName:(NSString *)name {
    self = [super init];
    if (self) {
        _name = name;
    }
    return self;
}

- (void)sayHello {
    NSLog(@"Hello, my name is %@.", self.name);
}

@end

第一步：在 Swift 项目中创建桥接头文件。在项目中创建一个名为 Bridging-Header.h 的头文件，并将其添加到 Xcode 项目设置的 "Objective-C Bridging Header" 配置项中。如果你的项目是通过 Xcode 创建的 Swift 项目，Xcode 会询问你是否要自动创建这个桥接头文件

// Bridging-Header.h
#import "MyClass.h"

第二步：在 Swift 代码中调用 Objective-C 类

// main.swift
let objCObject = MyClass(name: "John Doe")
objCObject.sayHello()

就这么简单！现在我们已经成功地在一个 Swift 项目中使用了 Objective-C 类

Swift 和 OC 混编 - OC 调用 Swift

如果 Objective-C 项目中有 Swift 代码，Xcode 会默认生成带有项目名称的 -Swift.h 头文件，例如 YourProjectName-Swift.h
在 Swift 中，需要使用 @objc 标记所有希望被 Objective-C 代码调用的类、属性和方法。如果 Swift 类继承于 NSObject，则可以省略 @objc 标记，因为所有 NSObject 子类默认都可以在 Objective-C 代码中访问
在 Objective-C 代码中，将此头文件导入以访问 Swift 类
Swift 的访问控制遵循严格的规则。只有不拥有 private、fileprivate 修饰符的类、属性和方法才能被 Objective-C 代码调用

在以下示例中，我们将演示如何在 Objective-C 项目中调用 Swift 代码

假设我们有一个 Swift 类：

// MySwiftClass.swift
import Foundation

@objc class MySwiftClass: NSObject {
    
    @objc var name: String
    
    @objc init(name: String) {
        self.name = name
    }
    
    @objc func sayHello() {
        print("Hello, my name is \(name).")
    }
}

第一步：确保 Xcode 自动生成 YourProjectName-Swift.h 文件。在项目设置中，选择 "Build Settings"，设置 "Define Module" 为 "Yes"。

第二步：在 Objective-C 代码中导入自动生成的头文件，并使用 Swift 类：

// ViewController.m or AppDelegate.m (or any other Objective-C file)
#import "ViewController.h"
#import "YourProjectName-Swift.h"

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];

    MySwiftClass *swiftObject = [[MySwiftClass alloc] initWithName:@"John Doe"];
    [swiftObject sayHello];
}

@end

现在我们已经成功地在一个 Objective-C 项目中使用了 Swift 类。请注意，将 Swift 类和方法暴露给 Objective-C 的关键在于使用 @objc 标记。这告诉编译器需要生成符合 Objective-C 的对应部分来访问这些类和方法。

Swift 和 C++ 混编

Swift 不能直接与 C++ 代码混编。为了在 Swift 项目中使用 C++ 代码，需要遵循特定的步骤。首先，您需要创建一个 Objective-C++ 源文件（文件扩展名通常为 .mm）。然后在这个文件中，您可以包含 C++ 代码，并通过 Objective-C 接口将 C++ 类暴露给 Swift。最后，在 Swift 代码中，通过引入这个 Objective-C 接口来调用 C++ 功能

假设我们有以下 C++ 类：

// my_class.hpp
class MyClass {
public:
    MyClass();
    ~MyClass();
    int sum(int a, int b);
};

// my_class.cpp
#include "my_class.hpp"

MyClass::MyClass() {}

MyClass::~MyClass() {}

int MyClass::sum(int a, int b) {
    return a + b;
}

为了在 Swift 代码中调用这个 C++ 类，我们需要创建一个 Objective-C++ 源文件（后缀名为 .mm）：

// MyWrapper.h
#import <Foundation/Foundation.h>

// 定义一个 Objective-C 类作为 C++ 类的包装器
@interface MyWrapper : NSObject

- (int)sum:(int)a withB:(int)b;

@end

// MyWrapper.mm
#import "MyWrapper.h"
#include "my_class.hpp"

@implementation MyWrapper {
    MyClass cppObj; // 在 Objective-C 类中包含 C++ 对象
}

- (int)sum:(int)a withB:(int)b {
    return cppObj.sum(a, b); 
}

@end

接下来，在 Swift 项目的 Bridging Header 文件中，导入 MyWrapper.h：

// Bridging-Header.h
#include "MyWrapper.h"

最后，在 Swift 代码中，可以使用 MyWrapper 类调用 MyClass 的 sum 方法：

// main.swift
let myWrapper = MyWrapper()
let result = myWrapper.sum(3, withB: 4)
print("Sum of 3 and 4 is: \(result)")

Swift 和 C 混编

在 Swift 项目中与 C 代码混编的方法稍微简单一些。Swift 支持与 C 代码的混编。通过为 C 代码创建模块映射，可以直接在 Swift 代码中导入 C 函数、类型和宏。这样，可以继续使用现有的 C 代码，无需重新编写

假设我们有以下 C 代码：

// my_functions.h
int multiply(int a, int b);

// my_functions.c
#include "my_functions.h"

int multiply(int a, int b) {
    return a * b;
}

创建一个模块映射文件（modulemap 文件）：

// module.modulemap
module MyCFunctions {
    header "my_functions.h"
    export *
}

然后，在 Swift 项目的 Import Paths（导入路径）设置中添加模块映射文件的路径。这样我们就可以直接在 Swift 代码中导入和使用 C 函数了：

// main.swift
import MyCFunctions

let result = multiply(3, 4)
print("3 times 4 equals: \(result)")

Swift 中使用指针

Swift 支持指针操作。Swift 中的指针类型主要有两类：UnsafePointer<T>（对应于 const T）和 UnsafeMutablePointer<T>（对应于 T）。T 表示指向的值的类型

在 Swift 中，UnsafePointer 和 UnsafeMutablePointer 不会自动完成内存管理，因此需要手动分配和释放内存。通常在与底层 C 代码或库交互时，需要注意这些内存管理操作

以下是内存管理的一些基本方法：

内存分配

使用 UnsafeMutablePointer 的 allocate() 方法来分配内存。它需要传入表示分配内存的元素数量的参数

let count = 10
let allocatedMemory = UnsafeMutablePointer<Int>.allocate(capacity: count)

初始化内存

在分配内存后，需要使用 initialize() 方法来初始化内存。这是一个重要的步骤，因为分配的内存可能包含垃圾数据

allocatedMemory.initialize(repeating: 0, count: count)

释放内存

在完成内存的使用后，要通过调用 deallocate() 方法释放内存，以避免内存泄漏。如果你没有手动释放内存，程序可能会持续消耗系统资源，并在极端情况下可能导致系统崩溃

allocatedMemory.deallocate()

以下是一个完整的示例，演示内存分配、初始化和释放的过程

let count = 10
let allocatedMemory = UnsafeMutablePointer<Int>.allocate(capacity: count)
allocatedMemory.initialize(repeating: 0, count: count)

// 对已分配内存的操作
allocatedMemory.pointee = 42
let result = allocatedMemory.pointee
print("The value at allocated memory is: \(result)")

// 释放内存
allocatedMemory.deallocate()

https://www.xamrdz.com/backend/3eq1997315.html

相关文章：