ada string assignment

Ada Programming/Strings

• 1 Fixed-length string handling
• 2 Bounded-length string handling
• 3 Unbounded-length string handling
• 4.1 Wikibook
• 4.2 Ada 95 Reference Manual
• 4.3 Ada 2005 Reference Manual

Ada supports three different types of strings. Each string type is designed to solve a different problem.

In addition, every string type is implemented for each available Characters type (Character, Wide_Character, Wide_Wide_Character) giving a complement of nine combinations.

Fixed-length string handling

Fixed-Length Strings (the predefined type String ) are arrays of Character, and consequently of a fixed length. Since String is an indefinite subtype the length does not need to be known at compile time — the length may well be calculated at run time. In the following example the length is calculated from command-line argument 1:

However once the length has been calculated and the string has been created the length stays constant. Try the following program which shows a typical mistake:

The program will only work when the 1st and 2nd parameter have the same length. This is even true when the 2nd parameter is shorter. There is neither an automatic padding of shorter strings nor an automatic truncation of longer strings.

Having said that, the package Ada . Strings . Fixed contains a set of procedures and functions for Fixed-Length String Handling which allows padding of shorter strings and truncation of longer strings.

Try the following example to see how it works:

Bounded-length string handling

Bounded-Length Strings can be used when the maximum length of a string is known and/or restricted. This is often the case in database applications where only a limited number of characters can be stored.

Like Fixed-Length Strings the maximum length does not need to be known at compile time — it can also be calculated at runtime — as the example below shows:

You should know that Bounded-Length Strings have some distinct disadvantages. Most noticeable is that each Bounded-Length String is a different type which makes converting them rather cumbersome. Also a Bounded-Length String type always allocates memory for the maximum permitted string length for the type. The memory allocation for a Bounded-Length String is equal to the maximum number of string "characters" plus an implementation dependent number containing the string length (each character can require allocation of more than one byte per character, depending on the underlying character type of the string, and the length number is 4 bytes long for the Windows GNAT Ada compiler v3.15p, for example).

Unbounded-length string handling

Last but not least there is the Unbounded-Length String. In fact: If you are not doing embedded or database programming this will be the string type you are going to use most often as it gives you the maximum amount of flexibility.

As the name suggest the Unbounded-Length String can hold strings of almost any length — limited only to the value of Integer'Last or your available heap memory. This is because Unbounded_String type is implemented using dynamic memory allocation behind the scenes, providing lower efficiency but maximum flexibility.

As you can see the Unbounded-Length String example is also the shortest (disregarding the buggy first example) — this makes using Unbounded-Length Strings very appealing.

• Ada Programming

Ada 95 Reference Manual

• 2.6: String Literals [ Annotated ]
• 3.6.3: String Types [ Annotated ]
• A.4.3: Fixed-Length String Handling [ Annotated ]
• A.4.4: Bounded-Length String Handling [ Annotated ]
• A.4.5: Unbounded-Length String Handling [ Annotated ]

Ada 2005 Reference Manual

• Book:Ada Programming

Navigation menu

5.2 Assignment Statements

This Reference Manual output has not been verified, and may contain omissions or errors. Report any problems on the tracking issue

[An assignment_statement replaces the current value of a variable with the result of evaluating an expression .]

assignment _ statement ::= variable _ name := expression ;

The execution of an assignment_statement includes the evaluation of the expression and the assignment of the value of the expression into the target . [An assignment operation (as opposed to an assignment _ statement ) is performed in other contexts as well, including object initialization and by-copy parameter passing.] The target of an assignment operation is the view of the object to which a value is being assigned; the target of an assignment _ statement is the variable denoted by the variable _ name .

Don't confuse this notion of the “target” of an assignment with the notion of the “target object” of an entry call or requeue.

Don't confuse the term “assignment operation” with the assignment_statement . The assignment operation is just one part of the execution of an assignment_statement . The assignment operation is also a part of the execution of various other constructs; see 7.6.1 , “ Completion and Finalization ” for a complete list. Note that when we say, “such-and-such is assigned to so-and-so”, we mean that the assignment operation is being applied, and that so-and-so is the target of the assignment operation.

