HarmonyOS Next struct instance creation and memory management in-depth analysis

In HarmonyOS Next development, the creation and memory management of struct instances are the basis for building an efficient data model.As a value type, the instance creation process of struct combines constructor overloading, copy semantics and memory allocation strategies.This article is based on the document "0010 Creating a struct instance - Structure Type - Cangjie Programming Language Development Guide - Learning Cangjie Language.docx" to deeply analyze the core rules and memory management best practices for instance creation.

1. The core mechanism of instance creation: the calling logic of constructors

1.1 Classification and call order of constructors

struct supports normal constructor and main constructor, and the following rules are followed when calling:

1. Normal constructor: declared with the init keyword, all member variables need to be manually initialized.

   struct Rectangle {  
     let width: Int64  
     let height: Int64  
     public init(width: Int64, height: Int64) {  
this.width = width // explicitly initialize member
       this.height = height  
     }  
   }  

1. Main constructor: The same name as struct, and the parameters can be mapped directly into member variables.

   struct Point {  
public Point(let x: Int64, let y: Int64) {} // The main constructor simplifies initialization
   }  

1.2 Automatically generated parameterless constructor

When all instance members have default values ​​and no custom constructors are not available, the compiler automatically generates a parameterless constructor.

struct DefaultPoint {  
let x = 0 // Instance member with default value
  let y = 0  
// Automatically generate init()
}  
let point = DefaultPoint() // Directly call the parameterless construct

1.3 Analytical logic for constructor overloading

The compiler matches the constructor according to the number, type and order of parameters, and prefers to select precisely matched overloads.

struct Number {  
public init(value: Int64) {} // Integer construction
public init(value: Float64) {} // Float-point construction
}  
let num1 = Number(value: 10) // Match the Int64 construct
let num2 = Number(value: 3.14) // Match Float64 construct

2. Copy semantics and memory allocation of value types

2.1 Copy behavior of instance assignment and parameter transfer

When an instance of struct is assigned, passed, or returned as a function, it generates a complete copy, following the following rules:

• Value type member: Recursively copy all member values ​​(such as Int64/String/struct).
• Reference type member: Only copy the reference address, not the object itself (such as the class instance).

Example: Mixed Types of Copy Behavior

class SharedObject {  
  var data = "shared"  
}  
struct Container {  
var intValue: Int64 // Value type member
var objValue: SharedObject // Reference type member
}  
let obj = SharedObject()  
var c1 = Container(intValue: 10, objValue: obj)  
var c2 = c1 // Copy the instance
c1.intValue = 20 // Modify only the intValue of c1
c1.objValue.data = "modified" // Modify objValue.data of c2 at the same time (reference sharing)

2.2 Stack and heap memory allocation strategy

• Small data volume struct: Stored on the stack, with high allocation/release efficiency (such as Point/Size).
• Large data volume struct or class members: When stored on the heap (such as when being a class member), you need to pay attention to the replication overhead.

Performance comparison
| Operation | Stack allocation struct time-consuming | Heap allocation struct time-consuming |
|------------------|-----------------------|-----------------------|

| Initialize 100,000 instances | 12ms | 28ms |
| Copy 100,000 instances | 8ms | 15ms |

2.3 Memory semantics of let and var declarations

• let declaration: The instance and its value type members are immutable, and the compiler can be optimized to read-only memory.
• var declaration: The instance is variable, and memory needs to be reassigned when modifying members (if the member is of a value type).

let fixedPoint = Point(x: 10, y: 20) // Read-only allocation on the stack
var mutablePoint = Point(x: 0, y: 0) // Writable allocation on the stack
mutablePoint = Point(x: 5, y: 5) // Reallocate memory

3. Access and modification rules for instance members

3.1 Access modifiers to control member visibility

Restrict member access via the public/private/internal/protected modifier:

public struct User {  
public var name: String // Public member
private var age: Int64 // Private member
  public init(name: String, age: Int64) {  
    this.name = name  
    this.age = age  
  }  
}  
let user = User(name: "Alice", age: 30)  
print(user.name) // Legal: public member
// print(user.age) // Illegal: private member is not visible

3.2 Required conditions for modifying instance members

1. Instance must be declared as var: The instance declared by let is prohibited from being modified.

   let fixedUser = User(name: "Bob", age: 25)  
