Structures and Classes

tags: Swift Docs

Structures and classes are general-purpose, flexible constructs that become the building blocks of your program’s code.

구조체와 클래스는 프로그램 코드의 빌딩 블록이 되는 유연한 범용 구조 입니다.

You define properties and methods to add functionality to your structures and classes using the same syntax you use to define constants, variables, and functions.

프로퍼티와 메서드를 정의하여 상수, 변수 및 함수를 정의 하는 데 사용하는 것과 동일한 구문을 사용하여 구조체 및 클래스에 기능을 추가 합니다.

Unlike other programming languages, Swift doesn’t require you to create separate interface and implementation files for custom structures and classes.

다른 프로그래밍 언어와 달리 Swift는 사용자 정의 구조체 및 클래스에 대해 별도의 인터페이스 및 구현 파일을 만들 필요가 없습니다.

In Swift, you define a structure or class in a single file, and the external interface to that class or structure is automatically made available for other code to use.

Swift에서 단일 파일에 구조체 또는 클래스를 정의하면 해당 클래스 또는 구조에 대한 외부 인터페이스가 자동으로 다른 코드에서 사용할 수 있게 됩니다.

💡 Note:
An instance of a class is traditionally known as an object. However, Swift structures and classes are much closer in functionality than in other languages, and much of this chapter describes functionality that applies to instances of either a class or a structure type. Because of this, the more general term instance is used.

💡 노트:
클래스의 인스턴스는 전통적으로 객체로 알려져 있습니다. 그러나 Swift구조와 클래스는 다른 언어보다 기능면에서 훨씬 더 가깝습니다. 그리고 이 장의 대부분은 클래스 또는 구조 유형의 인스턴스에 적용되는 기능에 대해 설명 합니다. 이 때문에 보다 일반적인 용어 인스턴스가 사용 됩니다.

Comparing Structures and Classes

Structures and classes in Swift have many things in common. Both can:

Swift의 구조와 클래스에는 많은 공통점이 있습니다. 둘 다 다음을 수행할 수 있습니다.

• Define properties to store values

값을 저장할 프로퍼티 정의

• Define methods to provide functionality

기능을 제공하는 메소드 정의

• Define subscripts to provide access to their values using subscript syntax

서브스크립트을 사용하여 값에 대한 액세서를 제공하도록 서브스크립트를 정의합니다.

• Define initializers to set up their initial state

초기 상태를 설정하기 위한 이니셜라이저 정의

• Be extended to expand their functionality beyond a default implementation

기본 구현 이상으로 기능을 확장하도록 확장

• Conform to protocols to provide standard functionality of a certain kind

특정 종류의 표준 기능을 제공하는 프로토콜 준수

For more information, see Properties, Methods, Subscripts, Initialization, Extensions, and Protocols.

자세한 내용은 프로퍼티, 메서드, 서브스크립트, 초기화, 확장 및 프로토콜을 참조 하세요.

Classes have additional capabilities that structures don’t have:

클래스에는 구조에 없는 추가 기능이 있습니다.

• Inheritance enables one class to inherit the characteristics of another.

상속을 통해 한 클래스가 다른 클래스의 특성을 상속할 수 있습니다.

• Type casting enables you to check and interpret the type of a class instance at runtime.

타입 캐스팅에 사용하면 런타임에 클래스 인스턴스의 타입을 확인하고 해석할 수 있습니다.

• Deinitializers enable an instance of a class to free up any resources it has assigned.

Deinitializers는 클래스의 인스턴스가 할당된 리소스를 해제할 수 있습니다.

• Reference counting allows more than one reference to a class instance.

참조 카운팅은 클래스 인스턴스에 대한 둘 이상의 참조를 허용 합니다.

For more information, see Inheritance, Type Casting, Deinitialization, and Automatic Reference Counting.

자세한 내용은 상속, 형식 캐스팅, 초기화 취소 및 자동 참조 카운팅을 참조하세요

The additional capabilities that classes support come at the cost of increased complexity.

