# FAQ: Functions - Parameters & Arguments

This community-built FAQ covers the “Parameters & Arguments” exercise from the lesson “Functions”.

Paths and Courses
This exercise can be found in the following Codecademy content:

## FAQs on the exercise Parameters & Arguments

There are currently no frequently asked questions associated with this exercise – that’s where you come in! You can contribute to this section by offering your own questions, answers, or clarifications on this exercise. Ask or answer a question by clicking reply () below.

If you’ve had an “aha” moment about the concepts, formatting, syntax, or anything else with this exercise, consider sharing those insights! Teaching others and answering their questions is one of the best ways to learn and stay sharp.

## Join the Discussion. Help a fellow learner on their journey.

Agree with a comment or answer? Like () to up-vote the contribution!

Found a bug? Report it!

Have a question about your account or billing? Reach out to our customer support team!

None of the above? Find out where to ask other questions here!

Inside the code:
`#include

// Define get_emergency_number() below:

void get_emergency_number(std::string emergency_number){
std::cout << "Dial " << emergency_number;
}

int main() {

// Original emergency services number
std::string old_emergency_number = “999”;

// For nicer ambulances, faster response times
// and better-looking drivers
std::string new_emergency_number = “0118 999 881 999 119 725 3”;

// Call get_emergency_number() below with
// the number you want!
get_emergency_number(new_emergency_number);

}`

How come if I put in ‘string emergency_number’ instead of ‘std::string emergency_number’ for the parameter in the ‘void get_emergency_number’ function I get an error?

4 Likes

I answered a very similar question here:

1 Like

Why doesn’t this work:
// Call get_emergency_number() below with
// the number you want!
std::cout << get_emergency_number(new_emergency_number);

But in 2/10 this works:
// Use rand() below to initialize the_amazing_random_number
int the_amazing_random_number = rand() % 500;
std::cout << the_amazing_random_number;

Hello @srinac.

If you look at the method, `get_emergency_number()`, what is its return type?

`std::cout <<` needs a value to print. The expression that follows is a method call, so the value to print will be the `return` value of the method. What does `get_emergency_number()` return?

1 Like

how can i call the new_emergency number ??

1 Like

Honestly, this exercise is kind of a confusing mess guys, sorry. It was great so far but this is pretty annoying.

I’m being asked to define a function first, but I have to put empty curly brackets before hitting Run to validate it and move on to the next instruction because the actual definition is in step 2…what?

Step 3, I must call the function with “either number”…either of which number? The old or the new? That doesn’t make any sense.

Are we talking about a new number here, or just the one you call when you want better looking drivers? Why is the variable underneath called new_emergency_number?

Why is there a string called old number? I don’t seem to need it? None of the instructions mention it?

Basically now I have fully functioning code that won’t validate a successful exercise because I can’t understand what I’m supposed to do with it.

How about you explain in practice how this function is used so I know what to do with it instead of referencing goofy TV shows and slathering your code with nonsensical comments that have nothing to do with the goal of the function?

11 Likes

Yeah I’m having the same kind of issue with this lesson. I click run to go to the next step and it says I did it wrong, and if I tell it to just show me the solution it’s exactly what I typed, plus the entire rest of the lesson. This is by far the most annoying thing I’ve experienced on Codecademy.

2 Likes

This video helped me. I agree my code wasn’t exactly the same but It worked the exact same way… not sure if thats wrong? I am sure there are best practices involved. Also the last couple of lessons don’t let you compile the code so they have taken away the ability to experiment with different ways to write the code. I also cant find the tab to report the problem.

here is the way I wrote my code.

#include

