Swift和C语言的混合使用

C语言的类型和Swift类型的对应关系

1. C语言的基本类型和Swift的对应关系

C 类型	Swift 对应类型	别名
bool	CBool	Bool
char,unsigned char	CChar, CUnsignedChar	Int8, UInt8
short, unsigned short	CShort, CUnsignedShort	Int16, UInt16
int, unsigned int	CInt, CUnsignedInt	Int32, UInt32
long, unsigned long	CLong, CUnsignedLong	Int, UInt
long long, unsigned long long	CLongLong, CUnsignedLongLong	Int64, UInt64
wchar_t, char16_t, char32_t	CWideChar, CChar16, CChar32	UnicodeScalar, UInt16, UnicodeScalar
float, double	CFloat, CDouble	Float, Double

2. C语言的指针类型和Swift中的对应关系

c语言	swift	说明
const Type *	UnsafePointer<Type>	指针可变，指针指向的内存值不可变
Type *	UnsafeMutablePointer<Type>	指针和指针指向的内存值均可变
Type * const *	UnsafePointer<Type>	指针的指针：指针不可变，指针指向的类可变
Type * __strong *	UnsafeMutablePointer<Type>	指针的指针：指针可变，指针指向的类可变
Type **	AutoreleasingUnsafeMutablePointer<Type>	自动释放指针 作为OC方法中的指针参数
const void *	UnsafeRawPointer	不可变无类型指针
void *	UnsafeMutableRawPointer	可变无类型指针

如何在Swift中使用C语言的宏(Macro)

在OC和C我们通常使用宏做如下几种操作：

1. 定义一个常量值 如 #define MAXVALUE 100

2. 定义一个较长的对象属性从而减少每次调用的代码量 如 #define SCREEN_WIDTH ([[UIScreen mainScreen] bounds].size.width)

3. 定义一个带参数的宏，类似于一个函数 如 #define RGB_COLOR(r,g,b) [UIColor colorWithRed:r/255.f green:g/255.f blue:b/255.f alpha:1.0]

但对于上面的几种操作，Swift只能处理第一种情况，Swift会自动将使用#define定义常量的宏作为全局常量导入

//在头文件中定义的宏
#define FADE_ANIMATION_DURATION 0.35
#define VERSION_STRING "2.2.10.0a"
#define MAX_RESOLUTION 1268

#define HALF_RESOLUTION (MAX_RESOLUTION / 2)
#define IS_HIGH_RES (MAX_RESOLUTION > 1024)

//当上面的定义宏的头文件通过桥接文件导入进swift的时候，它和下面这些定义的全局变量是等价的
let FADE_ANIMATION_DURATION = 0.35
let VERSION_STRING = "2.2.10.0a"
let MAX_RESOLUTION = 1268

let HALF_RESOLUTION = 634
let IS_HIGH_RES = true

如何在Swift中使用C语言的Struct和Union

Swift会将在C头文件中声明的所有struct和union作为Swift struct 导入。 导入的Swift struct包含每个C struct或者union字段的存储属性和一个初始化程序，其参数与存储的属性相对应。

//C语言中
struct MyColor{
    float r,g,b;
};

union SchroedingersCat {
    bool isAlive;
    bool isDead;
};

//Swift中 
struct MyColor {
    var r: Float
    var g: Float
    var b: Float
    init()
    init(r: Float, g: Float, b: Float)
}

/*
结构体和共用体的区别在于：结构体的各个成员会占用不同的内存，互相之间没有影响；而共用体的所有成员占用同一段内存，修改一个成员会影响其余所有成员。
结构体占用的内存大于等于所有成员占用的内存的总和（成员之间可能会存在缝隙），共用体占用的内存等于最长的成员占用的内存。共用体使用了内存覆盖技术，同一时刻只能保存一个成员的值，如果对新的成员赋值，就会把原来成员的值覆盖掉。
因此Swift导入的并集中的所有计算属性都使用相同的基础内存。 结果，更改导入结构实例上的属性值会更改该结构定义的所有其他属性的值。*/
struct SchroedingersCat {
    var isAlive: Bool { get set }
    var isDead: Bool { get set }
    
