Function power C++ - c++

I need to write need a function to compute power in C++
I don't understand why my code below is wrong.
ex. : base: 2 exponent 3 -> result: 4.48498e-306
if i use "int" the result is -> 2
#include <iostream>
#include <cstdlib>
#include <cmath>
using namespace std;
double power(double base, double exponent);
int main()
{
double base, exponent, power;
cout << "Enter a base " << endl;
cin >> base;
cout << "Enter an exponent" << endl;
cin >> exponent;
cout << "The result is ': "<< power << endl;
return 0;
}
double power(double base, double exponent)
{
int i;
double s=1;
for (i = 0; i < exponent; ++i)
s *= base;
return s;
}
What am I doing wrong?

In your code you have two declarations of power.
double power(double base, double esponente);
double base,esponente,power;
You declare the variable power but you never initialize it before printing it, so it's going to be undefined. Rerunning your program will actually give you a different number, in all likelihood. You need to remove this local variable declaration, as it shadows the global function declaration.
Then, instead of
cout<<"\nL'elevamento a potenza e': "<<power<<endl;
You want this line:
cout<<"\nL'elevamento a potenza e': "<<power(base, esponente)<<endl;

You are either printing the address of the function power or printing the uninitialized value of the double power the way you have written the code. (Technically you are hitting an uninitialized shadowed variable). In any case, you are not even calling the function you wrote... How does the power function know to be called? With what arguments?
Fix 1. Suggest you delete the 'double' of power.
Fix 2. Actually call the function and use/store/print the result
example.
After getting input from user do this:
double result = power( base, exponent );
cout << result << endl;
To print the result.

You need call function like this, with parameters:
Here is your main. You don't need local variable power. You want call function with name power.
int main ()
{
double base,esponente;
cout<<" \n Inserisci base \n";
cin>>base;
cout<<"\nInserisci esponente\n";
cin>>esponente;
cout<<"\nL'elevamento a potenza e': "<<power(base,esponente)<<endl;
system ("PAUSE");
}

Related

How do variables between functions and void functions work / interact with each other?

Watching this https://youtu.be/_bYFu9mBnr4 tutorial.From what I understand functions and void functions can be called and they would perform the code within them.
However I don't understand the purpose of the variables within the parenthesis. The code won't work if even one of them is missing. However it seems like you can assign theses variables different names and it could still work.
How do these variables connect / interact with each other? Referring to:
1.) double power (double base, int exponent)
2.) void print_pow (double base, int exponent)
3.) print_pow (base, exponent);
#include <iostream>
#include <cmath>
using namespace std;
double power(double base, int exponent)
{
double result = 1;
for(int i=0; i < exponent; i++)
{
result = result * base;
}
return result;
}
void print_pow(double base, int exponent)
{
double myPower = power (base, exponent);
cout << base << " raised to the " << exponent << " power is " << myPower << ". \n ";
}
int main()
{
double base;
int exponent;
cout << "What is the base?: ";
cin >> base;
cout << "What is the exponent?: ";
cin >> exponent;
print_pow(base, exponent);
}
Imagine this code, by itself, alone:
double power ()
{
double result = 1;
for(int i=0; i < exponent; i++)
{
result = result * base;
}
return result;
}
Can you tell me what is base and exponent and where they came from?
The answer is no. If you can't say, neither can the compiler. In my code, base and exponent has not been declared.
These are called function parameters. They are exactly what they sound like. A good analogy could be made with the mathematical notation:
f(x) = x * 2
In the parenthesis lies the parameters of the function.
Now consider a code very similar to your, but with the name of the parameter changed:
double power(double base, int exponent)
{
double result = 1;
for(int i=0; i < exponent; i++)
{
result = result * base;
}
return result;
}
// Name changed! ----v------v
void print_pow(double b, int e)
{
double myPower = power(b, e);
cout << base << " raised to the " << exponent << " power is " << myPower << ". \n ";
}
As you can see, parameters can be mapped to each other independently of their names. base will take the value of b and exponent will take the value of e.
An important property of function parameter is that they act just like local variable. Such local entity is not influenced by the name of an external entity. So if inside your code they are multiple variables named base and exponent, they are distinct entity since they have different scopes.
If you'd like, you could write such function:
void print_pow2(double base, int exponent)
{
double myPower = power(base * 2, 3);
cout << base << " raised to the " << exponent << " power is " << myPower << ". \n ";
}
As you can see, even though the name is the same, base and exponent won't have the same value inside power. You can even notice that the exponent inside power will have no relation to the exponent in print_power2 as I sent the constant 3.
If I do an analogy to the mathematical notation again:
f(x) = x * 2
g(x) = f(x * 2) / 3
Even though g and f have both x as parameter, that x is different and take up a different value in each functions.
The naming scheme applied here is a bit unfortunate. The names of those variables could be almost anything, and it is advisable to spend some time to find good names. Though, to merely illustrate that they are different entities, I just made them different:
#include<iostream>
#include<cmath>
using namespace std;
double power (double base, int exponent)
{
double result = 1;
for(int i=0; i < exponent; i++)
{
result = result * base;
}
return result;
}
void print_pow(double a, int b)
{
double myPower = power (a, b);
cout << a << " raised to the " << b << " power is " << myPower << ". \n ";
}
int main()
{
double x;
int y;
cout << "What is the base?: ";
cin >> x;
cout << "What is the exponent?: ";
cin >> y;
print_pow(x, y);
}
Variables are declared in a certain scope. Only within this scope you can access the variable. In your code there are 3 different variables called base. There is no magic relation between then, just because they share the same name. They are "connected" by calling the function with parameters print_pow(x,y), the name of parameters is not relevant for the function and the name of the functions arguments are not that relevant for the caller (other than giving a hint on what the argument is used for).
How do these variables connect / interact with each other?
There is no relation between the names of your function parameters and the names of other variables used outside of the function.
They are different variables, and it doesn't matter whether or not their names match.
When you define parameters such as double base, int exponent. in...
double power (double base, int exponent)
{
double result = 1;
for(int i=0; i < exponent; i++)
{
result = result * base;
}
return result;
}
... you are telling the compiler that any values passed to your function power will become new variables double base and int exponent inside of your function.
When your function completes, those new variables no longer exist.

