в 15:31, 26 мая 2010

2010-05-26T15:31:18Z

Admin: 1 версия

2010-05-26T11:39:47Z

1 версия

Новая страница

==C# Ref and Out Parameters==

<source lang="csharp">
using System;
class Point
{
public Point(int x, int y)
{
this.x = x;
this.y = y;
}

public void GetPoint(ref int x, ref int y)
{
x = this.x;
y = this.y;
}

int x;
int y;
}
public class RefOutParameters2
{
public static void Main()
{
Point myPoint = new Point(10, 15);
int x = 0;
int y = 0;

myPoint.GetPoint(ref x, ref y);
Console.WriteLine("myPoint({0}, {1})", x, y);
}
}

</source>

==Demonstrate params==

<source lang="csharp">
/*
C#: The Complete Reference
by Herbert Schildt
Publisher: Osborne/McGraw-Hill (March 8, 2002)
ISBN: 0072134852
*/
// Demonstrate params.

using System;

class Min {
public int minVal(params int[] nums) {
int m;

if(nums.Length == 0) {
Console.WriteLine("Error: no arguments.");
return 0;
}

m = nums[0];
for(int i=1; i < nums.Length; i++)
if(nums[i] < m) m = nums[i];

return m;
}
}

public class ParamsDemo {
public static void Main() {
Min ob = new Min();
int min;
int a = 10, b = 20;

// call with two values
min = ob.minVal(a, b);
Console.WriteLine("Minimum is " + min);

// call with 3 values
min = ob.minVal(a, b, -1);
Console.WriteLine("Minimum is " + min);

// call with 5 values
min = ob.minVal(18, 23, 3, 14, 25);
Console.WriteLine("Minimum is " + min);

// can call with an int array, too
int[] args = { 45, 67, 34, 9, 112, 8 };
min = ob.minVal(args);
Console.WriteLine("Minimum is " + min);
}
}

</source>

==Illustrates the use of out parameters==

<source lang="csharp">
/*
Mastering Visual C# .NET
by Jason Price, Mike Gunderloy
Publisher: Sybex;
ISBN: 0782129110
*/
/*
Example5_8.cs illustrates the use of out parameters
*/

// declare the MyMath class
class MyMath
{
// the SinAndCos() method returns the sin and cos values for
// a given angle (in radians)
public void SinAndCos(double angle, out double sin, out double cos) {
sin = System.Math.Sin(angle);
cos = System.Math.Cos(angle);
}
}

public class Example5_8
{
public static void Main()
{
// declare and set the angle in radians
double angle = System.Math.PI / 2;
// declare the variables that will be used as out paramters
double sin;
double cos;
// create a MyMath object
MyMath myMath = new MyMath();
// get the sin and cos values from the SinAndCos() method
myMath.SinAndCos(angle, out sin, out cos);
// display sin and cos
System.Console.WriteLine("sin = " + sin + ", cos = " + cos);
}
}

</source>

==Objects are passed by reference==

<source lang="csharp">
/*
C#: The Complete Reference
by Herbert Schildt
Publisher: Osborne/McGraw-Hill (March 8, 2002)
ISBN: 0072134852
*/
// Objects are passed by reference.

using System;

class Test {
public int a, b;

public Test(int i, int j) {
a = i;
b = j;
}
/* Pass an object. Now, ob.a and ob.b in object
used in the call will be changed. */
public void change(Test ob) {
ob.a = ob.a + ob.b;
ob.b = -ob.b;
}
}

public class CallByRef {
public static void Main() {
Test ob = new Test(15, 20);

Console.WriteLine("ob.a and ob.b before call: " +
ob.a + " " + ob.b);

ob.change(ob);

Console.WriteLine("ob.a and ob.b after call: " +
ob.a + " " + ob.b);
}
}

</source>

==Objects can be passed to methods==

<source lang="csharp">
/*
C#: The Complete Reference
by Herbert Schildt
Publisher: Osborne/McGraw-Hill (March 8, 2002)
ISBN: 0072134852
*/
// Objects can be passed to methods.

using System;