클래스가 지원하는 추가 기능에는 복잡성이 증가합니다.

As a general guideline, prefer structures because they’re easier to reason about, and use classes when they’re appropriate or necessary.

일반적인 지침으로, 추론하기 쉽기 때문에 구조를 선호하고 적절하거나 필요할 때 클래스를 사용 합니다.

In practice, this means most of the custom data types you define will be structures and enumerations.

실제로 이것은 정의하는 대부분의 사용자 정의 데이터 유형이 구조 및 열거형이 될 것임을 의미합니다.

For a more detailed comparison, see Choosing Between Structures and Classes.

더 자세한 비교는 구조와 클래스 중 선택을 참조하십시오.

💡Note: NOTE
Classes and actors share many of the same characteristics and behaviors. For information about actors, see Concurrency.

노트 클래스와 액터는 동일한 특성한 특성과 동작을 많이 공유 합니다. 행위자에 대한 정보는 동시성을 참조 하십시오.

Definition Syntax

Structures and classes have a similar definition syntax.

구조체와 클래스는 유사한 정의 구문을 가지고 있습니다.

You introduce structures with the struct keyword and classes with the class keyword.

struct 키워드로 구조를 도입하고 class 키워드로 클래스를 도입 합니다.

Both place their entire definition within a pair of braces:

둘 다 한 쌍의 중괄호 안에 전체 정의를 배치 합니다.

struct SomeStructure {
    // structure definition goes here
}
class SomeClass {
    // class definition goes here
}

💡NOTE
Whenever you define a new structure or class, you define a new Swift type. Give types UpperCamelCase names (such as SomeStructure and SomeClass here) to match the capitalization of standard Swift types Give properties and methods lowerCamelCase names (such as frameRate and incrementCount) to differentiate them from type names.

새 구조체나 클래스를 정의할 때마다 새 Swift 유형을 정의 합니다. 표준 Swift유형의 대문자 사용과 일치하도록 유형에 UpperCamelCase 이름(예: SomeStructure 및 SomeClass)을 지정 합니다. 프로퍼티 및 메서드에 lowerCamelCase 이름(예: frameRate 및 incrementCount)을 지정하여 유형 이름과 구별 합니다.

Here’s an example of a structure definition and a class definition:

다음은 구조 정의 및 클래스 정의의 예 입니다.

struct Resolution {
    var width = 0
    var height = 0
}
class VideoMode {
    var resolution = Resolution()
    var interlaced = false
    var frameRate = 0.0
    var name: String?
}

The example above defines a new structure called Resolution, to describe a pixel-based display resolution.

위의 예는 픽셀 기반 디스플레이 해상도를 설명하기 위해 Resolution이라는 새로운 구조를 정의 합니다.

This structure has two stored properties called width and height.

이 구조에는 너비와 높이라는 두 개의 저장 프로퍼티가 있습니다.

Stored properties are constants or variables that are bundled up and stored as part of the structure or class.

저장 프로퍼티는 묶어서 구조체나 클래스의 일부로 저장하는 상수 또는 변수 입니다.

These two properties are inferred to be of type Int by setting them to an initial integer value of 0.

이 두 프로퍼티는 초기 정수 값으로 0을 설정하여 Int유형으로 유추 됩니다.

The example above also defines a new class called VideoMode, to describe a specific video mode for video display.

위의 예는 또한 비디오 표시를 위한 특정 비디오 모드를 설명하기 위해 VideoMode라는 새 클래스를 정의 합니다.

This class has four variable stored properties.

이 클래스에는 4개의 변수 저장 프로퍼티가 있습니다.

The first, resolution, is initialized with a new Resolution structure instance, which infers a property type of Resolution.

첫 번째인 resolution은 Resolution의 프로퍼티 유형을 유추하는 새로운 Resolution 구조체 인스턴스로 초기화 됩니다.

For the other three properties, new VideoMode instances will be initialized with an interlaced setting of false (meaning “noninterlaced video”), a playback frame rate of 0.0, and an optional String value called name.