Name Resolution Rules ​

The variable _ name of an assignment_statement is expected to be of any type. The expected type for the expression is the type of the target.

An assignment_statement as a whole is a “complete context”, so if the variable _ name of an assignment_statement is overloaded, the expression can be used to help disambiguate it. For example:

type P1 is access R1; type P2 is access R2; 4.c function F return P1; function F return P2; 4.d X : R1; begin F.all := X; -- Right hand side helps resolve left hand side

Legality Rules ​

The target [denoted by the variable _ name ] shall be a variable of a nonlimited type.

If the target is of a tagged class-wide type T 'Class, then the expression shall either be dynamically tagged, or of type T and tag-indeterminate (see 3.9.2 ).

This is consistent with the general rule that a single dispatching operation shall not have both dynamically tagged and statically tagged operands. Note that for an object initialization (as opposed to the assignment_statement ), a statically tagged initialization expression is permitted, since there is no chance for confusion (or Tag _ Check failure). Also, in an object initialization, tag-indeterminate expressions of any type covered by T 'Class would be allowed, but with an assignment_statement , that might not work if the tag of the target was for a type that didn't have one of the dispatching operations in the tag-indeterminate expression.

Dynamic Semantics ​

For the execution of an assignment_statement , the variable _ name and the expression are first evaluated in an arbitrary order.

Other rules of the language may require that the bounds of the variable be determined prior to evaluating the expression , but that does not necessarily require evaluation of the variable _ name , as pointed out by the ACID.

When the type of the target is class-wide:

• If the expression is tag-indeterminate (see 3.9.2 ), then the controlling tag value for the expression is the tag of the target;

See 3.9.2 , “ Dispatching Operations of Tagged Types ”.

• Otherwise [(the expression is dynamically tagged)], a check is made that the tag of the value of the expression is the same as that of the target; if this check fails, Constraint _ Error is raised.

The value of the expression is converted to the subtype of the target. [The conversion can raise an exception (see 4.6 ).]

4.6 , “ Type Conversions ” defines what actions and checks are associated with subtype conversion. For non-array subtypes, it is just a constraint check presuming the types match. For array subtypes, it checks the lengths and slides if the target is constrained. “Sliding” means the array doesn't have to have the same bounds, so long as it is the same length.

In cases involving controlled types, the target is finalized, and an anonymous object can be used as an intermediate in the assignment, as described in 7.6.1 , “ Completion and Finalization ”. In any case, the converted value of the expression is then assigned to the target, which consists of the following two steps:

To be honest: 7.6.1 actually says that finalization happens always, but unless controlled types are involved, this finalization during an assignment_statement does nothing.

• The value of the target becomes the converted value.
• If any part of the target is controlled, its value is adjusted as explained in 7.6 .

If any parts of the object are controlled, abort is deferred during the assignment operation itself, but not during the rest of the execution of an assignment_statement .

NOTE The tag of an object never changes; in particular, an assignment_statement does not change the tag of the target.

The implicit subtype conversion described above for assignment_statement s is performed only for the value of the right-hand side expression as a whole; it is not performed for subcomponents of the value.

The determination of the type of the variable of an assignment_statement may require consideration of the expression if the variable name can be interpreted as the name of a variable designated by the access value returned by a function call, and similarly, as a component or slice of such a variable (see 8.6 , “ The Context of Overload Resolution ”).

Examples of assignment statements:

Value := Max _ Value - 1; Shade := Blue; 19 Next _ Frame(F)(M, N) := 2.5; -- see 4.1.1 U := Dot _ Product(V, W); -- see 6.3 20/4

Writer := (Status = > Open, Unit = > Printer, Line _ Count = > 60); -- see 3.8.1 Next.all := (72074, null, Head); -- see 3.10.1

Examples involving scalar subtype conversions:

I, J : Integer range 1 .. 10 := 5; K : Integer range 1 .. 20 := 15; ... 23 I := J; -- identical ranges K := J; -- compatible ranges J := K; -- will raise Constraint _ Error if K > 10

Examples involving array subtype conversions:

A : String(1 .. 31); B : String(3 .. 33); ... 26 A := B; -- same number of components 27 A(1 .. 9) := "tar sauce"; A(4 .. 12) := A(1 .. 9); -- A(1 .. 12) = "tartar sauce"

Assignment_statement s are well-defined even in the case of overlapping slices of the same array, because the variable _ name and expression are both evaluated before copying the value into the variable. In the above example, an implementation yielding A(1 .. 12) = "tartartartar" would be incorrect.

Extensions to Ada 83 ​

We now allow user-defined finalization and value adjustment actions as part of assignment_statement s (see 7.6 , “ Assignment and Finalization ”).

Wording Changes from Ada 83 ​

The special case of array assignment is subsumed by the concept of a subtype conversion, which is applied for all kinds of types, not just arrays. For arrays it provides “sliding”. For numeric types it provides conversion of a value of a universal type to the specific type of the target. For other types, it generally has no run-time effect, other than a constraint check.

We now cover in a general way in 3.7.2 the erroneous execution possible due to changing the value of a discriminant when the variable in an assignment_statement is a subcomponent that depends on discriminants.

Incompatibilities With Ada 95 ​

The change of the limited check from a resolution rule to a legality rule is not quite upward compatible. For example

type AccNonLim is access NonLim; function Foo (Arg : in Integer) return AccNonLim; type AccLim is access Lim; function Foo (Arg : in Integer) return AccLim; Foo(2).all := Foo(1).all;

where NonLim is a nonlimited type and Lim is a limited type. The assignment is legal in Ada 95 (only the first Foo would be considered), and is ambiguous in Ada 2005. We made the change because we want limited types to be as similar to nonlimited types as possible. Limited expressions are now allowed in all other contexts (with a similar incompatibility), and it would be odd if assignments had different resolution rules (which would eliminate ambiguities in some cases). Moreover, examples like this one are rare, as they depend on assigning into overloaded function calls.

5.2.1 Target Name Symbols ​

@, known as the target name of an assignment statement, provides an abbreviation to avoid repetition of potentially long names in assignment statements.

target _ name ::= @

[If a target_name occurs in an assignment_statement A , the variable _ name V of A is a complete context. The target name is a constant view of V , having the nominal subtype of V .]

The complete context rule is formally given in 8.6 . The constant view rule is formally given in 3.3 ; the nominal subtype is a property taken from the target object as described below in Dynamic Semantics.

A target_name shall appear only in the expression of an assignment_statement .

For the execution of an assignment_statement with one or more target_name s appearing in its expression , the variable _ name V of the assignment_statement is evaluated first to determine the object denoted by V , and then the expression of the assignment_statement is evaluated with the evaluation of each target_name yielding a constant view of the target whose properties are otherwise identical to those of the view provided by V . The remainder of the execution of the assignment_statement is as given in 5.2 .

To be honest: The properties here include static properties like whether the target_name is aliased and the nominal subtype of the target_name . It was too weird to give separate rules for static and dynamic properties that said almost the same thing.

Use of a target_name can be erroneous if the variable _ name V is a discriminant-dependent component, and some other constituent of the expression modifies the discriminant governing the component V . The assignment probably would be erroneous anyway, but the use of a target_name eliminates the possibility that a later evaluation of V raises an exception before any erroneous execution occurs. See 3.7.2 .

Examples of the use of target name symbols:

Board(1, 1) := @ + 1.0; -- An abbreviation for Board(1, 1) := Board(1, 1) + 1.0; -- (Board is declared in 3.6.1 ). 8/5

My _ Complex _ Array : array (1 .. Max) of Complex; -- See 3.3.2 , 3.8 . ... -- Square the element in the Count (see 3.3.1 ) position: My _ Complex _ Array (Count) := (Re = > @.Re * * 2 - @.Im * * 2, Im = > 2.0 * @.Re * @.Im); -- A target _ name can be used multiple times and -- as a prefix if desired.

Extensions to Ada 2012 ​

The target name symbol @ is new.

• 5.2.1 Target Name Symbols

3.1 Assignment Statements

[ Table of Contents ] [  Chapter Overview  ] [  Next  ] [ Glossary/Index ]

An assignment statement is a simple statement used to replace the value of a variable with a new value computed using an expression, as indicated below.