class MyClass {
int alpha, beta;

public MyClass(int i, int j) {
alpha = i;
beta = j;
}

/* Return true if ob contains the same values
as the invoking object. */
public bool sameAs(MyClass ob) {
if((ob.alpha == alpha) & (ob.beta == beta))
return true;
else return false;
}

// Make a copy of ob.
public void copy(MyClass ob) {
alpha = ob.alpha;
beta = ob.beta;
}

public void show() {
Console.WriteLine("alpha: {0}, beta: {1}",
alpha, beta);
}
}

public class PassOb {
public static void Main() {
MyClass ob1 = new MyClass(4, 5);
MyClass ob2 = new MyClass(6, 7);

Console.Write("ob1: ");
ob1.show();

Console.Write("ob2: ");
ob2.show();

if(ob1.sameAs(ob2))
Console.WriteLine("ob1 and ob2 have the same values.");
else
Console.WriteLine("ob1 and ob2 have different values.");

Console.WriteLine();

// now, make ob1 a copy of ob2
ob1.copy(ob2);

Console.Write("ob1 after copy: ");
ob1.show();

if(ob1.sameAs(ob2))
Console.WriteLine("ob1 and ob2 have the same values.");
else
Console.WriteLine("ob1 and ob2 have different values.");

}
}

</source>

==Parameter demo==

<source lang="csharp">
/*
Learning C#
by Jesse Liberty
Publisher: O"Reilly
ISBN: 0596003765
*/
using System;
namespace ParamsDemo
{
public class TesterParamsDemo
{
public void Run()
{
int a = 5;
int b = 6;
int c = 7;
Console.WriteLine("Calling with three integers");
DisplayVals(a,b,c);
Console.WriteLine("\nCalling with four integers");
DisplayVals(5,6,7,8);
Console.WriteLine("\ncalling with an array of four integers");
int [] explicitArray = new int[4] {5,6,7,8};
DisplayVals(explicitArray);
}
// takes a variable number of integers
public void DisplayVals(params int[] intVals)
{
foreach (int i in intVals)
{
Console.WriteLine("DisplayVals {0}",i);
}
}
[STAThread]
static void Main()
{
TesterParamsDemo t = new TesterParamsDemo();
t.Run();
}
}
}

</source>

==Parameter out and reference==

<source lang="csharp">
using System;

class ReferenceAndOutputParamtersTest
{
static void Main( string[] args )
{
int y = 5;
int z;
Console.WriteLine( "Original value of y: {0}", y );
Console.WriteLine( "Original value of z: uninitialized\n" );
SquareRef( ref y ); // must use keyword ref
SquareOut( out z ); // must use keyword out
Console.WriteLine( "Value of y after SquareRef: {0}", y );
Console.WriteLine( "Value of z after SquareOut: {0}\n", z );
Square( y );
Square( z );
Console.WriteLine( "Value of y after Square: {0}", y );
Console.WriteLine( "Value of z after Square: {0}", z );
}
static void SquareRef( ref int x )
{
x = x * x;
}
static void SquareOut( out int x )
{
x = 6;
x = x * x;
}
static void Square( int x )
{
x = x * x;
}
}

</source>

==Passing parameters by reference==

<source lang="csharp">
/*
Mastering Visual C# .NET
by Jason Price, Mike Gunderloy
Publisher: Sybex;
ISBN: 0782129110
*/
/*
Example5_7.cs illustrates passing parameters by reference
*/

// declare the Swapper class
class Swapper
{
// the Swap() method swaps parameters passed by reference
public void Swap(ref int x, ref int y)
{
// display the initial values
System.Console.WriteLine("In Swap(): initial x = " + x +
", y = " + y);
// swap x and y
int temp = x;
x = y;
y = temp;
// display the final values
System.Console.WriteLine("In Swap(): final x = " + x +
", y = " + y);
}
}

public class Example5_7
{
public static void Main()
{
// declare x and y (the variables whose values
// are to be swapped)
int x = 2;
int y = 5;
// display the initial values
System.Console.WriteLine("In Main(): initial x = " + x +
", y = " + y);
// create a Swapper object
Swapper mySwapper = new Swapper();
// swap the values, passing a reference to the Swap() method
mySwapper.Swap(ref x, ref y);
// display the final values
System.Console.WriteLine("In Main(): final x = " + x +
", y = " + y);
}
}

</source>

==Passing parameters by value==

