Question about function parameter

Dev Shed Forums Sponsor:

May 9th, 2008, 07:50 AM

JohnFish

Contributing User

Join Date: Sep 2005

Posts: 157

Time spent in forums: 1 Day 15 h 29 m 39 sec
Reputation Power: 4

Question about function parameter

Hi all. I have two functions A and B. Their functionality is listed below:

A does some processing stuff with the data
A loops through the data and adds their values (say int) together
A returns an int result

B does some processing stuff with the data
B loops through the data and multiplies their values (say int) together
B returns an int result

What i want to do is have one function and be able to specify what function to execute when that point reaches. Something like AB(sum)

I know this is probably done with delegates but i am not sure how.

thx

May 9th, 2008, 08:08 AM

f'lar

Senior WeyrLeader

Join Date: Aug 2003

Location: WI

Posts: 3,892

Time spent in forums: 1 Month 1 Week 5 Days 9 h 11 m 26 sec
Reputation Power: 788

C# or VB?

Here's a VB version:

Code:

    Sub Test()
        Dim data As New List(Of Integer)
        data.Add(1)
        data.Add(2)
        data.Add(3)
        data.Add(4)

        Dim product As Integer = Aggregate(data, AddressOf mult)
        Dim sum As Integer = Aggregate(data, AddressOf add)
        MsgBox("Product: " & product & vbCrLf & "Sum: " & sum)
    End Sub

    Function Aggregate(ByVal data As IEnumerable(Of Integer), ByVal method As AggregateDelegate) As Integer
        Return method(data)
    End Function

    Delegate Function AggregateDelegate(ByVal data As IEnumerable(Of Integer)) As Integer

    Function add(ByVal data As IEnumerable(Of Integer)) As Integer
        add = 0
        For Each i As Integer In data
            add += i
        Next
    End Function
    Function mult(ByVal data As IEnumerable(Of Integer)) As Integer
        mult = 1
        For Each i As Integer In data
            mult *= i
        Next
    End Function

Notice that the signatures for add() and mult() must match the signature for AggregateDelegate. The C# is even cooler because you can use anonymous methods: you don't have to declare the mult and add functions separately, but can pass the logic in line.

__________________
Primary Forums: .Net Development, MS-SQL, C Programming
VB.Net: It's not your father's Visual Basic.

