i want to get n lines from keyboard and put them into an array...it does not work!!!

#include "stdafx.h"
#include <iostream>
#include <fstream> //this is for file I/O. you aren't using files.
#include <conio.h>
#include <string>
#include <stdio.h> //You don't need this. you are using std:: functions instead for printing and reading to the console.
#include <stdlib.h> //You dont need this either. not sure why you thought you did.
#include <map> //You arent using the std::map. Why are you including this?

//be careful when using "using namespace". This can only be used to use a single namespace.
//you should instead use:
//using std::cin;
//using std::cout;
//...
using namespace std;

//When passing in the parameter c another copy is made of the string.
//You are creating 2 copies of the string when you only need the original.
//Why are you passing in count. The first thing you do is set a copy of the value to 0.
int jomleTokalame(string *a,string c,int count) {
    string cc="";
    count =0;
    for(int i = 0 ; c[i]!='\0';i++){
        cc+=c[i];
        if (c[i]==' ' || c[i+1]=='\0'){
            a[count]=cc; //Yet another copy of a string.
            count++;
            cc="";
        }
    }
    return count;
}

//here you are using the typed main function, which will use whichever character set you are compiling with.
//All your std::strings are are ASCII
int _tmain(int argc, _TCHAR* argv[]) {
    //You have limited space on the stack.
    //You should avoid putting large arrays on the stack, or arrays of large data types.
    int location[100]; //unused variable taking 400 bytes on the stack. Use it or get rid of it
    string str[100]; //Each std::string typically takes 12 bytes. This is taking 1200 bytes on the stack
    string a[100]; //again, this is taking 1200 bytes on the stack
    string s;
    int n,i=1,j,k=0,g; //You should change more meaningful variable names. Unused variable k. Initial value of i is never used.
    cout<<"plz enter number of lines:\n";
    cin>>n; //what if the user enters 
    for(i=1;i<=n;i++) { //I think you are wanting to start with for(i=0;i<n;i++).
        //Array indices start at 0 and go to N-1.
        getline(cin,a[i],'\n');
        s=a[i]; //Note: this COPIES the value of a[i]. This is slow and unnecessary.
        g=jomleTokalame(str,s,0);
        for(j=0;j<=g;j++)
            cout<<str[j];
    }
    getch(); //This function is deprecated, you should instead use _getch();
    return 0;
}

#include <iostream>
#include <conio.h>
#include <string>

using std::cout;
using std::cin;
using std::string;

//Now we will pass parameter strLine by const reference
//This does not create a copy, but does say that we can't change the original
int jomleTokalame(string *strWords, const string &strLine) {
    //instead of using a variable cc, we will just modify the array directly. This will avoid copying.
    int nWords = 0;
    strWords[nWords]="";
    for(int nChar = 0; strLine[nChar] != '\0'; ++nChar){//++X is often (marginally) faster than X++
        strWords[nWords] += strLine[nChar];
        if (strLine[nChar] == ' ' || strLine[nChar + 1] == '\0'){
            //no copying to be done now.
            strWords[++nWords]=""; //Make sure the next string is empty.
        }
    }
    return nWords + 1; //This is a better place to increment the number of words
}

int _tmain(int argc, _TCHAR* argv[]) {
    string strWords[100]; //you should really use something like a std::vector for this, but i will let you do that.
    string *strLines = NULL; //This will be allocated dynamically once we know how big to make the array.
    int nLines, nLine, nWords, nWord;
    cout << "plz enter number of lines:\n";
    cin >> nLines;
    strLines = new string[nLines]; //This way you won't get a buffer overflow if nLines>100 and it doesn't take up precious space on the stack.
    for (nLine = 0; nLine < nLines; ++nLine) {//++X is often (marginally) faster than X++
        getline(cin, strLines[nLine], '\n');
        nWords = jomleTokalame(strWords, strLines[nLine]); //pass a[nLine] in directly
        for (nWord = 0; nWord < nWords; ++nWord)
            cout << strWords[nWord];
    }
    delete[] strLines; //delete the dynamically allocated array of strings
    _getch();
    return 0;
}