C++ Problem I get "nan" as output everytime I run my program

I was required to create a program with a function that changes height in feet to height in meters. I made the function and when I cout from the function I get the right value but when I cout it in main I get "nan". I dont understand why the value is not printing. This is my first time using this website so I am sorry if I miss anything.
#include <iostream>
#include <iomanip>
#include <cmath>
using namespace std;
double heightInMeters(double feet , double inches)
{
double footToMeter = 0.305;
double inchToMeter = 0.0254;
double heightInMeters = ((footToMeter * feet) + (inchToMeter * inches));
cout << heightInMeters << endl;
}
int main()
{
double feet, inches, calcheight;
char ch;
cout << "Enter your height [Use format ft-in]: ";
cin >> feet >> ch >> inches;
calcheight = heightInMeters(feet, inches);
cout << calcheight << endl;
return 0;
}
This function here:
double heightInMeters(double feet , double inches)
{
double footToMeter = 0.305;
double inchToMeter = 0.0254;
double heightInMeters = ((footToMeter * feet) + (inchToMeter * inches));
cout << heightInMeters << endl;
}
isn't returning anything. That's undefined behavior, what you get here
calcheight = heightInMeters(feet, inches);
Is most likely just some invalid rubbish value then. Perhaps instead of this:
cout << heightInMeters << endl;
You wanted this:
return heightInMeters;
Does your compiler issue any warnings for your code? If not, please try to find out if you can set it to give you more warnings. Most compilers usually complain about missing returns.
heightInMeters doesn't have an explicit return value.
Therefore, since it's not a void function (or main), the behaviour of your program is undefined.
Didn't your compiler warn you of that? It's an easy spot for a compiler to make in your case, and the current crop of compilers all warn if you turn the warning level up appropriately.
(Granted, NaN is a peculiar manifestation of that undefined behaviour.)
Finally, note that one foot is exactly 0.3048 meters. Base your conversion metrics from that. Your values introduce unnecessary imprecision.
void f()
{
double a=0.3;
cout << a << endl;
}
//
// inside main function
f();
double f()
{
double a=0.3;
return a;
}
// inside main function
cout << f() << endl;
Because the return value of your code is not specified, the output is “nan“

Paint Job Estimator C++