다른 세 프로퍼티인 경우 새 VideoMode인스턴스는 false의 인스레이스 설정("비인터레이스 비디오"를 의미), 재생 프레임 속도 0.0 및 name이라는 옵셔널 문자열 값으로 초기화 합니다.

The name property is automatically given a default value of nil, or “no name value”, because it’s of an optional type.

name 프로퍼티는 옵셔널 유형이기 때문에 기본값 nil 또는 "이름 값 없음"이 자동으로 지정 됩니다.

Structure and Class Instances

The Resolution structure definition and the VideoMode class definition only describe what a Resolution or VideoMode will look like.

Resolution 구조체 정의와 VideoMode클래스 정의는 Resolution 또는 VideoMode의 모양만 설명 합니다

They themselves don’t describe a specific resolution or video mode.

그들 자체는 특정 해상도나 비디오 모드를 설명하지 않습니다.

To do that, you need to create an instance of the structure or class.

그렇게 하려면 구조체나 클래스의 인스턴스를 만들어야 합니다.

The syntax for creating instances is very similar for both structures and classes:

인스턴스를 생성하는 구문은 구조체와 클래스 모두에서 매우 유사 합니다.

let someResolution = Resolution()
let someVideoMode = VideoMode()

Structures and classes both use initializer syntax for new instances.

구조체와 클래스는 모두 새 인스턴스에 대해 이니셜라이저 구문을 사용 합니다.

The simplest form of initializer syntax uses the type name of the class or structure followed by empty parentheses, such as Resolution() or VideoMode().

이니셜라이저 구문의 가장 간단한 형식은 Resolution() 또는 VideoMode()와 같이 빈 괄호 뒤에 오는 클래스 또는 구조체의 유형 이름을 사용 합니다.

This creates a new instance of the class or structure, with any properties initialized to their default values.

그러면 프로퍼티 기본값으로 초기화된 클래스 또는 구조체의 새 인스턴스가 생성 됩니다.

Class and structure initialization is described in more detail in Initialization.

클래스 및 구조체 이니셜라이즈는 이니셜라이즈에서 자세히 설명 합니다.

Accessing Properties

You can access the properties of an instance using dot syntax.

점 구문을 사용하여 인스턴스의 프로퍼티에 액세스 할 수 있습니다.

In dot syntax, you write the property name immediately after the instance name, separated by a period (.), without any spaces:

점 구문에서는 공백 없이 마침표(.)로 구분하여 인스턴스 이름 바로 뒤에 프로퍼티 이름을 작성 합니다

print("The width of someResolution is \(someResolution.width)")
// Prints "The width of someResolution is 0"

In this example, someResolution.width refers to the width property of someResolution, and returns its default initial value of 0.

이 예제에서 someResolution.width는 someResolution의 너비 프로퍼티을 참조하고 기본 초기 값인 0을 반환 합니다

You can drill down into subproperties, such as the width property in the resolution property of a VideoMode:

VideoMode의 resolution 프로퍼티에 있는 width 프로퍼티와 같은 하위 프로퍼티으로 드릴다운(문제를 여럿으로 세분화하면서 분석하는 기법) 할 수 있습니다.

print("The width of someVideoMode is \(someVideoMode.resolution.width)")
// Prints "The width of someVideoMode is 0"

You can also use dot syntax to assign a new value to a variable property:

점 구문을 사용하여 변수 프로퍼티에 새 값을 할당할 수 있습니다.

someVideoMode.resolution.width = 1280
print("The width of someVideoMode is now \(someVideoMode.resolution.width)")
// Prints "The width of someVideoMode is now 1280"

Memberwise Initializers for Structure Types

All structures have an automatically generated memberwise initializer, which you can use to initialize the member properties of new structure instances.

모든 구조에는 자동으로 생성된 멤버별 이니셜라이저가 있어 새 구조체 인스턴스의 멤버 프로퍼티를 초기화하는데 사용할 수 있습니다.