<source lang="csharp">
/*
Mastering Visual C# .NET
by Jason Price, Mike Gunderloy
Publisher: Sybex;
ISBN: 0782129110
*/
/*
Example5_6.cs illustrates passing parameters by value
*/

// declare the Swapper class
class Swapper
{
// the Swap() method swaps parameters passed by value
public void Swap(int x, int y)
{
// display the initial values
System.Console.WriteLine("In Swap(): initial x = " + x +
", y = " + y);
// swap x and y
int temp = x;
x = y;
y = temp;
// display the final values
System.Console.WriteLine("In Swap(): final x = " + x +
", y = " + y);
}
}

public class Example5_6
{
public static void Main()
{
// declare x and y (the variables whose values
// are to be swapped)
int x = 2;
int y = 5;
// display the initial values
System.Console.WriteLine("In Main(): initial x = " + x +
", y = " + y);
// create a Swapper object
Swapper mySwapper = new Swapper();
// swap the values in x and y
mySwapper.Swap(x, y);
// display the final values
System.Console.WriteLine("In Main(): final x = " + x +
", y = " + y);
}
}

</source>

==Passing Parameters By Value and By Ref==

<source lang="csharp">
/*
* C# Programmers Pocket Consultant
* Author: Gregory S. MacBeth
* Email: gmacbeth@comporium.net
* Create Date: June 27, 2003
* Last Modified Date:
*/
using System;
namespace Client.Chapter_5___Building_Your_Own_Classes
{
public class PassingParametersByValueandByRef
{
static void Main(string[] args)
{
int MyInt = 5;
MyIntArray = new int[10];
ObjectCount++;
Method2();
Method2(1, 2);
MyMethodRef(ref MyInt);
Method2(new int[] { 1, 2, 3, 4 });
}
static private int MyInt = 5;
static public int MyInt2 = 10;
static public int[] MyIntArray;
private static int ObjectCount = 0;
static public int MyMethodRef(ref int myInt)
{
MyInt = MyInt + myInt;
return MyInt;
}
static public int MyMethod(int myInt)
{
MyInt = MyInt + myInt;
return MyInt;
}
static private long MyLongMethod(ref int myInt)
{
return myInt;
}
static public void Method2(params int[] args)
{
for (int I = 0; I < args.Length; I++)
Console.WriteLine(args[I]);
}
}
}

</source>

==Pass value by reference==

<source lang="csharp">
/*
Learning C#
by Jesse Liberty
Publisher: O"Reilly
ISBN: 0596003765
*/
using System;
namespace PassByRef
{
public class Time3
{
// private member variables
private int Year;
private int Month;
private int Date;
private int Hour;
private int Minute;
private int Second;
// Property (read only)
public int GetHour()
{
return Hour;
}
// public accessor methods
public void DisplayCurrentTime()
{
System.Console.WriteLine("{0}/{1}/{2} {3}:{4}:{5}",
Month, Date, Year, Hour, Minute, Second);
}
public void GetTime(int h, int m, int s)
{
h = Hour;
m = Minute;
s = Second;
}
// constructor
public Time3(System.DateTime dt)
{
Year = dt.Year;
Month = dt.Month;
Date = dt.Day;
Hour = dt.Hour;
Minute = dt.Minute;
Second = dt.Second;
}

}
public class PassByRefTester
{
public void Run()
{
System.DateTime currentTime = System.DateTime.Now;
Time3 t = new Time3(currentTime);
t.DisplayCurrentTime();
int theHour = 0;
int theMinute = 0;
int theSecond = 0;
t.GetTime(theHour, theMinute, theSecond);
System.Console.WriteLine("Current time: {0}:{1}:{2}",
theHour, theMinute, theSecond);
}
static void Main()
{
PassByRefTester t = new PassByRefTester();
t.Run();
}
}
}

</source>

==Pass value by reference with read only value==

