How to create a Struct Instance Using a Struct Literal in Golang?

A structure or struct in Golang is a user-defined data type which is a composition of various data fields. Each data field has its own data type, which can be a built-in or another user-defined type. Struct represents any real-world entity which has some set of properties/fields.

For Example, a student has a name, roll number, city, department. It makes sense to group these four properties into a single structure address as shown below.

type Student struct {
      name string 
      roll_no int
      city string
      department string
}

Syntax for declaring a structure:

var x Student

The above code creates a variable of type Student in which fields by default are set to their respective zero values.

Since struct is a composite data type, it is initialised using composite literals. Composite literals construct values for structs, arrays, slices, and maps where a single syntax is used for those types. Struct literals are used to create struct instances in Golang. You can create a struct instance using a struct literal as follows:



var d = Student{"Akshay", 1, "Lucknow", "Computer Science"}

We can also use a short declaration operator.

d := Student{"Akshay", 1, "Lucknow", "Computer Science"} 

You must keep the following rules in mind while creating a struct literal:

  1. A key must be a field name declared in the struct type.
  2. An element list that does not contain any keys must list an element for each struct field in the order in which the fields are declared.
  3. An element list that contains keys does not need to have an element for each struct field. Omitted fields get the zero value for that field.
  4. A literal may omit the element list; such a literal evaluates to the zero value for its type.
  5. It is an error to specify an element for a non-exported field of a struct belonging to a different package.

Example 1:

filter_none

edit
close

play_arrow

link
brightness_4
code

// Golang program to show how to
// declare and define the struct
// using struct literal
package main
  
// importing required modules
import "fmt"
  
// Defining a struct type
type Student struct {
    name       string
    roll_no    int
    city       string
    department string
}
  
func main() {
  
    // Declaring a variable of a `struct` type
    // All the struct fields are initialized
    // with their zero value
    var x Student
    fmt.Println("Student0:", x)
  
    // Declaring and initializing a
    // struct using a struct literal
    // Fields should be initialised in
    // the same order as they are declared
    // in struct's definition
    x1 := Student{"Akshay", 1, "Lucknow", "Computer Science"}
      
    fmt.Println("Student1: ", x1)
  
    // You can specify keys for 
    // their respective values
    x2 := Student{name: "Anita", roll_no: 2, 
     city: "Ballia", department: "Mechanical"}
      
    fmt.Println("Student2: ", x2)
}

chevron_right


Output:

Student0: { 0  }
Student1:  {Akshay 1 Lucknow Computer Science}
Student2:  {Anita 2 Ballia Mechanical}

Uninitialized fields are set to their corresponding zero-values.

Example 2:

filter_none

edit
close

play_arrow

link
brightness_4
code

// Golang program illustrating
// the use of string literals
package main
  
// importing required modules
import "fmt"
  
// Defining a struct type
type Address struct {
    name, city string
    Pincode    int
}
  
func main() {
    add1 := Address{name: "Ram"}
    fmt.Println("Address is:", add1)
}

chevron_right


Output:

Address is: {Ram  0}

It must be noted that uninitialized values are set to zero values when field:value initializer is used during instantiation. The following code will output an error.

Example:

filter_none

edit
close

play_arrow

link
brightness_4
code

// Golang program illustrating
// the use of string literals
package main
  
// importing required modules
import "fmt"
  
// Defining a struct type
type Address struct {
    name, city string
    Pincode    int
}
  
func main() {
    add1 := Address{"Ram"}
    fmt.Println("Address is: ", add1)
}

chevron_right


Output:

Compilation Error: too few values in Address literal

If you specify least one key for an element, then you must specify all the other keys as well.

Example:

filter_none

edit
close

play_arrow

link
brightness_4
code

package main
  
// importing required modules
import "fmt"
  
// Defining a struct type
type Address struct {
    name, city string
    Pincode    int
}
  
func main() {
    // Only 1 key is specified here
    add1 := Address{name: "Ram", "Mumbai", 221007}
    fmt.Println("Address is: ", add1)
}

chevron_right


Output:

Compilation Error: mixture of field:value and value initializers

The above program throws an error as we have specified key for only one element and that creates a mixture of the field:value and value initializers. We should either go with the field:value or value initializers.




My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.


Article Tags :

Be the First to upvote.


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.