Swift Structures
Last Updated :
05 Dec, 2022
A structure is a general-purpose building block of any code and stores variables of different data types under a single unit. Just like other programming languages in Swift you can also define the properties and methods into a structure, where the properties are the set of constants or variables that are stored as part of the structure. Also, there is no need to create any separate interface to implement the structure, you can define the structure in a single file and then the external interface will automatically use the structure.
In Swift, a structure is a value type. Value type means a type whose value is copied whenever it is assigned to a variable or a constant or passed to a function, so we can say that whenever an instance of the structure is created and any value types that the properties have can be copied whenever they are passed in the code and whenever we define a new structure then that means we define a new data type. We can use structure to encapsulate simple data values, and also can copy the encapsulated data and the related properties by their values, not by the reference. Using structure we can also create our own types which have their own methods and properties. We can simply create a structure using the struct keyword.
Syntax:
struct nameOfStructure{
// structure properties and methods
}
Example:
Swift
import Swift
struct geeksforgeeks{
var employeeName = "Mohit"
var employeeID = 1234
var employeeDepartment = "HR"
var joiningYear = 2019
}
|
Structure Instance
Just like a class in Swift, we can also create an instance of the structure, and using this instance we can access the properties and methods of the structure. The structure also uses initializer syntax to create an instance. It is the easiest and most efficient way to create an instance of the structure. You need to simply write the name of the structure followed by empty parentheses, for example, geeksforgeeks(). Using a single instance, we can access all the properties and methods of a structure along with their values and a single structure can contain multiple instances.
Syntax:
let instanceName = StructureName()
Example:
Swift
import Swift
struct geeksforgeeks{
var employeeName = "Mohit"
var employeeID = 1234
var employeeDepartment = "HR"
var joiningYear = 2019
}
var myinstance = geeksforgeeks()
|
Accessing the Structure Properties
We can access the properties of the structure using the instance of the structure followed by a dot and the name of the property. Also using this syntax we can access the sub-properties of the structure. This syntax is also used to assign value to the specified property or to the sub-property.
Syntax:
// For accessing property
instanceName.PropertyName
// For accessing sub-property
instanceName.PropertyName.subPropertyName
// For assigning value to the property
instanceName.PropertyName = 23
Example:
Swift
import Swift
struct geeksforgeeks{
var employeeName = "Mohit"
var employeeID = 1234
var employeeDepartment = "HR"
var joiningYear = 2019
}
var myinstance = geeksforgeeks()
print ( "Employee Name:" , myinstance.employeeName)
print ( "Joining Year:" , myinstance.joiningYear)
|
Output:
Employee Name: Mohit
Joining Year: 2019
Memberwise Initializers
Structure always generates a memberwise initializer automatically, it is also known as the default initializer. So without wasting time, you can easily use these memberwise initializers to initialize the properties of a new structure instance. Or we can say if the property of the structure is not initialized with any initial value then using memberwise initializers we can initialize the property with the initial value. And we can also use memberwise initializers if the property contains the initial value.
Syntax:
let varName = structureName(propertyName1: Value, propertyName2: Value)
Example:
Swift
import Swift
struct geeksforgeeks{
var employeeName = "Mohit"
var employeeID = 1234
var employeeDepartment = "HR"
var joiningYear = 2019
}
var myinstance = geeksforgeeks()
print ( "Employee Id before updating:" , myinstance.employeeID)
var newdata = geeksforgeeks(employeeID: 234)
print ( "Employee Id after updating:" , newdata.employeeID)
print ( "________________________________" )
struct employeeDetail{
var age : Int
var contact : Int
}
var empinstance = employeeDetail(age: 24, contact: 7777777777)
print ( "Employee Age: " , empinstance.age)
print ( "Employee Contact: " , empinstance.contact)
|
Output:
Employee Id before updating: 1234
Employee Id after updating: 234
________________________________
Employee Age: 24
Employee Contact: 77777777
Function Inside Structure
A structure can also contain functions. When a function is defined inside a structure then that function is called a method. The method can use the properties of the structure. To access the function we can use the dot syntax. As shown in the below example, where we created an increment() method in the geeksforgeeks structure to find the increment in the salary of the employee and then access that method using dot syntax.
Syntax:
struct nameOfStructure{
func functionName(){
// Function Body
}
}
In Swift, you are generally not allowed to write methods that change the properties, but you can specially request them. If you want to change the property present inside the method then you need to declare that function using the mutating keyword.
Syntax:
struct nameOfStructure{
mutating func functionName(){
// Function Body
}
}
Example:
Swift
import Swift
struct geeksforgeeks{
var salary = 230000
func increment(){
let newsalary = 2 * salary
print ( "New salary: " , newsalary)
}
}
var myinstance = geeksforgeeks()
myinstance.increment()
|
Output:
New salary: 460000
Using self in the structure
Sometimes in a structure, the name of the method parameter is the same as the property, so the compiler does not get the right context that you want to operate on the property or on the method parameter. So to overcome this kind of situation we use the self keyword. We generally use the self keyword with the property because the parameter name automatically takes higher precedence. Using the self keyword the compiler can easily distinguish between the name of the parameter and property. When we are working with the self keyword which means we are explicitly accessing the current value of the named type, it is exactly equal to the instance itself, so you are allowed to use the self property to refer to the current object within its own object method. Self keyword is generally useful in initializers, when two variables of the same name are present in the same scope and you want to assign a new value to the property, not to the parameter, in that case, you can use the self keyword before the property name using dot syntax.
Syntax:
self.propertyName
Example:
Swift
import Swift
struct geeksforgeeks{
var article = 230
func update(article: Int = 23){
let updatedData1 = article + 234
print ( "Updated Data 1: " , updatedData1)
let updatedData2 = self .article + 234
print ( "Updated Data 2: " , updatedData2)
}
}
var myinstance = geeksforgeeks()
myinstance.update()
|
Output:
Updated Data 1: 257
Updated Data 2: 464
Share your thoughts in the comments
Please Login to comment...