Adding string value to map in c++

The problem there as other mentioned is the char *. Also in you case the char * becomes dangling and you are actually pointing to garbage, the reason behind that is that when name goes out of scope that memory is freed, and you are still pointing to that memory, you actually need to copy the data in the map.

this one works

// ConsoleApplication1.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"


#include <iostream>
#include <string>
#include <map>
#include <utility>

using namespace std;
class map_demo
{


public:
    class cmp_str
    {
    public:
        bool operator() (char const *a, char const *b)
        {
            return std::strcmp(a, b) <0;
        }
    };

private:
    typedef map <string, int> ptype;
    ptype p;

public:
    void set_value()
    {
        char name[20];
        std::string inval;
        int empid;

        cout << "Enter the employee name\n";
        cin.getline(name, 20);
        inval = name;
        //cout<<"name entered=:"<<name;

        cout << "Enter the employee id\n";
        cin >> empid;

        //this->p.insert(map<char *, int>::value_type(name, empid));
        this->p.insert(std::pair<string , int>(inval,empid));
    }

    void get_value()
    {

        cout << "Map size: " << p.size() << endl;

        for (auto ii = p.begin(); ii != p.end(); ++ii)
        {
            std::string mysf(ii->first);
            //std::cout << mysf << std::endl;
            cout << "the first=" << mysf << ": " << (*ii).second << endl;
        }

    }

};
int main()
{
    map_demo  mp1;
    mp1.set_value();
    mp1.get_value();
}

Is just a quick fix, probably with a bit more effort can be made better. But just to give you an idea.

If you need to do it with char *, then you probably need to allocate memory yourself in bulk, each time you go and ask for a name you copy that in your data struct and retrieve a pointer to it. To properly handle that the way you make your data struct changes a lot in how clean your result will be, but the core point is, you need to manage your memory, copy in a place which will persist and not get lost, and store a pointer to that memory, not to a region of memory freed when you get out of set_value().

This line

this->p.insert(map<char *,int>::value_type(name,empid));  

adds a char* pointer to the map, not the string itself. If the pointer points to the stack (name[] is on the stack) then it will be the potentially the same address in each iteration.

Either use a std::string

e.g.

typedef std::map<std::string, int> ptype;
...
p.insert(std::make_pair(name,empid))

or allocate dynamic memory manually and keep track of the string

char* nameStorage = new char[strlen(name)+1];
strcpy(nameStorage,name);
p.insert(std::make_pair(nameStorage,empid));

You defined the key of the map like char *

typedef map <char*, int, cmp_str> ptype;
             ^^^^^

So in member function set_value

void set_value() {
    char name[20];
    int empid;

    //...

    this->p.insert(map<char *,int>::value_type(name,empid));
}

the key is assigned with the address of the local valriable name (more precisely with the address of the first character of the array name) that will be destroyed after exiting the function.

After that the key will be invalied because it will point to a non-existent character array.

Moreover the key shall be copy-assignable but arrays do not have the copy assignment operator.

You could use standard class std::array<char, 20> as the key type. For example

typedef map <std::array<char, 20>, int, cmp_str> ptype;

In this case you have to change also cmp_str that it would accept objects of this type.

Another approach is to use standard class std::string instead of the array. Foir example

typedef map <std::string, int> ptype;