GeeksforGeeks App
Open App
Browser
Continue

# Structures in Golang

A structure or struct in Golang is a user-defined type that allows to group/combine items of possibly different types into a single type. Any real-world entity which has some set of properties/fields can be represented as a struct. This concept is generally compared with the classes in object-oriented programming. It can be termed as a lightweight class that does not support inheritance but supports composition. For Example, an address has a name, street, city, state, Pincode. It makes sense to group these three properties into a single structure address as shown below.

Declaring a structure:

``` type Address struct {
name string
street string
city string
state string
Pincode int
}```

In the above, the type keyword introduces a new type. It is followed by the name of the type (Address) and the keyword struct to illustrate that we’re defining a struct. The struct contains a list of various fields inside the curly braces. Each field has a name and a type.

Note: We can also make them compact by combining the various fields of the same type as shown in the below example:

```type Address struct {
name, street, city, state string
Pincode int
}```

To Define a structure: The syntax for declaring a structure:

`var a Address`

The above code creates a variable of a type Address which is by default set to zero. For a struct, zero means all the fields are set to their corresponding zero value. So the fields name, street, city, state are set to “”, and Pincode is set to 0. You can also initialize a variable of a struct type using a struct literal as shown below:

`var a = Address{"Akshay", "PremNagar", "Dehradun", "Uttarakhand", 252636}`

Note:

• Always pass the field values in the same order in which they are declared in the struct. Also, you can’t initialize only a subset of fields with the above syntax.
• Go also supports the name: value syntax for initializing a struct (the order of fields is irrelevant when using this syntax). And this allows you to initialize only a subset of fields. All the uninitialized fields are set to their corresponding zero value. Example:

var a = Address{Name:”Akshay”, street:”PremNagar”, state:”Uttarakhand”, Pincode:252636} //city:””

## Go

 `// Golang program to show how to``// declare and define the struct` `package` `main` `import` `"fmt"` `// Defining a struct type``type Address ``struct` `{``    ``Name    ``string``    ``city    ``string``    ``Pincode int``}` `func` `main() {` `    ``// Declaring a variable of a `struct` type``    ``// All the struct fields are initialized``    ``// with their zero value``    ``var` `a Address``    ``fmt.Println(a)` `    ``// Declaring and initializing a``    ``// struct using a struct literal``    ``a1 := Address{"Akshay", "Dehradun", ``3623572``}` `    ``fmt.Println("Address1: ", a1)` `    ``// Naming fields while``    ``// initializing a struct``    ``a2 := Address{Name: "Anikaa", city: "Ballia",``                                 ``Pincode: ``277001``}` `    ``fmt.Println("Address2: ", a2)` `    ``// Uninitialized fields are set to``    ``// their corresponding zero-value``    ``a3 := Address{Name: "Delhi"}``    ``fmt.Println("Address3: ", a3)``}`

Output:

```{  0}

### How to access fields of a struct?

To access individual fields of a struct you have to use dot (.) operator.

Example:

## Go

 `// Golang program to show how to``// access the fields of struct``package` `main` `import` `"fmt"` `// defining the struct``type Car ``struct` `{``    ``Name, Model, Color ``string``    ``WeightInKg         ``float64``}` `// Main Function``func` `main() {``    ``c := Car{Name: "Ferrari", Model: "GTC4",``            ``Color: "Red", WeightInKg: ``1920``}` `    ``// Accessing struct fields``    ``// using the dot operator``    ``fmt.Println("Car Name: ", c.Name)``    ``fmt.Println("Car Color: ", c.Color)` `    ``// Assigning a new value``    ``// to a struct field``    ``c.Color = "Black"``    ` `    ``// Displaying the result``    ``fmt.Println("Car: ", c)``}`

Output:

```Car Name:  Ferrari
Car Color:  Red
Car:  {Ferrari GTC4 Black 1920}```

### Pointers to a struct

Pointers in Go programming language or Golang is a variable which is used to store the memory address of another variable. You can also create a pointer to a struct as shown in the below example:

## Go

 `// Golang program to illustrate``// the pointer to struct``package` `main` `import` `"fmt"` `// defining a structure``type Employee ``struct` `{``    ``firstName, lastName ``string``    ``age, salary int``}` `func` `main() {` `    ``// passing the address of struct variable``    ``// emp8 is a pointer to the Employee struct``    ``emp8 := &Employee{"Sam", "Anderson", ``55``, ``6000``}` `    ``// (*emp8).firstName is the syntax to access``    ``// the firstName field of the emp8 struct``    ``fmt.Println("First Name:", (*emp8).firstName)``    ``fmt.Println("Age:", (*emp8).age)``}`

Output:

```First Name: Sam
Age: 55```

The Golang gives us the option to use emp8.firstName instead of the explicit dereference (*emp8).firstName to access the firstName field. Example to show this is following:

## Go

 `// Golang program to illustrate``// the pointer to struct``package` `main` `import` `"fmt"` `// Defining a structure``type Employee ``struct` `{``    ``firstName, lastName ``string``    ``age, salary         int``}` `// Main Function``func` `main() {` `    ``// taking pointer to struct``    ``emp8 := &Employee{"Sam", "Anderson", ``55``, ``6000``}` `    ``// emp8.firstName is used to access``    ``// the field firstName``    ``fmt.Println("First Name: ", emp8.firstName)``    ``fmt.Println("Age: ", emp8.age)``}`

Output:

```First Name:  Sam
Age:  55```

In Go, a structure is a composite data type that groups together zero or more values of different types. Structures are defined using the type keyword, followed by the name of the new type, and the keyword struct. Here’s an example:

In this example, we define a new type Person that has three fields: Name of type string, Age of type int, and Address of type string. We can then create new instances of the Person type and set the values of its fields:

## Go

 `func` `main() {``    ``person := Person{``        ``Name:    ``"John Doe"``,``        ``Age:     ``30``,``        ``Address: ``"123 Main St"``,``    ``}``    ``fmt.Println(person)``}`

1. Output:

{John Doe 30 123 Main St}

### Advantages of using structures in Go:

1. Encapsulation: Structures allow you to encapsulate related data together, making it easier to manage and modify the data.
2. Code organization: Structures help to organize code in a logical way, which makes it easier to read and maintain.
3. Flexibility: Structures allow you to define custom types with their own behavior, making it easier to work with complex data.
4. Type safety: Structures provide type safety by allowing you to define the type of each field, which helps to prevent errors caused by assigning the wrong type of value.
5. Efficiency: Structures in Go are very efficient, both in terms of memory usage and performance.

### Disadvantages of using structures in Go:

1. Complexity: Structures can make code more complex, especially if the structures have a large number of fields or methods.
2. Boilerplate code: When defining large structures with many fields, it can be time-consuming to write out all of the field names and types.
3. Inheritance: Go does not support inheritance, which can make it more difficult to work with large hierarchies of related data.
4. Immutability: Go structures are mutable by default, which can make it more difficult to enforce immutability in your code.
5. Overall, the advantages of using structures in Go typically outweigh the disadvantages, as they provide a powerful tool for managing and working with complex data. However, as with any programming technique, it’s important to use structures judiciously and be aware of their limitations.

### Here are some important points about structures in Go:

1. Structures are composite data types that allow you to group together related data of different types.
2. In Go, structures are defined using the type keyword, followed by the name of the new type, and the keyword struct.
3. Structures can have fields that are of any type, including other structures.
4. Fields can be accessed using the dot . operator.
5. Structures in Go can also have methods associated with them.
6. Methods can be defined on structures using the receiver syntax.
7. Structures can be used to create custom types that encapsulate related data and behavior.
8. Go structures are mutable by default, but you can create immutable structures by using pointers or methods that return a new instance of the structure.
9. Structures in Go are very efficient in terms of both memory usage and performance.
10. Go does not support inheritance, but you can use composition to achieve similar results.

Overall, structures in Go are a powerful tool for managing and working with complex data. By grouping related data together and associating behavior with it, you can create custom types that are more expressive and easier to work with.

My Personal Notes arrow_drop_up