Comparisons between pointer and integer?

bool cScript::LoadScript(std::string filepath){     std::ifstream file;     file.open( filepath.c_str() );     if( file.is_open() )     {         while( !file.eof() )         {                getline(file, rawScript);         }     }     else     {        file.close();         return false;     }      file.close();     return true;}

#include <iostream>#include <fstream>#include <string>#include "includes/cScript.h"int main(){    cScript* testScript = new cScript();    bool result = testScript->LoadScript("script.txt");    if(result != false)    {        testScript->Process();        std::string com = testScript->getCommand();        std::ofstream file("result.txt");        file << com << std::endl;        file.close();        std::cout << "Current command: " << com << std::endl;        std::cin.get();        return 0;    }    else    {        std::cout << result << std::endl;        std::cin.get();        return 1;    }}

/*Process' the script and "parse it"*/void cScript::Process(){     std::string script = rawScript;     // are you 100% certain script is not empty?     // assert(!script.empty()) here to be on the safe side     if(script[0] == "-") //if the script file starts with a - (this is where I get a comparison error     {          Persistent = true; //the script is persistent     }     else     {          Persistent = false;     }     int i = 1;     // again, you should assert that script actually contains a ';'     // to avoid reading off into the ether (assert(script.find(';') != std::string::npos);)     while(script != ";")      {           // is Command big enough to write into?           Command = script; //assign each character to the command           // i is an index, not an iterator           ++i; //increment the iterator     }     // you could replace the above loop with Command.assign(script, 0, script.find(';'));}// ----#ifndef CSCRIPT_H#define CSCRIPT_Hclass cScript{      public:             // pass strings by const reference, not value             bool LoadScript(std::string); //loads a script from file             std::string getScript() const; //returns the current script             void Execute() const; //execute the script             void Process();             std::string getCommand() const;             cScript(std::string);      private:             std::string rawScript;             std::string Command;             std::string Param1;//both parameters are optional             std::string Param2;             bool Persistent(); //this is true if the script conditions should be checked each update};#endif// ----// pass by const reference, not valuebool cScript::LoadScript(std::string filepath){     std::ifstream file;     file.open( filepath.c_str() );     if( file.is_open() )     {         while( !file.eof() )         {                // this is going to overwrite the same line over                // and over again                getline(file, rawScript);         }     }     else     {        // no need to explicitly close the file        // the ifstream destructor will take care        // of that - one of the advantages of RAII        file.close();         return false;     }      // as above     file.close();     return true;}// ----#include <iostream>#include <fstream>#include <string>#include "includes/cScript.h"int main(){    // why dynamically allocated?    cScript* testScript = new cScript();    bool result = testScript->LoadScript("script.txt");    if(result != false)    {        testScript->Process();        std::string com = testScript->getCommand();        std::ofstream file("result.txt");        file << com << std::endl;        file.close();        std::cout << "Current command: " << com << std::endl;        std::cin.get();        return 0;    }    else    {        std::cout << result << std::endl;        std::cin.get();        return 1;    }}

-test;

void cScript::Process(){     std::string script = rawScript;     if(script[0] == '-') //if the script file starts with a - (this is where I get a comparison error     {          Persistent = true; //the script is persistent     }     else     {          Persistent = false;     }     int i = 1;     while(script != ';')      {           Command = script; //assign each character to the command           ++i; //increment the iterator     }} 

// cwhat's ca cscript, canyway?#ifndef SCRIPT_H#define SCRIPT_Hclass Script {  // I like to put the private section first, but that seems to be unusual.  // What that does is avoid the need for an explicit 'private:' label.  // Don't keep the raw script around; you don't need it.  // Oh, and RAII demands that you do all the setup work - that means load  // the file and process it - in the constructor, throwing an exception in  // case of error. That way, your object is always in a valid state.  // Because the file may contain multiple lines, I use a container like this  // to keep the lines separate:  std::vector<std::string> script_data;  // Don't keep parameters around. The name "parameter" should tip you off;  // these are values that should be passed to the execution function.  // By the way, in C++, things like "execute()" are commonly spelled   // "operator()". :) (That lets you "call" the object like a function.)    bool persistent; // you had this as a member function before, which isn't  // right if you're assigning to it.   public:  // pass strings by const reference, not value  Script(const std::string&);  // Don't provide accessors. The contents of the script should be meaningless  // to the rest of the program.  // To handle the optional parameters, I provide defaults:  void operator()(const std::string& = "",                  const std::string& = "") const;  // So that we don't require the accessor for testing, I will make  // the operator() "interpret" the script by dumping it to the file named  // in the first parameter.};#endif// ----Script::Script(const std::string& filepath) : persistent(false) {  // That initialization will be overridden if we find a '-'.  std::ifstream file(filepath.c_str());  if (!file.is_open()) {    throw std::runtime_error("can't open script file");  }  // Read each line from the file, and append up to the semicolon character  // on each line to the script buffer. As well, check for persistence on  // the first line.  bool checked_persistence = false;  std::string line;  while (std::getline(file, line)) { // A common file-reading idiom that avoids  // subtle problems with .eof().    // Ignore blank lines (even at the beginning of the script).    if (line.empty()) continue;    int begin = 0;    if (!checked_persistence) {      checked_persistence = true;      if (line[0] == '-') {        persistent = true;        // And we should probably remove that '-' from the script line:        begin = 1;      }    }    // make a temporary and add it to the vector:    script_data.push_back(std::string(line, begin, line.find(';')));    // Yes, that does handle the case where there is no ';'.  }}void Script::operator()(const std::string& filepath,                        const std::string& reserved) const {  ofstream output(filepath.c_str());  if (!file.is_open()) {    throw std::runtime_error("can't open output file");  }  // Behold the power of <algorithm>! (Oh, you'll need <iterator> too :\)  std::copy(script_data.begin(), script_data.end(),            ostream_iterator<std::string>(output, "\n"));}// ----#include <iostream>#include <fstream>#include <string>#include <exception>#include "includes/Script.h"int main() {  try {    Script test("script.txt");    // Using the script is now this easy - like it should be:    test("result.txt");    return 0;  } catch (std::runtime_error& ex) {    // script failed to load.    // We can use the exception to get a better error message than just "false":    std::cout << ex.what() << std::endl;    // Notice how I also handle an error in the *output* file now, yet the error    // handling gets unified.    return 1;  }  // Don't pause your programs artificially at the end.}

std::copy(script_data.begin(), script_data.end(), ostream_iterator<std::string>(output, "\n"));