CODEWITHSUNDEEP
c++variableslocalinitialization
WJR
WJR

Reputation: 340

C++ compiler warning(?) when passing uninitialized local variable to function

I'm very new to C++ so I'm hoping someone would shed some light. I came across several similar topics but I just need clarification.

So it seems it's valid to pass a local string that has been declared but not initialized to a function. But why does compiler complain when you try it with int or float??

Whether it's string, float, or int, memory address gets referenced when it is declared even tho it may be "garbage"

#include <iostream>
using namespace std;

void load(int);

int main()
{
    int salary;
    load(salary);
    return 0;
}

void load(int sal)
{
    cout << "your salary: " << endl;
    cin >> sal;
    cout << sal << endl;
}

If I declare int or float as global variable, it works as expected without any warnings. So then is it a better practice to declare variable in global space (I hope not)?

So putting it in global, it works :

#include <iostream>
using namespace std;

int salary;
void load(int);

int main()
{
    load(salary);
    return 0;
}

void load(int sal)
{
    cout << "your salary: " << endl;
    cin >> sal;
    cout << sal << endl;
}

ok, another example to show that uninitialized global variable works when passing to function as value : (going off of David's comment)

int foo; 
int returnit(int j)
{ 
    cout << "your salary";
    cin >> j;
    return j; 
} 
int main() 
{ 
    int k = returnit(foo);
    cout << k; 
    return 0;
}

anyways, lesson here is to initialize primitive data types before passing to functions.

Upvotes: 0

Views: 5536

Answers (4)

jamesdlin
jamesdlin

Reputation: 89985

So it seems it's valid to pass a local string that has been declared but not initialized to a function. But why does compiler complain when you try it with int or float??

If by "string" you mean a std::string object, it's because objects are never uninitialized. When you do:

std::string s;

then the default constructor of std::string is invoked, and the object is initialized.

Variables of primitive data types (such as int and float), unless declared to have static storage duration, will have garbage if not explicitly initialized, however. Making attempts to read and use that garbage rightly trigger warnings. (Variables of primitive data types that do have static storage duration (i.e., global variables or variables declared as static) are implicitly initialized to 0.)

So then is it a better practice to declare variable in global space (I hope not)?

No, a better practice would be to initialize your variables.

Upvotes: 5

Joshua
Joshua

Reputation: 21

The best way to explain why you should never use an uninitialized variable in a function call is because this is logically invalid and sometimes both logically invalid and the syntax is invalid.

To see if your program is logically valid use the box method and trace your program. Global box has global variables in it, int main has its own box which holds its local variables, and when functions are called create a new box for that function and fill it with its parameters and local variables. Go line by line and change variable values as they change in the program. Remember to use only constants as global variables. When writhing a function be careful when you pass by reference that you understand that the function is given that variables address in memory and can change that value. When using pass by value use this kind of syntax in your functions declaration: 

int Multiplication(const int Var1, const int Var2);

This protects the values you pass to multiplication.The syntax of c++ is made for speed, and it does not keep you from being logically incorrect.

Upvotes: 2

Asaf
Asaf

Reputation: 4407

To add on David's answer, what you probably wanted to do (I'm guessing) is to modify the original salary variable. To do this you need to pass a reference to the variable, like this:

void load(int& sal)
{
    cout << "your salary: " << endl;
    cin >> sal;
    cout << sal << endl;
}

Note the '&' after int in the function signature.

Also note that you use 'salary' in load() where it's not defined. You should use 'sal' instead.

That way the compiler knows that load() receives a reference to a variable, so if you modify it inside the function, the variable you sent to the function (salary) also changes.

The call itself to the function remains the same.

Upvotes: 0

David Schwartz
David Schwartz

Reputation: 182769

int salary;
load(salary);

What value do you think you are passing to load here? You're passing a nonsense value.

To be clear, you are not passing an "uninitialized variable", you are passing the value of an uninitialized variable. If you do:

int j=3;
load(j);

You are passing the value of j, that is, 3, to load. If you don't specify otherwise, C++ passes by value.

You'd have the same problem with a global variable:

int foo;

int returnit(int j)
{
    return j;
}

int main(void)
{
    int j=returnit(foo);

What value do you think j should have here?! You still have to initialize a variable to some particular value before you can pass its value to a function.

Upvotes: 1

Related Questions