<source lang="csharp">
/*
Learning C#
by Jesse Liberty
Publisher: O"Reilly
ISBN: 0596003765
*/
using System;
namespace PassByRef
{
public class Time
{
// private member variables
private int Year;
private int Month;
private int Date;
private int Hour;
private int Minute;
private int Second;
// Property (read only)
public int GetHour()
{
return Hour;
}
// public accessor methods
public void DisplayCurrentTime()
{
System.Console.WriteLine("{0}/{1}/{2} {3}:{4}:{5}",
Month, Date, Year, Hour, Minute, Second);
}
// takes references to ints
public void GetTime(ref int h, ref int m, ref int s)
{
h = Hour;
m = Minute;
s = Second;
}
// constructor
public Time(System.DateTime dt)
{
Year = dt.Year;
Month = dt.Month;
Date = dt.Day;
Hour = dt.Hour;
Minute = dt.Minute;
Second = dt.Second;
}

}
public class TesterPassByRef
{
public void Run()
{
System.DateTime currentTime = System.DateTime.Now;
Time t = new Time(currentTime);
t.DisplayCurrentTime();
int theHour = 0;
int theMinute = 0;
int theSecond = 0;
// pass the ints by reference
t.GetTime(ref theHour, ref theMinute, ref theSecond);
System.Console.WriteLine("Current time: {0}:{1}:{2}",
theHour, theMinute, theSecond);
}
static void Main()
{
TesterPassByRef t = new TesterPassByRef();
t.Run();
}
}
}

</source>

==Ref and Out Parameters 2==

<source lang="csharp">
using System;
class Point
{
public Point(int x, int y)
{
this.x = x;
this.y = y;
}

public void GetPoint(out int x, out int y)
{
x = this.x;
y = this.y;
}

int x;
int y;
}
public class RefOutParameters3
{
public static void Main()
{
Point myPoint = new Point(10, 15);
int x;
int y;

myPoint.GetPoint(out x, out y);
Console.WriteLine("myPoint({0}, {1})", x, y);
}
}

</source>

==Ref and Out Parameters: compiling error==

<source lang="csharp">
// error
using System;
class Point
{
public Point(int x, int y)
{
this.x = x;
this.y = y;
}
// get both values in one function call
public void GetPoint(ref int x, ref int y)
{
x = this.x;
y = this.y;
}

int x;
int y;
}
public class RefOutParameters {
public static void Main()
{
Point myPoint = new Point(10, 15);
int x;
int y;

// illegal
myPoint.GetPoint(ref x, ref y);
Console.WriteLine("myPoint({0}, {1})", x, y);
}
}

</source>

==Simple types are passed by value==

<source lang="csharp">
/*
C#: The Complete Reference
by Herbert Schildt
Publisher: Osborne/McGraw-Hill (March 8, 2002)
ISBN: 0072134852
*/
// Simple types are passed by value.

using System;

class Test {
/* This method causes no change to the arguments
used in the call. */
public void noChange(int i, int j) {
i = i + j;
j = -j;
}
}

public class CallByValue {
public static void Main() {
Test ob = new Test();

int a = 15, b = 20;

Console.WriteLine("a and b before call: " +
a + " " + b);

ob.noChange(a, b);

Console.WriteLine("a and b after call: " +
a + " " + b);
}
}

</source>

==Swap two references==

<source lang="csharp">
/*
C#: The Complete Reference
by Herbert Schildt
Publisher: Osborne/McGraw-Hill (March 8, 2002)
ISBN: 0072134852
*/
// Swap two references.

using System;

class RefSwap {
int a, b;

public RefSwap(int i, int j) {
a = i;
b = j;
}

public void show() {
Console.WriteLine("a: {0}, b: {1}", a, b);
}

// This method now changes its arguments.
public void swap(ref RefSwap ob1, ref RefSwap ob2) {
RefSwap t;

t = ob1;
ob1 = ob2;
ob2 = t;
}
}

public class RefSwapDemo {
public static void Main() {
RefSwap x = new RefSwap(1, 2);
RefSwap y = new RefSwap(3, 4);

Console.Write("x before call: ");
x.show();

Console.Write("y before call: ");
y.show();

Console.WriteLine();

// exchange the objects to which x and y refer
x.swap(ref x, ref y);

Console.Write("x after call: ");
x.show();

Console.Write("y after call: ");
y.show();

}
}

</source>

==Swap two values==

<source lang="csharp">
/*
C#: The Complete Reference
by Herbert Schildt
Publisher: Osborne/McGraw-Hill (March 8, 2002)
ISBN: 0072134852
*/
// Swap two values.

using System;