After the expression on the right side of the := symbol is evaluated, it's type must match the type or subtype of the variable on the left. Otherwise, an exception will be raised.

Here is a small program containing two simple examples of assignment statements, one handling integer values and the other handling string values.

Source Code Listing

The above program produces the following output:

(The multiplication by 10 happens before the subtraction of 2.)

Operator Precedence and Overloading

The evaluation of expressions involves operators such as +, -, and * (for numeric values) and & (for strings and characters). The following table lists the precedence rules for Ada's built-in operators, ranging from level 6 operators (highest precedence) to level 1 (lowest precedence).

The level 1 operators are known as logical operators. The level 2 operators are known as relational operators. (See discussion of the Boolean type in the next chapter.) The binary (level 3) operators take two parameters, while the unary (level 4) operators take just one.

Some of the built-in operators are overloaded. For example, there are multiple versions of the binary +, -, * and / operators, used for different combinations of numeric types -- Integer, Float and Fixed_Point. (See discussion of numeric types in the next chapter.) It is also possible to create user-defined operators, which can further overload some of the symbols used for the built-in operators.

Related Topics

[ Back to top of page ]  [  Next  ]

• Introduction to Ada: Laboratories
• Standard library: Strings

Standard library: Strings 

Concatenation .

Goal : implement functions to concatenate an array of unbounded strings.

Implement the Str_Concat package. Implement the Concat function for Unbounded_String . Implement the Concat function for String .

Requirements :

The first Concat function receives an unconstrained array of unbounded strings and returns the concatenation of those strings as an unbounded string. The second Concat function has the same parameters, but returns a standard string ( String type).

Both Concat functions have the following parameters:

An unconstrained array of Unbounded_String strings ( Unbounded_Strings type). Trim_Str , a Boolean parameter indicating whether each unbounded string must be trimmed. Add_Whitespace , a Boolean parameter indicating whether a whitespace shall be added between each unbounded string and the next one. No whitespace shall be added after the last string of the array.

You can use the Trim function from the Ada . Strings . Unbounded package.

List of events 

Goal : create a system to manage a list of events.

Implement the Events package. Declare the Event_Item subtype.

Implement the Events . Lists package.

Adapt the Add procedure. Adapt the Display procedure.

The Event_Item type (from the Events package) contains the description of an event . This description is declared as a subtype of unbounded string. Procedure Add adds an event into the list of events for a specific date. The declaration of E needs to be adapted to use unbounded strings.

Procedure Display must display all events for each date (ordered by date) using the following format:

The arguments to Put_Line need to be adapted to use unbounded strings.

We use the lab on the list of events from the previous chapter ( Standard library: Dates & Times ) as a starting point.

Copyright ©1986 owned by the United States Government. All rights reserved. Direct inquiries to the Ada Information Clearinghouse at [email protected] .

In this article

How to Use Regex for Advanced String Replacement in Python

Explore advanced string replacement in Python with regex, handling complex patterns, dynamic substitutions, and multi-line strings using re.sub().

Regular expressions, or regex, are a powerful tool in Python for working with text data. They enable you to search, match, and manipulate strings based on specific patterns. Whether you are cleaning data, validating input, or performing complex string replacements, regex can help you accomplish tasks with efficiency and precision.

In Python, the  re module provides a suite of functions to work with regex. Among these,  re.sub() is particularly useful for replacing substrings within a text based on a regex pattern. This article will guide you through the essentials of using  re.sub() for advanced string replacement, showcasing various techniques and examples.

By mastering regex-based string replacement, you can streamline your text processing tasks, automate repetitive text modifications, and handle complex patterns with ease. Let's dive into the basics before exploring more advanced use cases.

Ready for high-paying Python projects? Join Index.dev to work on impactful projects in the US, UK, and EU.

Understanding the basics of re.sub().

The  re.sub() function is the primary tool for performing string replacements with regex in Python. It allows you to specify a regex pattern to search for, a replacement string, and the target string where the replacement will occur. The basic syntax of  re.sub() is as follows:

• pattern : The regex pattern you want to search for.
• replacement : The string that will replace the matched pattern.
• string : The original string where the replacement occurs.
• count : An optional parameter that specifies the maximum number of replacements (default is 0, meaning all occurrences).
• flags : Optional flags that modify the behavior of the regex engine (e.g.,  re.IGNORECASE for case-insensitive matching).

Here’s a simple example:

In this example, the word "World" is replaced with "Universe" using the regex pattern  r"World" . This is a straightforward use of  re.sub() , but the true power of regex becomes apparent when you start using more complex patterns.

Advanced Pattern Matching with Regex

Regex provides a rich syntax for matching patterns, allowing you to identify and replace complex sequences of characters in a string. Some advanced features include:

• Character Classes : Match specific sets of characters, e.g.,  [0-9] matches any digit,  [A-Za-z] matches any letter.
• Quantifiers : Specify how many times a character or group should be matched, e.g.,  * (zero or more),  + (one or more),  {n} (exactly n times).
• Groups and Backreferences : Capture parts of the matched pattern and reuse them, e.g.,  (abc)\1 matches "abcabc".
• Assertions : Conditions that must be true for the match, but do not consume characters, e.g.,  \b for word boundaries.

Let’s explore these features with an example:

Here, the regex pattern matches email addresses in the text. The pattern  \b[\w.-]+@[\w.-]+\.\w+\b breaks down as follows:

• \b : Word boundary to ensure we're matching whole email addresses.
• [\w.-]+ : Matches the username part (letters, digits, underscores, dots, hyphens).
• @ : Matches the "@" symbol.
• [\w.-]+ : Matches the domain part.
• \.\w+ : Matches the top-level domain (e.g., ".com").
• \b : Another word boundary.

The matched emails are then replaced with "[email]", demonstrating how regex can be used for advanced pattern matching and replacement.

Using Functions for Dynamic Replacements

One of the powerful features of  re.sub() is the ability to pass a function as the replacement argument. This allows you to perform dynamic replacements based on the match content. The function receives a match object and can return a customized replacement string.

Here’s an example where we replace all numbers in a string with their squared values:

In this example, the regex  r"\d+" matches any sequence of digits. The  square() function is called for each match, converting the matched number to an integer, squaring it, and returning the result as a string. This technique is particularly useful when the replacement value depends on the matched content.

Handling Case Sensitivity and Multiline Strings

By default, regex in Python is case-sensitive. If you want to perform case-insensitive replacements, you can use the  re.IGNORECASE flag. Additionally, regex can work across multiple lines if the string contains line breaks. The  re.MULTILINE flag allows you to match patterns at the start or end of each line within the string.

Consider the following example:

Here, the  re.IGNORECASE flag ensures that all variations of "hello world" (regardless of case) are replaced with "hi universe".

For multiline strings, consider using  re.MULTILINE to match patterns at the beginning or end of each line:

This example demonstrates how the  re.MULTILINE flag allows the  ^ anchor to match the start of each line, replacing the first word on every line with "Line".

Using Backreferences for Complex Replacements

Backreferences in regex allow you to refer back to captured groups in your pattern, which can be useful for more sophisticated replacements. Backreferences are denoted by  \1 ,  \2 , etc., corresponding to the order of the capturing groups.

Here’s an example where we swap the first and last name in a string:

In this example, the pattern  r"(\w+), (\w+)" captures the last name and first name separately. The replacement string  r"\2 \1" refers to these captured groups, swapping their order.

This technique is especially useful for reformatting text data or performing complex text transformations where the new format depends on the structure of the original text.

Read more:  How to prepend an element to a short Python list

Regex in Python is a versatile tool for advanced string replacement tasks. By leveraging the power of  re.sub() , you can efficiently handle complex patterns, dynamic replacements, and multi-line strings. Whether you’re working with simple substitutions or intricate text manipulations, mastering regex will enable you to process and transform text data with precision.

Understanding how to use regex effectively requires practice and familiarity with its syntax. Start with basic patterns and gradually explore more advanced features like groups, backreferences, and flags. With time, you’ll find regex to be an indispensable tool in your Python programming toolkit, capable of simplifying even the most challenging text processing tasks.

Join Index.dev , the remote work platform connecting senior Python developers with remote tech companies. Begin working remotely on innovative projects across the US, UK, and EU!