Initial values for the properties of the new instance can be passed to the memberwise initializer by name:

새 인스턴스의 프로퍼티에 대한 초기 값은 이름으로 멤버별 이니셜라이저에 전달할 수 있습니다.

let vga = Resolution(width: 640, height: 480)

Unlike structures, class instances don’t receive a default memberwise initializer. Initializers are described in more detail in Initialization.

구조체와 달리 클래스 인스턴스는 기본 멤버별 이니셜라이저를 받지 않습니다.

Unlike structures, class instances don’t receive a default memberwise initializer. Initializers are described in more detail in Initialization.

이니셜라이저는 초기화에 자세히 설명되어 있습니다.

Structures and Enumerations Are Value Types

A value type is a type whose value is copied when it’s assigned to a variable or constant, or when it’s passed to a function.

값 유형은 변수나 상수에 할당되거나 함수에 전달될 때 값이 복사되는 유형 입니다.

You’ve actually been using value types extensively throughout the previous chapters.

실제로 이전 장에서 값 유형을 광범위하게 사용했습니다.

In fact, all of the basic types in S₩wift—integers, floating-point numbers, Booleans, strings, arrays and dictionaries—are value types, and are implemented as structures behind the scenes.

사실, Swift의 모든 기본 유형(정수, 부동 소수점 숫자, Bool, 문자열, 배열 및 사전)은 값 유형이며 후엔 구조로 구현 됩니다.

All structures and enumerations are value types in Swift.

모든 구조와 열거형은 Swift의 값 유형 입니다.

This means that any structure and enumeration instances you create—and any value types they have as properties—are always copied when they’re passed around in your code.

즉, 생성한 모든 구조 및 열거형 인스턴스와 속성으로 포함된 모든 값 유형은 코드에서 전달될 때 항상 복사 됩니다.

💡NOTE
Collections defined by the standard library like arrays, dictionaries, and strings use an optimization to reduce the performance cost of copying.
Instead of making a copy immediately, these collections share the memory where the elements are stored between the original instance and any copies.
If one of the copies of the collection is modified, the elements are copied just before the modification.
The behavior you see in your code is always as if a copy took place immediately.

💡노트
배열, 사전 및 문자열과 같은 표준 라이브러리에 의해 정의된 컬렉션은 복사의 성능 비용을 줄이기 위해 최적화를 사용 합니다.
즉시 복사본을 만드는 대신 이러한 컬렉션은 원본 인스턴스와 복사본 간에 요소가 저장되는 메모리를 공유 합니다.
컬렉션 복사본 중 하나가 수정되면 수정 직전의 요소가 복사 됩니다.
코드에서 볼 수 있는 동작은 복사가 즉시 발생한 것처럼 보입니다.

Consider this example, which uses the Resolution structure from the previous example:

이전 예제의 Resolution 구조를 사용하는 다음 예제를 고려해봅시다.

let hd = Resolution(width: 1920, height: 1080)
var cinema = hd

This example declares a constant called hd and sets it to a Resolution instance initialized with the width and height of full HD video (1920 pixels wide by 1080 pixels high).

이 예제는 hd라는 상수를 선언하고 풀 HD 비디오(폭1920 x 높이 1080)의 너비와 높이로 초기화 된 Resolution 인스턴스로 설정 합니다.

It then declares a variable called cinema and sets it to the current value of hd.

그런 다음 시네마라는 변수를 선언하고 hd의 현재 값으로 설정 합니다.

Because Resolution is a structure, a copy of the existing instance is made, and this new copy is assigned to cinema.

Resolution은 구조이기 때문에 기존 인스턴스의 복사본이 만들어지고 이 새 복사본이 cinema에 할당 됩니다.

Even though hd and cinema now have the same width and height, they’re two completely different instances behind the scenes.

이제 hd와 cinema의 너비와 높이가 동일하지만, 씬 뒤에서 완전히 다른 두 인스턴스 입니다