Hi I am working on a project for school and cannot for the life of me figure out how to get the totalJobCost function to work. The other functions work without a problem but i don't think they are passing the var back to main for totalJobCost to grab as the totalJobCost outputs 0. here is the code that i am using:
#include "stdafx.h"
#include <iostream>
using namespace std;
void space(double paintarea, double paintcost, double paintneeded, double totalpaint);
void cost(double hrs, double hrcost, double spacetopaint);
void totalJobCost(double allTheirPaintCost, double allTheirWages, double theirTotalJobCost);
const double AREA_FORMULA = 220.00;
const double AREAFORMULA_PAINT = 1.00;
const double AREAFORMULA_HOURS = 8.00;
const double AREAFORMULAHOURS_WAGES = 35.00;
int main()
{
double areaTP;
double paintCST = 0;
double paintNeeded = 0;
double allPaintCost = 0;
double hoursNeeded = 0;
double hoursWages = 0;
double allWages = 0;
double allJobCost = 0;
cout << "Enter the square footage you need to paint, then press enter" << endl;
cin >> areaTP;
cout << "Enter the price by gallons of paint you will use, then press enter" << endl;
cin >> paintCST;
while (paintCST < 10)
{
cout << "Enter the price by gallons of paint you will use, then press enter. cannot be less than 10 :";
cin >> paintCST;
}
space(areaTP, paintCST, paintNeeded, allPaintCost);
cost(hoursNeeded, hoursWages, areaTP);
totalJobCost(allPaintCost, hoursWages, allJobCost);
system("Pause");
return 0;
}
void space(double paintarea, double paintcost, double paintneeded, double totalpaint)
{
paintneeded = paintarea / AREA_FORMULA * AREAFORMULA_PAINT;
totalpaint = paintneeded * paintcost;
cout << "How many gallons of paint you will need: " << paintneeded << endl;
cout << "Your total paint cost will be: " << totalpaint << endl;
}
void cost(double hrs, double hrcost, double spacetopaint)
{
hrs = (spacetopaint / AREA_FORMULA) * AREAFORMULA_HOURS;
hrcost = hrs * AREAFORMULAHOURS_WAGES;
cout << "The number of hours for the job will be: " << hrs << endl;
cout << "The total amount of wages will be: " << hrcost << endl;
}
void totalJobCost(double totalpaint, double hrcost, double theirTotalJobCost)
{
theirTotalJobCost = totalpaint + hrcost;
cout << "The total price of your paint job will be: " << theirTotalJobCost << endl;
}
You need to declare your arguments (totalpaint and hrcost) as references.
Currently, functions space() and cost() just make copies of totalpaint and hrcost when called, update them, then print them. But when the functions return, the values stored in totalpaint and hrcost are lost.
To fix this, you should declare those functions as follows:
void space(double paintarea, double paintcost, double paintneeded, double& totalpaint)
void cost(double hrs, double& hrcost, double spacetopaint)
Now whatever variable you pass in as totalpaint or hrcost will be updated when space() or cost() operates on it.
This is a pass by value vs. pass by reference issue.
In C++, booleans, characters, integer numbers, floating-point numbers,
arrays, classes—including strings, lists, dictionaries, sets, stacks,
queues—and enumerations are value types, while references and pointers
are reference types.
CPP reference
The variables you are using are doubles (double precision floating point), so they are value types. When you pass value type variables to functions as parameters, the current value of the variables is copied to the calling stack of the function you called. Once inside the function, the parameter names are just names you use to access the copied values. Whatever you do to these copied values will not affect the value of the original variables you passed to the function. Read up on function scope and the calling stack architecture of C/C++ to understand more.
To change the value of a variable across function calls, you need to pass a reference to its location in memory. If you declare a variable in the first few lines of a function, its location in memory will be part of that function’s call stack, and you can safely access that memory in any function calls that are called within the original function. So you can do this:
int main() {
double variable = 0;
function(&variable);
cout << variable;
}
void function(double* variable_address) {
*variable_address = 1.5;
}
This involves the dereference operator. Sorry if this is too much info, but pass by reference and pass by value are easier to understand if you know what’s happening in the underlying function call and memory architecture of C/C++.

Trouble understanding how elements of a certain function work

I am required to fully understand the following code :
#include <iostream>
using namespace std;
double area(double length, double width);
double time(double p_area, double h_area, double mow_rate);
int main() {
double d_plot_length, d_plot_width, d_home_side, d_mow_rate;
double plot_area, home_area, time_taken;
// I've used double for all of these to get the most precise values possible, something I'd only really consider doing on small programmes such as this
cout << "What is the length of the plot? In meters please." << endl;
cin >> d_plot_length;
cout << "What is the width of the plot? In meters please." << endl;
cin >> d_plot_width;
cout<< "What is the size of the side of the house? In meters please." << endl;
cin >> d_home_side;
cout << "What is the rate at which you are going to be mowing? In meters per minute please" << endl;
cin >> d_mow_rate;
// Just getting all the data I need from the user
plot_area = area(d_plot_length, d_plot_width);
home_area = area(d_home_side, d_home_side);
time_taken = time(plot_area, home_area, d_mow_rate);
cout << "It will take " << time_taken << " minutes to mow this lawn. Better get cracking" << endl;
return 0;
}
double area(double length, double width) {
double value;
value = length * width;
return value;
}
double time(double p_area, double h_area, double mow_rate) {
double value;
value = (p_area - h_area) / mow_rate;
return value;
}
I am struggling to understand how the time() function works.
So far I understand that :
time_taken , gets its value from the time() function: time(plot_area, home_area, d_mow_rate).
The time() function gets its values from the function declaration at the bottom.
double time(double p_area, double h_area, double mow_rate) {
double value;
value = (p_area - h_area) / mow_rate;
return value;
}
However, this is where I'm stuck. The user is asked to enter values for d_plot_length, d_plot_width, etc. So I cannot understand how the compiler knows what these values p_area, and h_area actually are.
I realise that somehow the area() function is being used to aid the time() function, but as far as I'm aware the variables P_area etc within the time() function do not have values assigned to them.
Please can someone fill in the gaps in my understanding.
To be more precise, I want to know exactly how time_taken is displayed on the screen, from the start of the process, to the cout. Like I say I am familiar with most areas but not all.
In your program, you had computed the following values:
plot_area = area(d_plot_length, d_plot_width);
home_area = area(d_home_side, d_home_side);
When the method area(double,double) is invoked, the resultant double value gets stored in these variables.
Then you have the function call:
time_taken = time(plot_area, home_area, d_mow_rate);
This is the call by value type of function invocation. A copy of the values in the variables, plot_area, home_area and d_mow_rate are passed to the function. In the time(double, double, double) the computing is done upon the basis of the logic you had defined in this method and the resultant value is returned to the function call in the main() method.
Please note that the function call is of call by value and hence only a copy of the values are passed to the arguments mentioned in the function time(double, double, double) even though the variable names are the same in the main() and in the function call.
For further reading, I will suggest you to have a look at the following links:
Call By
Value
Call By
Reference
Call By
Pointer

