OBJECT SEMANTICS IN C++/CLI in Visual C#

Generating PDF417 in Visual C# OBJECT SEMANTICS IN C++/CLI

To pass reference type objects by value, omit the handle symbol, as shown in the declaration of the function h in Listing 4-23. While this is normal for a value type, it is also possible for a reference type as long as the reference type has a copy constructor. Listing 4-23. Passing a Reference Type by Value // pass_by_value.cpp using namespace System; ref struct R { R() { val = 1; } // copy constructor R( R% r) { val = r.val; } property int val; };

// R passed by value (no ^) void f(R r_local) { // Modify r without affecting outer scope. r_local.val = 2; Console::WriteLine("Within f: " + r_local.val); } int main() { R r; f(r); Console::WriteLine("Outside f: " + r.val); // The same code, using heap semantics R^ rhat = gcnew R(); f(*rhat); // Dereference the handle. Console::WriteLine("Outside f: " + rhat->val); } The output of Listing 4-23 is as follows: Within f: 2 Outside f: 1 Within f: 2 Outside f: 1 Figure 4-4 shows what s happening in memory for this type of parameter passing.

Figure 4-4. The main method declares R r and passes by value to f(R r_local). The copy constructor is invoked, creating another copy of the reference type object on the managed heap.

Parameters normally passed by value (such as primitive types and value types) may be passed by reference using the % symbol in the parameter declaration. This is useful if you want to write a function that changes a value type, such as in Listing 4-24. Listing 4-24. Changing a Value Type in a Function // pass_by_ref.cpp using namespace System; value class Pair { public: int x; int y; }; void swap_values(Pair% pair) { int temp = pair.x; pair.x = pair.y; pair.y = temp; } int main() { Pair p; p.x = 5; p.y = 3; Console::WriteLine("{0} {1}", p.x, p.y); swap_values(p); Console::WriteLine("{0} {1}", p.x, p.y); } The output of Listing 4-24 is shown here: 5 3 3 5 Figure 4-5 shows the memory layout for the preceding example.

Figure 4-5. The swap_values method contains a reference pair to main s copy of p as well as a local integer variable to hold a temporary value.

In Listing 4-12, you saw how you could pass a handle by reference using the ^% indirection. In Listing 4-25, you see that a reference type object with stack semantics isn t affected by a function that takes a reference to a handle if you use the tracking reference operator (%) to create a handle to the object. This is because the handle obtained with the % operator is a different, temporary handle. As a result, an object with stack semantics always represents the original object, so you can be assured that the correct object is cleaned up at the end of the block. Listing 4-25. C++/CLI Stack Semantics // pass_by_ref2.cpp // This example illustrates that a stack semantics // reference type can't be redirected by a function // that operates on references to handles. using namespace System; ref struct R { property int A; R(int a) { this->A = a; } }; // Takes a reference to a handle void reset_handle(R^% r) { r = gcnew R(5); } int main() { R r(2); // stack semantics reset_handle(%r); // Use % to create a handle. // The output is 2, since the handle passed to f

// was a temporary one, so it didn't get changed by // the function f. Console::WriteLine("Value: {0}", r.A); } It s worth having a solid understanding of the semantics of parameter passing. Using what you ve seen so far, see if you can predict the output of Listing 4-26. Listing 4-26. What Does This Output // pass_by_ref3.cpp // This example requires some careful thought. // Can you figure out what the final output // will be using namespace System; ref struct R { property int A; R(int a) { this->A = a; } }; // Takes a reference to a handle. This function // sets the property value on the object, then // overwrites the object! // Will the object in the calling scope // have the value 3, or 5, or will it retain its // original value void reset_handle(R^% r) { r->A = 3; r = gcnew R(5); } int main() { R r_stack(1); // stack semantics R^ r_heap = gcnew R(2); // heap semantics reset_handle(%r_stack); // Use % to create a handle. reset_handle(r_heap); Console::WriteLine("Final value, stack semantics: {0}", r_stack.A); Console::WriteLine("Final value, heap semantics: {0}", r_heap->A); }