Thread: Question: Can a function be nameless?

I've been wondering about something for a while now. You can make nameless variables by allocating memory to pointers, such as

Code:

int *ptr = new int;

from the tutorial. That I understand. What I wonder, however, is if it's possible to make an unnamed function by assigning a block of code to a function pointer. For example, would this work?:

Code:

#include <cstdarg>
 
// this function should be called with only two int variables, the va_list is to access them
int (*mult)(int, int, ...) = {
va_list arglist;
va_start(arglist, 0); // will this allow access to the first variable?
return va_arg(arglist, int) * va_arg(arglist, int);
}

I know that wouldn't be very useful, and it wouldn't be good form, but is it at all possible to make a nameless function with something like this?

If so, I can think of a way to make a more secure (but cumbersome) login feature for some programs: Instead of having the sign-in box accept a password, have it accept a variable assignment as the "password". The sign-in box could be connected to an interpreter, which will read and execute this assignment. Now, if you don't actually include a function that allows the user to log in as part of the program, but instead have the user input a new function into a variable, you could prevent access to only those who know not only what steps your program needs to perform to log in, but also which function pointer to use.


(Oh, and if you're wondering about my account name, I like to use the same name on every forum, or as close to it as possible.)

I don't understand your question, really. If a function is nameless, then how could one reference it? Or do you just mean design an interpreter than can convert an input expression to some arbitrary functionality? If so, yes, but then why go to all the trouble, when conventional means are sufficient?

Or did you mean something else entirely?

There is something called lambda functions. There are available at C++0x, not C++. In other languages, as C# 3.0, you can use them. Functional languages (term?) generally use them.

I don't know if they provide security

Originally Posted by Sebastiani

I don't understand your question, really. If a function is nameless, then how could one reference it? Or do you just mean design an interpreter than can convert an input expression to some arbitrary functionality? If so, yes, but then why go to all the trouble, when conventional means are sufficient?

Or did you mean something else entirely?

What I mean is that the function itself doesn't have a name, just a pointer to it. The only way to use the function is through the function pointer. It's like how if you make a new array with new[] and assign it to a pointer, you'll only be able to access the array through that pointer, since the array itself doesn't have a name. Or how

Code:

int *ptr = new int;

from the tutorial's pointer page works: it makes an int at ptr. This int doesn't actually have a name, so the only way to use it is to go through the pointer. Similarly, I wonder if you can make a function that can only be called through a pointer to it, since the function itself doesn't actually have a name for use in function calls. Also, if it is possible to do so, I'm not sure if using

Code:

va_start(arglist, 0);

will actually allow access to the first variable, or if it'll cause an exception.

Lambdas are in C# and if they are like that in C++ I will avoid them entirely.

They have C++0x lambdas, as has been mentioned several times. Here's a simple example with lambdas. It's not the best way to do this, but it works.

Code:

#include <algorithm>
#include <iostream>
#include <string>
#include <list>

using namespace std;

int main()
{
     list<string> someList;

     someList.push_back("Test 1");
     someList.push_back("Test 2");
     someList.push_back("Test 3");

     for_each(someList.begin(), someList.end(), 
     [](string element)  //This is the start of the lambda
     { 
          cout << element << endl;  //Outputs Test 1, Test 2, Test 3
     });
     return 0;
}

I still haven't decided if they are putting lambda's in C++ for a real reason, or if they are just trying to make it more like C#. I suspect the later.

Doesn't lambda functions also help passing a function in another function. Like instead of creating a compare function for qsort() just write it when calling it. If the compare function is really small (which can be) you can avoid one function.

Like

Code:

qsort(a, b, c, [&](void* x, void* y) {int *xx= x, *yy= y; return *xx > *yy});

Nevermind the 100% correctness of the syntax but you get the point

First, I have to clarify: I probably could have worded it better, but I was talking about assigning a block of C++ code to a function pointer to dynamically make a function that didn't actually have a name. I haven't found much info on lambda functions (but then again, I admittedly haven't checked the VC++ log, and I don't exactly trust Wikipedia), though, so I had to ask. And in regards to brewbuck's post, does it have to be machine code, or would it be possible to make an interpreter that can change C++ code into machine code dynamically, so you can use it as something of a more secure password? (After all, if you were to make a program where the log-in function had to be manually inputted for a person to log in, it'd be pretty hard for someone to crack that 'password', I'd imagine. All you'd need to do is make a few functions that check whether the inputted line is code, whether it's malicious, and whether it's in the right format (specifically, if it's in the form

Code:

pointer = {code};

(or would that be

Code:

pointer = &{code};

?), and then run it when you're sure. For added security, you could design the program so that the actual variable(s) needed to store log-in information changed each day, such as by using a class to use the information, and making a new instance of the class each day (you could either design the program to email you with the new instance's name or use a set name for each day, such as login_Mon, login_Tues, etc.).)

I also thought of another use for it: debugging. You know how some IDEs allow you to change the value in variables on the fly? Well, if they allowed you to input new code and store its address in a function pointer, you could quickly try new functions during the testing phase without having to stop interpretation and rewrite the program, speeding up the process.

Well, thanks for the input.