10172.md

contributors
RamitSharma991

Basics of interoperability

Incremental adoption

• Builds on Objective-C interoperability
• Supports incremental Swift adoption

Using Swift in more places

• Adopt Swift in large C++ codebases.
• Use C++ libraries in Swift.
• Remove Objective-C bridging.
• While using C++ frameworks, Xcode imports C++ APIs automatically and don’t need a bridging header.
• Enable C++ interoperability in the build settings.

  // Calling a C++ method from Swift
  func loadImage(_ image: UIImage) {
  // Load an image into the shared C++ class.
  CxxImageEngine.shared.pointee.loadImage(image)
}

  // importing a C++ framework 
  import CxxImageKit

Bidirectional interoperability

• Incremental Swift adoption.

• Completely automatic integration by the Swift compiler without writting a Bridging layer.

• Direct calls and no overheads when calling APIs in Swift and vice-versa.

• C++ APIs availablity in Swift:

  • can import most C++ collections, both from the standard library and elsewhere
    • Collections: std::vector, std::map, User-defined
  • handlew function templates and class template specializations
  • supports managing memory using shared pointer and similar user-defined types.
    • Smart pointers: std::shared_ptr, user-defined
  • Members: methods, properties and intializers
  • Generics: structs and enums
  • Standard library: swift::Array, swift::String, and swift::Optional
  • Library evolution: resilient structs and classes

• Xcode Compatiblity

  • Code completion
  • Jump-to-definition
  • Global rename
  • Debugger support

Natural Swift APIs

• Swift compiler is able to automatically import most C++ APIs and represent them as safe Swift APIs.
  • Getters and Setters -> Methods
  • Value types -> Structs
  • Reference Types -> Pointers
  • Operators -> Operators
  • Containers -> Swift Collections
  • Constructors -> initializers
• Swift compiler allows us to fine-tune how APIs are imported and expose APIs that feel even more natural by providing the compiler with more information about your APIs through the use of annotations.
• structs represent value types and classes represent reference types.
• C++ types will be imported as value types in Swift.

Imported value types

• Short lifetimes and deep copies.
• Copy constructor and destructor manage lifetime.

Collections

• Imports any type with begin and end methods as Swift collection.
• Swift Collections can be used in for-loops, map, filter

Swift Collections Safety

• use these Swift Collection APIs rather than C++ iterator APIs which do not fit into Swift's safety model.
• The Swift compiler will help guide you towards these safer APIs by marking unsafe C++ APIs as unavailable and suggesting a safer alternative.
• C++ doesn't have a strong distinction between value types and reference types.
• Swift also gives you the option to import some things as reference or class types by adding an annotation to your C++ code.

Foreign reference types

• map CxxImageEngine to a Swift class using the SWIFT_SHARED_REFERENCE attribute.
• Enforces reference sematics.
• Removes UnsafePointer indirection.
• Manages lifetime with custom retain and release operations.

  //importing swift/bridging
  #import <swift/bridging>

  //Applying SWIFT_SHARED_REFERENCE attribute to CxxImageEngine
  struct SWIFT_SHARED_REFERENCE(IKRetain, IKRelease) CxxImageEngine {
      // ...
  };

Computed properties

SWIFT_COMPUTED_PROPERTY attribute maps getter and setter to property.

   /// \returns all images that have been loaded into the engine. Includes any modifications that were
   /// applied to the images.
   SWIFT_COMPUTED_PROPERTY
   inline std::vector<Image *_Nonnull> getImages() const;

Future evolution

• Evolve based on your feedback.
• Opt-in to changes with interoperability versions.
• You can join the workgroup and get involved on the forums. Just head to Mixing Swift and C++