[Moving to ASP.Net] | [.Net Dos and Don't for VB6 Programmers]

Last edited by f'lar : May 9th, 2008 at 08:15 AM.

May 9th, 2008, 09:58 AM

WebDunce

Contributing User

Join Date: Nov 2005

Location: Northwest Florida

Posts: 188

Time spent in forums: 3 Days 11 h 28 m 25 sec
Reputation Power: 5

...deleted by me...

Last edited by WebDunce : May 9th, 2008 at 10:22 AM.

May 9th, 2008, 10:02 AM

WebDunce

Contributing User

Join Date: Nov 2005

Location: Northwest Florida

Posts: 188

Time spent in forums: 3 Days 11 h 28 m 25 sec
Reputation Power: 5

...deleted by me...

Last edited by WebDunce : May 9th, 2008 at 10:22 AM.

May 9th, 2008, 10:13 AM

WebDunce

Contributing User

Join Date: Nov 2005

Location: Northwest Florida

Posts: 188

Time spent in forums: 3 Days 11 h 28 m 25 sec
Reputation Power: 5

Of course, another way is to have an add method and a multiply method call the common processing method.

Code:

private int[] PreProcessData(int[] data)
{
    // do some basic processing to the data
    // and return the modified data
}

public int AddThem(int[] data)
{
     int[] modifiedData = PreProcessData(data);

     int result = 0;
     for (i = 0; i < modifiedData.Length; i++)
     {
          result += modifiedData[i];
     }

     return result;
}

public int MultiplyThem(int[] data)
{
     int[] modifiedData = PreProcessData(data);

     int result = 1;
     for(int i = 0; i < modifiedData.Length; i++)
     {
          result *= modifiedData[i];
     }

     return result;
}

Now, whether you call AddThem() or MultiplyThem()...the common processing gets done. This is probably how I'd actually do it in a real program...but if you're doing an assignment you gotta do it however it was specified...I'm just showing options.

Last edited by WebDunce : May 9th, 2008 at 10:20 AM.

May 9th, 2008, 10:27 AM

WebDunce

Contributing User

Join Date: Nov 2005

Location: Northwest Florida

Posts: 188

Time spent in forums: 3 Days 11 h 28 m 25 sec
Reputation Power: 5

It's overkill for your simple goal...but another way would be to create an abstract DataProcessor class that could be subclassed to add, multiply, divide, substract...or whatever...that could be passed into the processing method.

Below I demonstrate how an abstract class would work.

Code:

// define the abstract class
public abstract class DataProcessor
{
    // just need to define one abstract method
    public abstract int GetResult(int[] data);
}

// define a class that adds
public class Adder : DataProcessor
{
     // implement the abstract method
     public override int GetResult(int[] data)
     {
          int result = 0;
          for (int i = 0; i < data.Length; i++)
          {
               result += data[i];
          }
          return result;
     }
}
 
// define a class that multiplies
public class Multiplier : DataProcessor
{
    // implement the abstract method
     public override int GetResult(int[] data)
     {
          int result = 1;
          for (int i = 0; i < data.Length; i++)
          {
               result *= data[i];
          }
          return result;
     }

}

Now...to see how the classes above would be used...

Code:

// some random method that calls your
// desired method
void SomeMethod(int[] data)
{
     // if you want to add
     int sum = ProcessData(data, new Adder());

     // if you want to multiply
     int product = ProcessData(data, new Multiplier());
}

// this is the single method that does
// the processing as required
int ProcessData(int[] data, DataProcessor dataProcessor)
{
     // do some general processing to
     // modify the data

     return dataProcessor.GetResult(data);
}

Now any object that subclasses DataProcessor can be an argument in the ProcessData method. Again, it's overkill for this problem, though.

Last edited by WebDunce : May 9th, 2008 at 10:35 AM.

May 9th, 2008, 11:19 AM

f'lar

Senior WeyrLeader

Join Date: Aug 2003

Location: WI

Posts: 3,892

Time spent in forums: 1 Month 1 Week 5 Days 9 h 11 m 26 sec
Reputation Power: 788

Lol, as long as we're going to town on this one, here's another delegate version that isolates the arithmetic operation, so you can easily do it as a lambda later if you want:

Code:

    Sub Test()
        Dim data As New List(Of Integer)
        data.Add(1)
        data.Add(2)
        data.Add(3)
        data.Add(4)

        Dim product As Integer = Aggregate(data, AddressOf mult)
        Dim sum As Integer = Aggregate(data, AddressOf add)
        MsgBox("Product: " & product & vbCrLf & "Sum: " & sum)
    End Sub

    Function Aggregate(ByVal data As IEnumerable(Of Integer), ByVal method As AggregateDelegate) As Integer
        Dim total As Integer
        Dim started As Boolean = False
        For Each i As Integer In data
            If Not started Then
                total = i
                started = True
            Else
                total = method(total, i)
            End If
        Next i
        Return total
    End Function

    Delegate Function AggregateDelegate(ByVal val1 As Integer, ByVal val2 As Integer) As Integer

    Function add(ByVal val1 As Integer, ByVal val2 As Integer) As Integer
        Return val1 + val2
    End Function

    Function mult(ByVal val1 As Integer, ByVal val2 As Integer) As Integer
        Return val1 * val2
    End Function

Notice that the test function didn't change, but if this were C# and wanted to use an anonymous function, the code would be much simpler.

Last edited by f'lar : May 9th, 2008 at 11:34 AM.

May 9th, 2008, 04:43 PM

JohnFish

Contributing User

Join Date: Sep 2005

Posts: 157

Time spent in forums: 1 Day 15 h 29 m 39 sec
Reputation Power: 4

Quote:

Originally Posted by f'lar

Lol, as long as we're going to town on this one, here's another delegate version that isolates the arithmetic operation, so you can easily do it as a lambda later if you want:

Code:

    Sub Test()
        Dim data As New List(Of Integer)
        data.Add(1)
        data.Add(2)
        data.Add(3)
        data.Add(4)

        Dim product As Integer = Aggregate(data, AddressOf mult)
        Dim sum As Integer = Aggregate(data, AddressOf add)
        MsgBox("Product: " & product & vbCrLf & "Sum: " & sum)
    End Sub

    Function Aggregate(ByVal data As IEnumerable(Of Integer), ByVal method As AggregateDelegate) As Integer
        Dim total As Integer
        Dim started As Boolean = False
        For Each i As Integer In data
            If Not started Then
                total = i
                started = True
            Else
                total = method(total, i)
            End If
        Next i
        Return total
    End Function

    Delegate Function AggregateDelegate(ByVal val1 As Integer, ByVal val2 As Integer) As Integer

    Function add(ByVal val1 As Integer, ByVal val2 As Integer) As Integer
        Return val1 + val2
    End Function

    Function mult(ByVal val1 As Integer, ByVal val2 As Integer) As Integer
        Return val1 * val2
    End Function

Notice that the test function didn't change, but if this were C# and wanted to use an anonymous function, the code would be much simpler.

Thanks for all the answers here. Actually it is c sharp but i really dont want to make it as complex as creating new classes etc. The thing is that i have a set of 10 functions that do exactly the same but are different in the way they treat data (e.g. sum, subtract, multiply, divide, etc.). I really dont want to rewrite the function 10 times. I have done the pre-processor approach mentioned earlier but i really want to use some sort of a function pointer.

May 11th, 2008, 03:27 AM

WebDunce

Contributing User

Join Date: Nov 2005

Location: Northwest Florida

Posts: 188

Time spent in forums: 3 Days 11 h 28 m 25 sec
Reputation Power: 5

Using Delegates in C# Is Easy...

Using delegates in C# is easy; it involves 4 basic steps:

Declare a delegate type. A delegate declaration follows the following formula: access modifier + delegate keyword + return type + type name {you make this part up} + (arguments). A delegate can be declared inside OR outside of classes.

csharp Code:

Original - csharp Code
// declare the delegate public delegate int SimpleMathMethod(int value1, int value2);

// declare the delegate
public delegate int SimpleMathMethod(int value1, int value2);

Make methods whose signatures match the delegate's signature. A method's signature is its return type and arguments. The access modifier (e.g., public, private, etc.) is NOT part of the signature.

csharp Code:

Original - csharp Code

// a method with a matching signature
protected int AddTwoInts(int a, int b)
{
    return a + b;
}
 
// here's another one
public int MultiplyTwoInts(int x, int y)
{
    return x * y;
}
 
// and another one
int DoCrazyPointlessStuff(int hubba, int bubba)
{    
    int bubbleGum = hubba + bubba; // add the two ints
    bubbleGum = hubba * bubba; // multiply them
    bubbleGum = hubba / bubba; // divide them
    return 8; // man, those Crazy Eights :)!
}

Instantiate the delegates.

csharp Code:

Original - csharp Code

// just pass the desired method's name
// into the delegate's constructor
SimpleMathMethod addMethod = new SimpleMathMethod(AddTwoInts);
SimpleMathMethod multiplyMethod = new SimpleMathMethod(MultiplyTwoInts);
SimpleMathMethod crazyMethod = new SimpleMathMethod(DoCrazyPointlessStuff);
 
// you don't have to do a formal variable declaration
// each time. you can just instantiate it, if desired...
int x = DoSomething(2, 3, new SimpleMathMethod(AddTwoInts));

Use the delegates .

csharp Code:

Original - csharp Code

// use the delegate directly...
int sum1 = addMethod(1, 2);
int product1 = multiplyMethod(3, 8);
int crazyResult1 = crazyMethod(2, 5);
 
// ...or pass them into methods that can take
// SimpleMathMethod objects as arguments
int[] threeInts = new int[]{1, 2, 3};
int sum2= ProcessSomeInts(threeInts, addMethod);
int product2 = ProcessSomeInts(threeInts, multiplyMethod);
int crazyResult2 = ProcessSomeInts(threeInts, crazyMethod);
 
// here's such a method
int ProcessSomeInts(int[] someInts, SimpleMathMethod smMethod)
{
    int result = 0;
    for (int i = 0; i < someInts.Length; i++)
    {
        if(i == 0)
            result = someInts[i];
        else
            result = smMethod(result, someInts[i]); // using the delegate directly again
    }
    return result;
}

Last edited by WebDunce : May 11th, 2008 at 04:22 AM.

Thread Tools	Search this Thread
Email this Page	Search this Thread: Advanced Search
Display Modes	Rate This Thread
Linear Mode Switch to Hybrid Mode Switch to Threaded Mode