Inhalte

• Home
  • License Agreement
  • Introduction
  • IDE Settings
  • Project
  • Repository
  • Comments
  • reStructuredText
  • Naming
  • Formatting
    • Formatting Structured Text and Extended Structured Text ExST
    • Formatting SFC
  • Practices
    • Practices Introduction
    • Common Practices
      • Common Practices Interfaces
      • Common Practices Data Structures vs Objects
      • Common Practices Inheritance
      • Common Practices Dependencies
        • Common Practices Dependencies Examples
          • Common Practices Dependencies Examples Dependency Injection
            • Dependency Injection Introduction
            • Dependency Injection Common Interfaces
            • Dependency Injection Devices
            • Dependency Injection Inter-Stopper-Communication
            • Dependency Injection Stopper Workflows
            • Dependency Injection Stopper
            • Dependency Injection Declaration in Main
            • Dependency Injection Summary
          • Dependencies Examples Abstract Factories
            • Abstract Factories Introduction
            • Abstract Factories Object
            • Abstract Factories Alarm Messages
            • Abstract Factories Alarm Message Service
              • Alarm Message Service Introduction
              • Alarm Message Service Common Interfaces
              • Alarm Message Service Collection Interfaces
              • Alarm Message Service Factories
              • Alarm Message Service Collection Implementations
              • Alarm Message Service Alarm Message Distributor
            • Abstract Factories OPC-UA HMI Connection
            • Abstract Factories Test it
            • Abstract Factories Summary
      • Common Practices ControlStatus Words
      • Common Practices Scope Pointer
      • Common Practices Divide The Libraries
      • Common Practices Return Values
    • STExST Practices
      • STExST Practices GOTO JMP
      • STExST Practices CASE OF
      • STExST Practices Assignment as Expression
      • STExST Practices Namespace Alias
      • STExST Practices VAR_OUTPUT
    • SFC Practices
      • SFC Practices Jumps
      • SFC Practices Cyclic Rotations
  • Glossary
    • Glossary A
    • Glossary B
    • Glossary C
      • Glossary Class
    • Glossary D
      • Glossary Data Transfer Object
      • Glossary Dto
    • Glossary E
    • Glossary F
      • Glossary Foo
    • Glossary G
    • Glossary H
    • Glossary I
    • Glossary J
    • Glossary K
    • Glossary L
    • Glossary M
    • Glossary N
    • Glossary O
    • Glossary P
    • Glossary Q
    • Glossary R
    • Glossary S
    • Glossary T
    • Glossary U
    • Glossary V
    • Glossary W
    • Glossary X
    • Glossary Y
    • Glossary Z

Common Practices: Return Values

Table of Contents

Introduction

In Structured Text, it is possible to return References to types as a result of a method/property/function. In the TwinCAT documentation, it is even recommended to do so to allow access to single elements of a returned struct. This, however, should be avoided as it can lead to dangerous and unpredictable behavior in the runtime. The reason is that especially functions should not use any static variables, and so they most likely will return a reference to a value on the call-stack. This means the data after the call is not to be trusted, and the reference might point to something else.

Avoid Returning References or Pointers in Functions

Why functions must avoid returning interface references or pointers

1. Stack operations: Functions operate on the stack, where returning interface references or pointers can lead to unexpected behavior or memory corruption.

2. Avoidance of global data: Global data within functions is discouraged to maintain modularity and prevent unintended side effects.

3. Prevention of memory leaks: Dynamically generated data within functions can cause memory leaks if not managed properly.

Exceptions for returning interfaces, references, and pointers:

• Functions may return interfaces, references, or pointers if the referenced data is passed to the function, ensuring proper memory management.

Guidelines for Methods and Properties

• Methods and properties may return interface references or pointers if:

  • The data belongs to the object instance.

  • The data belongs to the class (static data).

  • It's a factory method with clear indications, providing dynamically generated data and offering the means to destroy it

    • For objects/interfaces, it’s required to provide a destruct method it must contain __DELETE(THIS);

    • For references to type structs, one member must contain the address of it. E.g. myAddress :POINTER TO <type>; Otherwise it’s not possible to delete it again because ADR will return just the address of your variable.

Tips for Handling Return Values:

• Instead of returning interface references or pointers directly, consider passing referenced data to functions to avoid stack-related issues and promote cleaner code.

• Employ proper memory management techniques, such as deallocating dynamically allocated memory, to prevent memory leaks.

• Utilize factory methods judiciously, ensuring they provide clear documentation and handling for dynamically generated data.