Next, the width property of cinema is amended to be the width of the slightly wider 2K standard used for digital cinema projection (2048 pixels wide and 1080 pixels high):

다음으로, cinema의 너비 프로퍼티는 디지털 시네마 프로젝션에 사용되는 약간 더 넓은 2K표준의 너비로 수정 됩니다.(2048픽셀 너비 및 1080 픽셀 높이)

cinema.width = 2048

Checking the width property of cinema shows that it has indeed changed to be 2048:

cinema의 width 프로퍼티를 확인하면 실제로 2048로 변경되었음을 알 수 있습니다.

print("cinema is now \(cinema.width) pixels wide")
// Prints "cinema is now 2048 pixels wide"

However, the width property of the original hd instance still has the old value of 1920:

그러나 원래 hd인스턴스의 너비 프로퍼티에는 여전히 1920의 이전 값이 있습니다.

print("hd is still \(hd.width) pixels wide")
// Prints "hd is still 1920 pixels wide"

When cinema was given the current value of hd, the values stored in hd were copied into the new cinema instance.

cinema에 현재 hd 값이 주어지면 hd에 저장된 값이 새 cinema 인스턴스에 복사 됩니다

The end result was two completely separate instances that contained the same numeric values.

최종 결과는 동일한 숫자 값을 포함하는 완전히 별개의 두 인스턴스였습니다.

However, because they’re separate instances, setting the width of cinema to 2048 doesn’t affect the width stored in hd, as shown in the figure below:

그러나 별개의 인스턴스이기 때문에 아래 그림과 같이 cienma 너비를 2048로 설정해도 hd에 저장된 너비에는 영향을 미치지 않습니다.

The same behavior applies to enumerations:

열거형에도 동일한 동작이 적용 됩니다.

enum CompassPoint {
    case north, south, east, west
    mutating func turnNorth() {
        self = .north
    }
}
var currentDirection = CompassPoint.west
let rememberedDirection = currentDirection
currentDirection.turnNorth()

print("The current direction is \(currentDirection)")
print("The remembered direction is \(rememberedDirection)")
// Prints "The current direction is north"
// Prints "The remembered direction is west"

When rememberedDirection is assigned the value of currentDirection, it’s actually set to a copy of that value.

rememberedDirection에 currentDirection 값이 할당 되면 실제로 해당 값의 복사본으로 설정 됩니다.

Changing the value of currentDirection thereafter doesn’t affect the copy of the original value that was stored in rememberedDirection.

그 이후에 currentDirection의 값을 변경해도 rememberDirection에 저장된 원래 값의 복사본에는 영향을 미치지 않습니다

Classes Are Reference Types(클래스는 참조 유형)

Unlike value types, reference types are not copied when they’re assigned to a variable or constant, or when they’re passed to a function.

값 유형과 달리 참조 유형은 변수나 상수에 할당되거나 함수에 전달될 때 복사되지 않습니다.

Rather than a copy, a reference to the same existing instance is used.

복사본 대신 동일한 기존 인스턴스에 대한 참조가 사용됩니다.

Here’s an example, using the VideoMode class defined above:

다음 예제에서는 위에서 정의한 VideoMode클래스를 사용하는 예 입니다.

let tenEighty = VideoMode()
tenEighty.resolution = hd
tenEighty.interlaced = true
tenEighty.name = "1080i"
tenEighty.frameRate = 25.0

This example declares a new constant called tenEighty and sets it to refer to a new instance of the VideoMode class.

이 예제에서는 tenEighty라는 새 상수를 선언하고 VideoMode 클래스의 새 인스턴스를 참조하도록 설정 합니다

The video mode is assigned a copy of the HD resolution of 1920 by 1080 from before.

비디오 모드에는 이전의 1920 x 1080 HD 해상도 사본이 할당 됩니다.

It’s set to be interlaced, its name is set to "1080i", and its frame rate is set to 25.0 frames per second.

인터레이스로 설정되고 이름은 "1080i"로 설정되면 프레임 속도는 초당 25.0프레임으로 설정 됩니다.