    init(isAlive: Bool)
    init(isDead: Bool)
    init()
}

如果C语言结构体中有嵌套

struct Cake {
    union {
        int layers;
        double height;
    };
 
    struct {
        bool icing;
        bool sprinkles;
    } toppings;
};

/*
由于Cake结构的第一个字段未命名，因此其初始值设定项的第一个参数没有标签。 由于Cake结构的字段具有未命名的类型，因此您可以使用.init初始值设定项（由于Swift的类型推断而被允许）为每个结构的未命名字段设置初始值。
*/
let cake = Cake(
    .init(layers: 2),
    toppings: .init(icing: true, sprinkles: false)
)
print("The cake has \(cake.layers) layers.")
// Prints "The cake has 2 layers."
print("Does it have sprinkles?", cake.toppings.sprinkles ? "Yes." : "No.")
// Prints "Does it have sprinkles? No."

如何在Swift中使用C语言的函数

Swift会将在C头文件中声明的所有函数 作为Swift的全局函数导入。

int product(int multiplier, int multiplicand);
int quotient(int dividend, int divisor, int *remainder);
 
struct Point2D createPoint2D(float x, float y);
float distance(struct Point2D from, struct Point2D to);

func product(_ multiplier: Int32, _ multiplicand: Int32) -> Int32
func quotient(_ dividend: Int32, _ divisor: Int32, _ remainder: UnsafeMutablePointer<Int32>) -> Int32
 
func createPoint2D(_ x: Float, _ y: Float) -> Point2D
func distance(_ from: Point2D, _ to: Point2D) -> Float

在Swift中，可以使用Swift getVaList（_ :)或withVaList（： :)函数调用C可变参数函数，例如vasprintf（：：_ :)。 withVaList（： :)函数采用CVarArg值的数组，并在闭包参数的主体内提供CVaListPointer值，而getVaList（_ :)函数则直接返回此值。 无论使用哪个函数，您都将得到的CVaListPointer值作为C可变参数的va_list参数传递。

func swiftprintf(format: String, arguments: CVarArg...) -> String? {
    return withVaList(arguments) { va_list in
        var buffer: UnsafeMutablePointer<Int8>? = nil
        return format.withCString { cString in
            guard vasprintf(&buffer, cString, va_list) != 0 else {
                return nil
            }
            
            return String(validatingUTF8: buffer!)
        }
    }
}
print(swiftprintf(format: "√2 ≅ %g", arguments: sqrt(2.0))!)
// Prints "√2 ≅ 1.41421"

@convention解释

@convention特性是在 Swift 2.0 中引入的，用于修饰函数类型，它指出了函数调用的约定。用在以下几个地方：

• 修饰 Swift 中的函数类型，调用 C 的函数时候，可以传入修饰过@convention(c)的函数类型，匹配 C 函数参数中的函数指针。
• 修饰 Swift 中的函数类型，调用 Objective-C 的方法时候，可以传入修饰过@convention(block)的函数类型，匹配 Objective-C 方法参数中的 block 参数。

在 Swift 中调用包含函数指针参数的 C 函数

//定义了一个带有函数参数的函数 其中 callback是一个函数指针，需要调用者自己实现
int customCFunction(CGFloat (callback)(int x, int y)) {
    return callback(10, 20);
}

//在Swift中使用这个函数
let callBack:@convention(c)(Int32,Int32)->Int32 = {
    (x, y) -> Int32 in
        return x + y
}
let value = customCFunction(callBack)
print(value) //输出30

在 Swift 中调用包含 block 参数的 Objective-C 方法

Swift 中调用一个含有 block 的 Objective-C 的方法时，需要使用@convention(block)定义 Swift 变量才能传入到 Objective-C 的方法中，当然也可以直接使用闭包。

[UIView animateWithDuration:3 animations:^{
    NSLog(@"start");
} completion:^(BOOL finished){
    NSLog(@"completion");
}];

let animationsBlock : @convention(block) () -> () = {
        NSLog("start")
}
let completionBlock : @convention(block) (Bool) -> () = {
        (Bool completion) in
            NSLog("completion")
}
UIView.animateWithDuration(2, animations: animationsBlock, completion: completionBlock)