Related Articles

Discover how a french-based saas company glopal onboarded experienced devops & python engineers in record time..

Explore how Index helped France Pari assign skilled PHP developers for its sports betting projects.

• Stack Overflow for Teams Where developers & technologists share private knowledge with coworkers
• Advertising & Talent Reach devs & technologists worldwide about your product, service or employer brand
• OverflowAI GenAI features for Teams
• OverflowAPI Train & fine-tune LLMs
• Labs The future of collective knowledge sharing
• About the company Visit the blog

Collectives™ on Stack Overflow

Find centralized, trusted content and collaborate around the technologies you use most.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Get early access and see previews of new features.

Passing Strings from Ada function to C function

Ada's strings are NOT null terminated like C's. I have a requirement in a C-Ada binding application where I need to pass a string that is allocated in Ada code to a C function. How will C recognize Ada strings in here as strings in C are usually simple char array terminated by a null char while this is not the case in Ada?

Any examples would be appreciated!

• 1 Check your manual: ada-auth.org/standards/aarm12_w_tc1/html/AA-B-3.html –  ikrabbe Commented Mar 18, 2016 at 7:23
• 1 Pass the ADA char-array along with its length to either strncpy (newstr, ada_str, length); and explicitly terminate newstr e.g. newstr[length] = 0; Or, if you have the ada string and the length and can use that same variable in the C code, just terminate the ada_string, e.g. adastring[length] = 0; (or if ada indexes from 1 instead of 0 , then adastring[length+1] = 0; (as long as the storage is available to add a nul-terminator) –  David C. Rankin Commented Mar 18, 2016 at 8:46
• 1 Mostly a duplicate of your own question stackoverflow.com/questions/35911763/… –  manuBriot Commented Mar 18, 2016 at 8:57

Expanding on @manuBriot's answer to your previous question on this topic, note that the convenient wrapper procedure Foo calls New_String on the incoming Ada String to obtain a chars_ptr .

Note also that New_String "is equivalent to New_Char_Array(To_C(Str)) ." When passed an Ada String , To_C sets Append_Nul to True by default. As a result, Ada Foo calls C foo with a properly null terminated C string.

• If I am allocating a string in ADA, how do I release memory after using that string in C side? –  Akay Commented Mar 20, 2016 at 10:59
• 1 @AKay: Referring to the code elided above, Free(S) will release the storage allocated for the char_array by New_String . –  trashgod Commented Mar 20, 2016 at 13:21

Your Answer

Reminder: Answers generated by artificial intelligence tools are not allowed on Stack Overflow. Learn more

Sign up or log in

Post as a guest.

Required, but never shown

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy .

Not the answer you're looking for? Browse other questions tagged c string ada or ask your own question .

• The Overflow Blog
• The evolution of full stack engineers
• One of the best ways to get value for AI coding tools: generating tests
• Featured on Meta
• Bringing clarity to status tag usage on meta sites
• Join Stack Overflow’s CEO and me for the first Stack IRL Community Event in...
• Feedback requested: How do you use tag hover descriptions for curating and do...
• Staging Ground Reviewer Motivation
• What does a new user need in a homepage experience on Stack Overflow?

Hot Network Questions

• A journal has published an AI-generated article under my name. What to do?
• What is the least number of colours Peter could use to color the 3x3 square?
• Why would the GPL be viral, while EUPL isn't, according to the EUPL authors?
• Guesstimate a multiple choice exam
• How are you supposed to trust SSO popups in desktop and mobile applications?
• Is this map real?
• Why are some Cloudflare challenges CPU intensive?
• Why do "modern" languages not provide argv and exit code in main?
• Did Queen (or Freddie Mercury) really not like Star Wars?
• Logical relationship between supercompact and rank-into-rank cardinals
• Is it possible for one wing to stall due to icing while the other wing doesn't ice?
• Are there epistemic vices?
• Big Transition of Binary Counting in perspective of IEEE754 floating point
• Geo Nodes: store attribute "line length" for every point in the line
• Where did Magnus get Super TNT?
• Can the Fourier transform of a test function vanish on an interval?
• How resiliant is a private key passphase to brute force attacks?
• Mistake on car insurance policy about use of car (commuting/social)
• Long table to fit in two pages
• Can you spell memento as mement?
• What sci-fi show was Ernie watching in the show My Three Sons?
• Key fob frequency filter design
• Colossians 1:16 New World Translation renders τα πάντα as “all other things” but why is this is not shown in their Kingdom Interlinear?
• When should I put a biasing resistor - op-amps

Ada Advantages

Ara community, ada resource association, news and resource for the ada programming language, by jim rogers.

This is part three (of five) of this article. Click here to return to part two, or click here to go to the article’s table of contents.

Ada Operators

C++ allows extensive overloading of operators. Ada allows a limited overloading of operators. The exception in Ada is that the assignment operator ( := ) cannot be overridden. When you override the equality operator ( = ) you also implicitly override the inequality operator ( /= ). Java does not allow overriding of operators.

If you want to achieve the equivalent of overriding the assignment operator in Ada you must declare your type to inherit from the abstract tagged type Controlled defined in the package Ada.Finalization. Controlled types provide three operations that can be overridden.

• Initialize is called during object construction and allows control over the initialization logic for the controlled type. The Initialize procedure performs much the same function as a default constructor in C++ or Java.
• Adjust is a procedure that is called at the end of assignment. Overriding Adjust lets you control assignment behavior.
• Finalize is called when an object goes out of scope. The Finalize procedure can be overridden to achieve the same purposes as a C++ destructor.

Ada also allows the definition of limited types. Any type declared limited has no predefined operators, including assignment. Use of limited types allows the programer to selectively restrict the available operations on a type. Only those operations specifically provided by the programmer will be available for a limited type.

The package Ada.Finalization defines a second abstract tagged type named Limited_Controlled . Limited_Controlled types do not have an adjust procedure.

Any attempt to assign a value to an object of a limited type will result in a compile time error message.

Operator Examples

This example is divided into three files. The first file is a package specification. This package specification defines two types and the subprograms for those types.

The Days type is an enumeration type containing the names of the days of the week in English. Days has the procedure Print_Message defined for it.

The Daily_Sales type is an array of floats indexed by the values in type Days . Daily_Sales has two functions defined for it: Total and Geometric_Mean .

The package Operator_Examples becomes visible to another compilation unit when that compilation unit names   Operator_Examples in a   with clause. Java does not require this explicit declaration of dependency. Instead, the compiler must scan every line of code to determine external dependencies. The public contents of this package specification become directly visible to a foreign compilation unit when it follows the with clause with a use clause. The Ada use clause is similar to a Java import statement. 

The next file is the package body, or implementation. The package body contains the definitions of all the subprograms declared in the package specification. In this example the package body also declares a dependency upon two packages: Ada.Text_Io and Ada.Numerics.Elementary_Functions . As you can see above, the exponentiation operation is defined as ** . The normal version of this operator takes an integer value as its power. I wanted to pass it a fractional value. I declared a dependency upon Ada.Numerics.Elementary_Functions and then included the same package in a use clause so that I could use the overloaded version of the exponentiation operator that takes a float for the exponent value.

The third file contains the parameterless procedure used as the starting point for a program to exercise the Operator_Examples package. This package declares a dependency upon two different I/O packages. The package Ada.Text_Io defines text file operations and procedures for the input and output of strings and characters. The package Ada.Float_Text_Io defines text file input and output procedures for the type float . Both packages have Put procedures. The package Ada.Float_Text_Io overloads the Put operations defined in Ada.Text_Io .

The output from this program is:

This ends part three of this article. Click here to continue with part four, Loops and other control structures.

• Learning Materials
• Professional Training
• Ada in Academia

ARA Sponsor Spotlight

• Ada Overview
• More Topics of Interest
• Features & Benefits
• Ada Comparison Chart
• Ada and Multicore
• Case Studies

Ada Projects

• Ada Standards
• Free Tools & Libraries
• Professional Tools and Services
• Associations
• Ada on the Web
• Compilers and Conformity
• Join the ARA
• ARA Press Releases

Copyright © 2009-2024 Ada Resource Association Site Map | Contact Us