Next, tenEighty is assigned to a new constant, called alsoTenEighty, and the frame rate of alsoTenEighty is modified:

다음으로, tenEighty는 alsoTenEighty라는 새로운 상수에 할당되고 alsoTenEighty의 프레임 속도는 수정 됩니다.

let alsoTenEighty = tenEighty
alsoTenEighty.frameRate = 30.0

Because classes are reference types, tenEighty and alsoTenEighty actually both refer to the same VideoMode instance.

클래스는 참조 유형이므로 tenEighty 및 alsoTenEighty는 실제로 동일한 VideoMode 인스턴스를 참조 합니다.

Effectively, they’re just two different names for the same single instance, as shown in the figure below:

사실상, 아래 그림과 같은 동일한 단일 인스턴스에 대한 두개의 다른 이름일 뿐 입니다

Checking the frameRate property of tenEighty shows that it correctly reports the new frame rate of 30.0 from the underlying VideoMode instance:

tenEighty의 frameRate 프로퍼티를 확인하면 기본 VideoMode 인스턴스에서 새 프레임 속도 30.0을 올바르게 보고한다는 것을 알 수 있습니다.

print("The frameRate property of tenEighty is now \(tenEighty.frameRate)")
// Prints "The frameRate property of tenEighty is now 30.0"

This example also shows how reference types can be harder to reason about.

이 예제는 또한 참조 유형이 어떻게 추론하기 더 어려울 수 있는지 보여 줍니다.

If tenEighty and alsoTenEighty were far apart in your program’s code, it could be difficult to find all the ways that the video mode is changed.

프로그램 코드에서 tenEighty와 alsoTenEighty가 멀리 떨어져 있으면 비디오 모드가 변경되는 모든 방법을 찾기 어려울 수 있습니다.

Wherever you use tenEighty, you also have to think about the code that uses alsoTenEighty,

tenEighty를 사용하는 곳마다, alsoTenEighty를 사용하는 코드에 대해서도 생각해야 합니다.

and vice versa. In contrast, value types are easier to reason about because all of the code that interacts with the same value is close together in your source files.

그 반대로, 대조적으로 값 유형은 동일한 값과 상호 작용하는 모든 코드가 소스 파일에서 함께 가깝기 때문에 추론하기가 더 쉽습니다.

Note that tenEighty and alsoTenEighty are declared as constants, rather than variables.

tenEighty 및 alsoTenEighty는 변수가 아닌 상수로 선언 됩니다.

However, you can still change tenEighty.

그러나 여전히 tenEighty를 변경할 수 있습니다.

frameRate and alsoTenEighty.

frameRate 및 또한 TenEighty

frameRate because the values of the tenEighty and alsoTenEighty constants themselves don’t actually change.

tenEighty 및 alsoTenEighty 상수 자체의 값은 실제로 변경되지 않기 때문에 frameRate 입니다.

tenEighty and alsoTenEighty themselves don’t “store” the VideoMode instance—instead, they both refer to a VideoMode instance behind the scenes.

tenEighty 및 alsoTenEighty 자체는 VideoMode 인스턴스를 "저장" 하지 않고, 둘 다 장면 뒤에서 VideoMode 인스턴스를 참조 합니다.

It’s the frameRate property of the underlying VideoMode that’s changed, not the values of the constant references to that VideoMode.

변경된 것은 해당 VideoMode에 대한 상수 참조 값이 아니라 기본 VideoMode의 frameRate 프로퍼티 입니다.

Identity Operators

Because classes are reference types, it’s possible for multiple constants and variables to refer to the same single instance of a class behind the scenes.

클래스는 참조 유형이기 때문에 여러 상수와 변수가 뒤에서 클래스의 동일한 단일 인스턴스를 참조할 수 있습니다.

(The same isn’t true for structures and enumerations, because they’re always copied when they’re assigned to a constant or variable, or passed to a function.)