class Swap {
// This method now changes its arguments.
public void swap(ref int a, ref int b) {
int t;

t = a;
a = b;
b = t;
}
}

public class SwapDemo {
public static void Main() {
Swap ob = new Swap();

int x = 10, y = 20;

Console.WriteLine("x and y before call: " + x + " " + y);

ob.swap(ref x, ref y);

Console.WriteLine("x and y after call: " + x + " " + y);
}
}

</source>

==Use out==

<source lang="csharp">
/*
C#: The Complete Reference
by Herbert Schildt
Publisher: Osborne/McGraw-Hill (March 8, 2002)
ISBN: 0072134852
*/
// Use out.

using System;

class Decompose {

/* Decompose a floating-point value into its
integer and fractional parts. */
public int parts(double n, out double frac) {
int whole;

whole = (int) n;
frac = n - whole; // pass fractional part back through frac
return whole; // return integer portion
}
}

public class UseOut {
public static void Main() {
Decompose ob = new Decompose();
int i;
double f;

i = ob.parts(10.125, out f);

Console.WriteLine("Integer portion is " + i);
Console.WriteLine("Fractional part is " + f);
}
}

</source>

==Use ref to pass a value type by reference==

<source lang="csharp">
/*
C#: The Complete Reference
by Herbert Schildt
Publisher: Osborne/McGraw-Hill (March 8, 2002)
ISBN: 0072134852
*/
// Use ref to pass a value type by reference.

using System;

class RefTest {
/* This method changes its arguments.
Notice the use of ref. */
public void sqr(ref int i) {
i = i * i;
}
}

public class RefDemo {
public static void Main() {
RefTest ob = new RefTest();

int a = 10;

Console.WriteLine("a before call: " + a);

ob.sqr(ref a); // notice the use of ref

Console.WriteLine("a after call: " + a);
}
}

</source>

==Use regular parameter with a params parameter==

<source lang="csharp">
/*
C#: The Complete Reference
by Herbert Schildt
Publisher: Osborne/McGraw-Hill (March 8, 2002)
ISBN: 0072134852
*/
// Use regular parameter with a params parameter.

using System;

class MyClass {
public void showArgs(string msg, params int[] nums) {
Console.Write(msg + ": ");

foreach(int i in nums)
Console.Write(i + " ");

Console.WriteLine();
}
}

public class ParamsDemo2 {
public static void Main() {
MyClass ob = new MyClass();

ob.showArgs("Here are some integers",
1, 2, 3, 4, 5);

ob.showArgs("Here are two more",
17, 20);

}
}

</source>

==Use two out parameters==

<source lang="csharp">
/*
C#: The Complete Reference
by Herbert Schildt
Publisher: Osborne/McGraw-Hill (March 8, 2002)
ISBN: 0072134852
*/
// Use two out parameters.

using System;

class Num {
/* Determine if x and v have a common denominator.
If so, return least and greatest common denominators in
the out parameters. */
public bool isComDenom(int x, int y,
out int least, out int greatest) {
int i;
int max = x < y ? x : y;
bool first = true;

least = 1;
greatest = 1;

// find least and treatest common denominators
for(i=2; i <= max/2 + 1; i++) {
if( ((y%i)==0) & ((x%i)==0) ) {
if(first) {
least = i;
first = false;
}
greatest = i;
}
}

if(least != 1) return true;
else return false;
}
}

public class DemoOut {
public static void Main() {
Num ob = new Num();
int lcd, gcd;

if(ob.isComDenom(231, 105, out lcd, out gcd)) {
Console.WriteLine("Lcd of 231 and 105 is " + lcd);
Console.WriteLine("Gcd of 231 and 105 is " + gcd);
}
else
Console.WriteLine("No common denominator for 35 and 49.");

if(ob.isComDenom(35, 51, out lcd, out gcd)) {
Console.WriteLine("Lcd of 35 and 51 " + lcd);
Console.WriteLine("Gcd of 35 and 51 is " + gcd);
}
else
Console.WriteLine("No common denominator for 35 and 51.");

}
}

</source>

← Предыдущая	Версия 15:31, 26 мая 2010
(нет различий)

Csharp/C Sharp/Language Basics/Parameters Passing - История изменений

в 15:31, 26 мая 2010

Admin: 1 версия