What's wrong in this C++ code? (Console)

To me, this code seems to have no errors, and it is correct in the way I learnt C++. What may be wrong?
This is my code:
#include<iostream>
#include<cstdlib>
#include<string>
#include<cmath>
using namespace std;
double Calculation(long double x, long double y);
void Output(long double s, long double d, long double p, long double q);
void main(){
long double a;
long double b;
long double sum;
long double difference;
long double product;
long double quotient;
cout << "Enter your first number." << endl;
cin >> a;
cout << "Enter your second number." << endl;
cin >> b;
Calculation(a, b);
Output(sum, difference, product, quotient);
system("pause");
}
double Calculation(long double x, long double y){
long double sum;
long double difference;
long double product;
long double quotient;
sum = x + y;
difference = x - y;
product = x * y;
quotient = x / y;
return sum;
return difference;
return product;
return quotient;
}
void Output(long double s, long double d, long double p, long double q){
cout << "The sum of your numbers is " << s << "." << endl;
cout << "The difference between your numbers is " << d << "." << endl;
cout << "The product of your numbers is " << p << "." << endl;
cout << "The quotient of your numbers is " << q << "." << endl;
}
Explanation: This is a calculator which works by the variables 'a' and 'b'. It calculates the sum, difference, product, and quotient of 'a' and 'b' by the function Calculate and outputs the answers with the function Output.
Error: uninitialized local variable 'quotient' used.
uninitialized local variable 'product' used.
uninitialized local variable 'difference' used.
uninitialized local variable 'sum' used.
Lots of things are wrong with your code, but there is a single root cause to this - a misunderstanding of how the return statement works.
You have a function with multiple return statements. It appears that you think that all of these statements would execute; that assumption is incorrect. Only the first return statement reached in a function is executed; the remaining ones are ignored.
Moreover, you appear to imply that return statement would influence variables in the caller automatically; it wouldn't. In order to modify a variable in the caller, the caller itself needs to assign the returned value.
If you need your function to return multiple values, you need to change the approach: it should take multiple arguments by reference, and modify them, like this:
void Calculation(long double x, long double y, long double &sum,
long double &difference, long double &product, long double &quotient) {
sum = x + y;
difference = x - y;
product = x * y;
quotient = x / y;
}
You also need to change the prototype declaration of Calculation, like this:
void Calculation(long double x, long double y, long double &sum,
long double &difference, long double &product, long double &quotient);
Call Calculation like this:
Calculation(a, b, sum, difference, product, quotient);
This will solve your compilation issue, and the code will run correctly.
The problem is that you declare the variables listed in the error message as local variables. That means that no other function will be able to use them. Declaring them again in another function declares new local variables.
In this case you might want to declare the variables as global variables. This is done by moving the definitions outside of any function, and only have that definition and not in a function.
In your main function you are not setting any values to those variables before passing them to the Output() function - therefore they are 'uninitialized'. Also, as mentioned in some comments, there are a number of other problems there too, here's a couple:
1) You can't do multiple returns in a function on the same logic path
2) You are not collecting the return of Calculation() anyway
I expect you can fix your issues by passing some of those variables by reference instead.
As others said, the direct cause of your problem is misunderstanding on how the return and scoping works.
When dealing with C++ the compiler/linker warnings can be cryptic and/or confusing. In your example, the compiler should warn you about unreachable code after first return, however Visual Studio 2013 with default default does not do that.
You can make it do that by enabling all warnings, which is a good practice anyway. In project properties go to Configuration Properties -> C/C++ -> General -> Warning level and select EnableAllWarnings.
Final advice: if you are programming for fun or learning how to program, I'd advise you to start with C# or Java, which are easier and have better tool support.