(구조체 및 열거형의 경우네는 동일하지 않습니다. 상수 또는 변수에 할당되거나 함수에 전달될 때 항상 복사되기 때문 입니다.)

It can sometimes be useful to find out whether two constants or variables refer to exactly the same instance of a class.

두 개의 상수 또는 변수가 클래스의 정확히 동일한 인스턴스를 참조하는지 여부를 찾는 것이 때때로 유용할 수 있습니다.

To enable this, Swift provides two identity operators:

이를 활성화하기 위해 Swift는 두 가지 ID연산자를 제공 합니다.

It can sometimes be useful to find out whether two constants or variables refer to exactly the same instance of a class.

두 개의 상수 또는 변수가 클래스의 정확히 동일한 인스턴스를 참조하는지 여부를 찾는 것이 때때로 유용할 수 있습니다.

To enable this, Swift provides two identity operators:

이를 활성화하기 위해 Swift는 두 가지 ID 연산자를 제공 합니다.

• Identical to (===)

• Not identical to (!==)

Use these operators to check whether two constants or variables refer to the same single instance:

다음 연산자를 사용하여 두 개의 상수 또는 변수가 동일한 단일 인스턴스를 참조하는지 확인 합니다.

if tenEighty === alsoTenEighty {
    print("tenEighty and alsoTenEighty refer to the same VideoMode instance.")
}
// Prints "tenEighty and alsoTenEighty refer to the same VideoMode instance."

Note that identical to (represented by three equals signs, or ===) doesn’t mean the same thing as equal to (represented by two equals signs, or ==).

same to(3개의 등호 또는 ===로 표시됨)는 equal to(2개의 등호 또는 ==로 표시됨)와 동일한 것을 의미하지 않습니다.

Identical to means that two constants or variables of class type refer to exactly the same class instance.

동일하다는 것은 클래스 유형의 두 상수 또는 변수가 정확히 동일한 클래스 인스턴스를 참조한다는 것을 의미 합니다.

Equal to means that two instances are considered equal or equivalent in value, for some appropriate meaning of equal, as defined by the type’s designer.

같음은 유형 디자이너가 정의한 같음의 적절한 의미에 대해 두 인스턴스가 값이 같거나 동등한 것으로 간주됨을 의미합니다.

When you define your own custom structures and classes, it’s your responsibility to decide what qualifies as two instances being equal.

고유한 사용자 정의 구조와 클래스를 정의할 때 두 인스턴스가 동일한 것으로 자격이 되는 항목을 결정하는 것은 개발자의 책임입니다.

The process of defining your own implementations of the == and != operators is described in Equivalence Operators.

== 및 != 연산자의 고유한 구현을 정의하는 프로세스는 등가 연산자에 설명되어 있습니다.

Pointers

If you have experience with C, C++, or Objective-C, you may know that these languages use pointers to refer to addresses in memory.

C, C++ 또는 Objective-C에 대한 경험이 있는 경우 이러한 언어가 포인터를 사용하여 메모리의 주소를 참조 한다는 것을 알 수 있습니다.

A Swift constant or variable that refers to an instance of some reference type is similar to a pointer in C,

어떤 참조 유형의 인스턴스를 참조하는 Swift 상수 또는 변수는 C의 포인터와 유사합니다.

but isn’t a direct pointer to an address in memory, and doesn’t require you to write an asterisk (*) to indicate that you are creating a reference.

그러나 메모리의 주소에 대한 직접적인 포인터가 아니며 참조를 생성하고 있음을 나타내기 위해 별표(*)를 작성할 필요가 없습니다.

Instead, these references are defined like any other constant or variable in Swift.

대신 이러한 참조는 Swift의 다른 상수 또는 변수처럼 정의 됩니다.

The standard library provides pointer and buffer types that you can use if you need to interact with pointers directly—see Manual Memory Management.

표준 라이브러리는 포인터와 직접 상호 작용해야 하는 경우 사용할 수 있는 포인터 및 버퍼 유형을 제공 합니다.
수동 메모리 관리 참조.