void get_emergency_number (int num){

std::cout << " The new number is: " << num << “\n”;

//the “num” argument is defined inside the the int main and called to the std::cout statement.

int main(){

// Original emergency services number
std::string old_emergency_number = “999”;

// For nicer ambulances, faster response times
// and better-looking drivers

get_emergency_number (911);

}

Now if you’re still reading I just checked to see if I could have used there number (0118 999 881 999 119 725 3). It seems that the argument for int cant take more than 8 numbers. That must be why they added a declared a separate variable.

1 Like

Im having trouble on step 3 it asks me to call it inside main

1 Like

For those having trouble:

#include

// Define get_emergency_number() below:

void get_emergency_number(std::string emergency_number){

std::cout << "Dial " << emergency_number << " ";
}

int main() {

// Original emergency services number
std::string old_emergency_number = “999”;

// For nicer ambulances, faster response times
// and better-looking drivers
std::string new_emergency_number = “0118 999 881 999 119 725 3”;

// Call get_emergency_number() below with
// the number you want!
get_emergency_number(new_emergency_number);

}

8 Likes

Hey y’all. I have tried all the solutions in this forum to no avail. It would be great to have this exercise revamped so that a result can be achieved. Very happy to see C++ on Codecademy!

yes obviously you to mention std:: before string to declare a string variable we are just decalaring a string variable in function defination for storing value

i want to know can i store numeric value in string type variable why are not we double type variable in this exercise

#include

// Define get_emergency_number() below:
void get_emergency_number(std::string emergency_number) {
std::cout << "Dial " << emergency_number;
}

int main() {

// Original emergency services number
std::string old_emergency_number = “999”;

// For nicer ambulances, faster response times
// and better-looking drivers
std::string new_emergency_number = “0118 999 881 999 119 725 3”;

// Call get_emergency_number() below with
// the number you want!

get_emergency_number(new_emergency_number);
}
this was my code that passed the exercise without errors and actually printed the correct thing.

If you try to assign an integer to a string type variable e.g.

``````int number = 52;
std::string strNum = number;
``````

you will get an error.

If you enclose the number in quotes, then it will be a valid assignment:
`std::string strNum = "52";`

If you don’t want to have to manually add quotes to the number, you can use some built-in functionality such as:

``````int number = 52;
std::string strNum = std::to_string(number);
``````

A `double` type variable won’t be quite suitable for what we are doing. If the number has spaces or dashes, then we can’t store it as a double or an int. Using a string variable avoids these issues.

#include

using namespace std;

// Define get_emergency_number() below:

void get_emergency_number(string emergency_number) {

Why do i need the string emergency_number ? how does it work if in the end i call get_emergency_number(new_emergency_number) instead of get_emergency_number(emergency_number)

The function definition

``````void get_emergency_number(std::string emergency_number) {
// Function body goes here
}
``````

indicates that this function has one parameter of type `std::string`. In other words, this function expects that it will be passed an input of type string. If we pass a string input to this function, this input will be assigned to the variable/parameter called `emergency_number`. Within our function body, if we want to display this input OR manipulate the input OR some other thing, we can do so by using the name `emergency_number` to refer to this input.

Suppose we have defined our function and now want to call it with some input.

Suppose we have stored a phone number in a string variable called `new_emergency_number`. When we make the function call `get_emergency_number(new_emergency_number)`, the string contained in the `new_emergency_number` is assigned to the parameter `emergency_number`. Within our function, we will use the name `emergency_number` to refer to this input string.

Suppose we have another phone number stores in a string variable called `old_emergency_number`. When we make the function call `get_emergency_number(old_emergency_number)`, the string contained in the `old_emergency_number` is assigned to the parameter `emergency_number`. Within our function, we will use the name `emergency_number` to refer to this input string.

I hope you see the pattern. As long as the input type matches the type specified in the function definition, we will take whatever input is passed and refer to it as `emergency_number`. This allows for abstraction and reusability. We don’t have to change our function’s body for different inputs. Whatever string is passed to the function, we simply use the parameter name` emergency_number` within our function to refer to this input.

2 Likes

omg thank you so much

Thank you, this is precisely the explanation I was looking for as I was having a mental disconnect between calling `new_emergency_number` in the main function and how it transferred the information to `emergency_number` in our function.

This explained it perfectly and I have a solid grasp on it now. Much appreciated!

1 Like