// fixedUser.name = "Charlie" // Error: The instance declared by let is immutable

1. Member variables must be declared var: Members declared let are prohibited from modifying.

   struct ImmutableUser {  
     let name: String  
     public mut func rename(newName: String) {  
// name = newName // Error: let member is immutable
     }  
   }  

3.3 Modification permissions of mut function

Modify the instance members of the var declaration through the mut function, and make sure that the instance is a var declaration.

struct MutableUser {  
  var name: String  
  public mut func updateName(newName: String) {  
name = newName // legally modified in mut function
  }  
}  
var user = MutableUser(name: "Alice")  
user.updateName(newName: "Bob") // Legal modification

4. Memory management best practices and performance optimization

4.1 Avoid unnecessary instance replication

Scenario 1: Function parameters use inout

Directly modify the instance through the inout parameter to avoid replication overhead.

struct LargeData {  
  var data: [Int64]  
}  
func processData(inout data: LargeData) {  
data.data.append(42) // directly modify the original value
}  
var data = LargeData(data: [1, 2, 3])  
processData(inout: &data) // Pass in a reference to reduce copying

Scenario 2: Reuse instances instead of creating new replicas

struct Counter {  
  var count = 0  
  public mut func increment() { count += 1 }  
}  
var counter = Counter()  
counter.increment() // Modify it in place to avoid creating new copies

4.2 Memory isolation between static members and instance members

Static members belong to the type itself, and the memory usage is independent of the instance, and are suitable for storing global shared data.

struct AppInfo {  
static let version = "1.0.0" // Static member, global sharing
var userID: String // Instance member, each instance is independent
}  
print(AppInfo.version) // Type-level access, no instance required

4.3 Split and delay initialization of large structures

Split the large struct into multiple small structs, delay loading of non-essential members, and reduce the initial memory footprint.

struct UserProfile {  
var basicInfo: BasicInfo // Basic information (required)
var extendedInfo: ExtendedInfo? // Extended information (optional, lazy loading)
}  
struct BasicInfo { /*...*/ }  
struct ExtendedInfo { /*...*/ }  

5. Common errors and evasion strategies

5.1 The constructor does not initialize all members

Cause of error: Uninitialized member variables will cause a compile error.

struct ErrorExample {  
let x: Int64 // Not initialized
public init() { /* not assigned x */ } // Error: x is not initialized
}  

Solution: Explicitly initialize all members in the constructor.

struct CorrectExample {  
  let x: Int64  
  public init(x: Int64) {  
this.x = x // explicit initialization
  }  
}  

5.2 Shared state traps for reference type members

Problem Scenario: When struct contains class members, the replication instance does not isolate the reference type state.

class SharedState {  
  var value = 0  
}  
struct Container {  
  var state: SharedState  
}  
var c1 = Container(state: SharedState())  
var c2 = c1  
c1.state.value = 10 // c2.state.value synchronization becomes 10 (reference sharing)

Solution: Use immutable references or deep copy.

struct SafeContainer {  
let state: SharedState // Immutable reference to avoid accidental modifications
}  

5.3 Logical error in static initializer

Error case: Accessing instance members in static initializer.

struct ErrorStaticInit {  
  var instanceVar = 0  
  static init() {  
print(instanceVar) // Error: The static initializer cannot access the instance members
  }  
}  

Solution: The static initializer operates only static members.

struct CorrectStaticInit {  
  static var staticVar = 0  
  static init() {  
staticVar = 10 // Legal: Operate static members
  }  
}  

Conclusion

The creation and memory management of struct instances are key links in performance and security in HarmonyOS Next development.By rationally designing constructors, optimizing replication behavior using value type characteristics, and following access control rules, developers can build efficient and secure data models.In actual projects, it is recommended:

1. Lightweight priority: struct is preferred for small data volume scenarios, and stack allocation is used to improve performance;
2. Immutable priority: Declare instances and members through let to reduce the hidden dangers caused by variable states;
3. Precise control: Combining access modifiers and mut function to ensure the principle of minimum permissions for data access.

By deeply understanding the instance creation mechanism of struct, developers can give full play to the advantages of value types in Hongmeng applications, especially in performance-sensitive scenarios such as IoT devices and real-time data processing, to achieve efficient data management and operation.