Which approach is better from these two using hashmaps..?

Approach 1: This method uses an integer account_num to look up a user in a hashmap. It then iterates over the list of users associated with that account number to verify the entered password. It returns the address of the user object if login is successful. The major problem is that it attempts to return the address of a local variable, which can lead to undefined behavior. Moreover, there's no clear feedback if the account_num doesn't exist in the hashmap.

User* login() 
{   
    bool correct_id= false;
    User* user= nullptr;
    while (correct_id == false)
    {
        cout<<"Enter email"<<endl;
        int account_num;
        cin>> account_num;
        cout<<"Enter password"<<endl;
        string password;
        cin>> password;
        if (this->hashmap.find(account_num)!=this->hashmap.end())
        {
            for(User user_node: hashmap[account_num])
            {
                if(account_num==user_node.account_num && password==user_node.password)
                {
                    cout<<"Login successful, loading menu";
                    user= &user_node;
                    correct_id = true;
                }
            }
            return user;
        }
    }
}

Approach 2: This method uses the user's email as a key to access the hashmap directly. It then checks if the entered password matches the stored one for that email. If the login is successful, it returns the address of the user object in the hashmap. It provides clear feedback if the email doesn't exist or the password is incorrect.

User* Login()
{
    bool correct_id = false;
    User* user = nullptr;
    while(!correct_id)
    {
        string email,password;
        cout<<"Enter Your Email"<<endl;
        cin>>email;
        cout<<"Enter Your Password"<<endl;
        cin>>password;
        if(this->hashmap.find(email)!=this->hashmap.end())
        {
            User* user_ptr= this->hashmap[email];
            if(user_ptr->password==password)
            {
                cout<<"Login Successful,Loading Menu";
                user = user_ptr;
                correct_id = true;
            }
            else
            {
                cout<<"incorrect password. Try Again";
            }
        }
        else
        {
            cout<<"Email Not Found. Try Again";
        }
    }
    return user;
}

I just want to know which approach is better practice..

The second approach for a user login function in C++ uses a user's email as a unique identifier. It provides direct access to user data stored in an unordered map (hashmap) using the email as a key. This approach is efficient due to the O(1) access time complexity of hashmaps.

Upon incorrect email or password entry, the user is informed and asked to try again, providing a better user experience. When login is successful, it returns a pointer to the user object, ensuring correct memory management by referencing an existing object in the hashmap, not a temporary or local one.

While this approach handles passwords in plain text, which is not secure, it provides a clear pathway for security enhancement by hashing passwords. Overall, it's a more conventional, efficient, and user-friendly approach compared to the first one. It aligns closely with common industry practices for user authentication systems and avoids potential memory management issues.

Well, I specialize in Javascript, but I'll take a crack at it.
The answer is it depends on the details of the program, I assume this is from a homework exercise. You should have posted the hashmap definition for better understanding.

In terms of memory and accessibility and syntax, the first one is better. I've worked in banking and can't recall any system that uses email addresses for map keys.

Both functions feature 2 searches (if or in the first one, for) which lead me to believe this is a hashmap that contains another data structure.
In that case, the second one is wrong. The syntax doesn't work. You're trying to first access the index and then access what is inside it. But whatever is inside that index is not this->hashmap[email]. By writing User *user_ptr = this->hashmap[email] you're making a pointer to the index itself, not whatever data struct is inside it.
Not to repeat myself, but your answer is basically unanswerable without the hashmap definition.

What is the type of hashmap, is it an unordered map or a custom struct?
Both are amateurish, but I assume you're a beginner.

From the first one, I can infer that this is some type of nested hashmap, it's not the typical key, value hashmap.
If that is the case, the first one is better.

The first one is better because the second one has a glaring syntax issue. hashmap.find(email) searches the index alright, but in the line after, you are assigning the pointer to the index again, which is wrong. You should assign the pointer to whatever(USER?) is inside the index, not the index itself.

These codes are so different I can't even tell if they are using the same hashmap. Are they? If they are, then the second one is wrong.

Both pieces of code are sophomoric although the second contains more errors than the first.

Your comment on the first code returning the address of the local variable is wrong. It does not return the address of the local variable, it returns the address of the hashmap variable, which is stored outside the function.

user_node makes a copy of the User object and then stores the address to user_node, which is then assigned to the pointer user. So pointer user points to an object beyond the login function.

The user pointer and the address it points to extend beyond the function scope even though the user_node variable doesn't. So it returns an address to a valid object in the hashmap, not an address to a local variable as you said.

The second code has syntax issues, the hashmap search doesn't make sense. Why return a pointer to the hashmap index? You need to return a pointer to the User object not the index. Searching a hashmap by email address is awkward, not to mention the accompanying security issues.

Overall, the first code deserves a B- the second one deserves a F.

Second approach looks more professional and time saving to me:
few reasons why:
1.Error handling: The code handles different error scenarios by checking if the email exists and informing the user about incorrect passwords or emails not found.
2.User experience: It provides a user-friendly experience by displaying clear messages and allowing users to correct their input.
3.Robustness: The code uses a loop to repeatedly prompt the user until the correct email and password are entered, preventing accidental logins or unauthorized access.
4.Security (basic): Although it lacks advanced security measures, the code demonstrates a simple password-based authentication mechanism by comparing user input passwords with stored passwords.