C / C++ / MFC

5-Mar-09 16:36

i ues string class in a Win32 Console Application(build by VC++ 6),here is the code and errors, how can i fix it?

#include "stdafx.h"


//add
#include <windows.h>
#include <stdio.h>
#include <tchar.h>
#include "Psapi.h"
#include <iostream.h>
#include  <string>    
  using   namespace   std;   

void PrintProcessNameAndID( DWORD processID )
{
	string  szProcessName;

    // Get a handle to the process.

    HANDLE hProcess = OpenProcess( PROCESS_QUERY_INFORMATION |
                                   PROCESS_VM_READ,
                                   FALSE, processID );

    // Get the process name.

    if (NULL != hProcess )
    {
        HMODULE hMod;
        DWORD cbNeeded;

        if ( EnumProcessModules( hProcess, &hMod, sizeof(hMod), 
             &cbNeeded) )
        {
			int len = lstrlen(szProcessName);
            GetModuleBaseName( hProcess, hMod, szProcessName, 
                               len);
			//theProName = szProcessName;
        }

	if(lstrcmp(szProcessName, "smss.exe"))
		_tprintf( TEXT("%s  (PID: %u)\n"), szProcessName, processID );
    }

    CloseHandle( hProcess );
}

int main(int argc, char* argv[])
{
...
	return 0;
}

errors:
... : error C2664: 'lstrlenA' : cannot convert parameter 1 from 'class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >' to 'const char *'
No user-defined-conversion operator available that can perform this conversion, or the operator cannot be called
... : error C2664: 'GetModuleBaseNameA' : cannot convert parameter 3 from 'class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >' to 'char *'
No user-defined-conversion operator available that can perform this conversion, or the operator cannot be called
... : error C2664: 'lstrcmpA' : cannot convert parameter 1 from 'class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >' to 'const char *'
No user-defined-conversion operator available that can perform this conversion, or the operator cannot be called

i 've tried ,then i have no regret

Naveen5-Mar-09 16:52

Naveen

5-Mar-09 16:52

Trying using szProcessName.c_str() instead of only "szProcessName" in the functions 'lstrlenA' , 'GetModuleBaseNameA' and 'lstrcmpA'.

nave

[OpenedFileFinder] [My Blog]

CHYGO5-Mar-09 19:45

5-Mar-09 19:45

Thank u,Naveen.I did as u told me ,but comes a new error:
...:error C2664: 'GetModuleBaseNameA' : cannot convert parameter 3 from 'const char *' to 'char *'

how to do?

i 've tried ,then i have no regret

CHYGO5-Mar-09 20:18

5-Mar-09 20:18

oh yea.. haha i must be looking like a fool now...
i fix it

thanks for yr help Smile | :)

i 've tried ,then i have no regret

Naveen5-Mar-09 20:22

Naveen

5-Mar-09 20:22

hmm..

I modified you code a little.Just changed the szProcessName to TCHAR.

void PrintProcessNameAndID( DWORD processID )
{
     TCHAR  szProcessName[MAX_PATH];
    // Get a handle to the process.
    HANDLE hProcess = OpenProcess( PROCESS_QUERY_INFORMATION |
                                   PROCESS_VM_READ,
                                   FALSE, processID );
    // Get the process name.
    if (NULL != hProcess )
    {
        HMODULE hMod;
        DWORD cbNeeded;

        if ( EnumProcessModules( hProcess, &hMod, sizeof(hMod), 
             &cbNeeded) )
        {
            GetModuleBaseName( hProcess, hMod, szProcessName, 
                                                       MAX_PATH);
        }
        if(lstrcmp(szProcessName, "smss.exe"))
		_tprintf( TEXT("%s  (PID: %u)\n"), szProcessName, processID );
    }

    CloseHandle( hProcess );
}

nave

[OpenedFileFinder] [My Blog]

CHYGO5-Mar-09 21:06

5-Mar-09 21:06

thanks for ue help nave, but yr code still have a little problem Smile | :)

 if(lstrcmp(szProcessName, "smss.exe"))		
_tprintf( TEXT("%s  (PID: %u)\n"), szProcessName, processID );

that is: function lstrcmp(lpstring1, lpstring2),when lpstring1 equals lpstring2,the return value is zero.so if i need only see "smss.exe" on the screen,i should change it like this

if(!lstrcmp(szProcessName, "smss.exe"))		
_tprintf( TEXT("%s  (PID: %u)\n"), szProcessName, processID );

i 've tried ,then i have no regret

Is Volume online and ready?

David Crow6-Mar-09 3:31

David Crow

6-Mar-09 3:31

CHYGO wrote:
if(!lstrcmp(szProcessName, "smss.exe"))

lstrcmp() is not a boolean function so you should refrain from treating it as such:

if (lstrcmp(szProcessName.c_str(), "smss.exe") == 0)
    ...

Also, since szProcessName is a string variable, why not just use:

if (szProcessName != "smss.exe")
    ...

"Old age is like a bank account. You withdraw later in life what you have deposited along the way." - Unknown

"Fireproof doesn't mean the fire will never come. It means when the fire comes that you will be able to withstand it." - Michael Simmons

Peter Weyzen5-Mar-09 14:59

Peter Weyzen

5-Mar-09 14:59

What's the best way to reliable determine if a volume is online and ready for use?

Current I am using GetVolumeInformation to do this. My assumption is that.

Should I go a step further and read the root folder?

Just wondering if GetVolumeInformation can report something present that's not ready for access?

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~<br />
Peter Weyzen<br />
Staff Engineer<br />
<a href="http://www.soonr.com">SoonR Inc -- PC Power delivered to your phone</a>

Rational Number constructor

aab199025-Mar-09 13:20

Re: Rational Number constructor

5-Mar-09 13:20

I need to construct Rational numbers, but they have to be in the simplest form... Here's what I have.

Rational::Rational( int Num , int Den )
{
   int A = Num;
   int B = Den;

   int temp;

   while(B)
   {
      temp = B;
      B = A%B;
      A = temp;
   }

   if( A != 0 )
   {
      Numerator_ = Num/A;
      Denominator_ = Den/A;
   }
}

modified on Thursday, March 5, 2009 8:52 PM

Cedric Moonen5-Mar-09 20:22

Cedric Moonen

5-Mar-09 20:22

What's your question exactly ?

Cédric Moonen
Software developer

Charting control [v1.5]
OpenGL game tutorial in C++

Re: Rational Number constructor

CPallini5-Mar-09 21:09

CPallini

5-Mar-09 21:09

We're always happy to see your achievements, now what is the question?
Smile | :)

If the Lord God Almighty had consulted me before embarking upon the Creation, I would have recommended something simpler.
-- Alfonso the Wise, 13th Century King of Castile.

This is going on my arrogant assumptions. You may have a superb reason why I'm completely wrong.
-- Iain Clarke

[My articles]

Re: Rational Number constructor

David Crow6-Mar-09 3:40

David Crow

6-Mar-09 3:40

Your Euclidean algorithm is correct. What's your concern?

Iterating string to add escape sequence.

mmayur5-Mar-09 11:27

mmayur

5-Mar-09 11:27

Hi,

I'm looking for much better optimzed code for adding escape sequence than the below.

void appendSlash(const string& source, string& result)
{
for(unsigned int i = 0; i < source.length(); i++)
{
switch(source[i])
{
default:
result += source[i];
break;
case '"':
result += "\\\"";
break;
}
}
}

The switch-case in the current code is to handle more scenarios that might be added for implementing later.

Thanks in advance,

Regards,
Mayur M

Re: Iterating string to add escape sequence.

«_Superman_»5-Mar-09 17:22

«_Superman_»

5-Mar-09 17:22

You should use the infamous find and replace Smile | :)

string class (rather basic_string class) has a member function called find to find the character that you specify in your switch statement. After finding the character, use the replace member function to put in the escape sequence that you wish.

«_Superman_»
I love work. It gives me something to do between weekends.

Re: Iterating string to add escape sequence.

David Crow6-Mar-09 3:43

David Crow

6-Mar-09 3:43

What about PathAddBackslash(), or:

if (source.substr(source.length() - 1) != "\\")
    source += '\\';

First C++ class

aab199025-Mar-09 11:18

5-Mar-09 11:18

Can someone please take a look at this class and tell me what I'm doing so terribly wrong. The compiler gives me an error I search around fix it and then another one pops up.
I will post my header file and my code...And if someone has a thought about how to overload the input operator that would help because i am lost on that one

#ifndef RATIONAL_
#define RATIONAL_

using namespace std;

#include <iostream>

class Rational
{
  public:

    // Construct rational from numerator and denominator
    //
    Rational( int = 0, int = 1 );

    // Construct rational by copying existing rational
    //
    Rational( const Rational& );

    // Assign into rational by copying existing rational
    //
    Rational& operator=( const Rational& );

         //Find Greatest Common Divisor
         int GCD();

         //Simplify the rational number to its smallest form
         void Simplify();

    // Return true if rational is valid (non-zero denominator)
    //
    bool IsValid() const;

    // Return value of numerator
    //
    int Numerator() const;

    // Return value of denominator
    //
    int Denominator() const;

    // Input/Output operations
    //
    friend istream& operator>>( istream&, Rational& );
    friend ostream& operator<<( ostream&, const Rational& );

  private:

    // Insert your declarations here
         int Numerator_;
         int Denominator_;
};

// Comparative operations
//
bool operator==( const Rational&, const Rational& );
bool operator!=( const Rational&, const Rational& );
bool operator< ( const Rational&, const Rational& );
bool operator<=( const Rational&, const Rational& );
bool operator> ( const Rational&, const Rational& );
bool operator>=( const Rational&, const Rational& );

// Arithmetic operations
//
Rational operator+( const Rational&, const Rational& );
Rational operator-( const Rational&, const Rational& );
Rational operator*( const Rational&, const Rational& );
Rational operator/( const Rational&, const Rational& );

#endif
</iostream>

using namespace std;

#include <iostream>

#include "proj06.rational.h"


/*-----------------------------------------------------------------------------
   Name:  constructor for class "Rational"

   Purpose:  Initialize the contents of a rational number
   Receive:  The numerator and denominator or rational number
-----------------------------------------------------------------------------*/

Rational::Rational( int Num, int Den )
{
   Numerator_ = Num;

  if (Den <= 0)
  {
    Denominator_ = 1;
  }
  else
  {
    Denominator_ = Den;
  }
}

/*-----------------------------------------------------------------------------
   Name:  copy constructor for class "Rational"

   Purpose:  Initialize the value and scale inside a Rational object
   Recieve:   The rational to be copied
-----------------------------------------------------------------------------*/

Rational::Rational( const Rational& C )
{
  Numerator_ = C.Numerator_;
  Denominator_ = C.Denominator_;
}

/*-----------------------------------------------------------------------------
   Name:  assignment operator for class "Rational"

   Purpose:  Copy the contents of one rational to another
        Recieve:         The rational which is to be copied
   Return:   The rational number
-----------------------------------------------------------------------------*/

Rational& Rational::operator=(const Rational& C )
{
        Numerator_ = C.Numerator_;
        Denominator_ = C.Denominator_;

        return *this;
}
 
/*-----------------------------------------------------------------------------
   Name: GCD 
 
   Purpose:  Find the greatest common divisor of a rational number
   Return:   GCD
-----------------------------------------------------------------------------*/
 
int Rational::GCD()
{
        int A = Numerator_;
        int B = Denominator_;

        int Temp;

        while(B)
        {
                Temp = B;
                B = A%B;
                A = Temp;
        }

        return A;
}

/*-----------------------------------------------------------------------------
   Name:        Simplify
 
   Purpose:  Simplify a rational number
-----------------------------------------------------------------------------*/
 
void Rational::Simplify()
{
        int GCDNumber = GCD();

        if(GCDNumber != 0)
        {
                Numerator_ = Numerator_/GCDNumber;
                Denominator_ = Denominator_/GCDNumber;
        }
}

/*-----------------------------------------------------------------------------
   Name:  IsValid
 
   Purpose:  Test whether or not the rational is valid
   Return:   The Boolean value for the result of the test
-----------------------------------------------------------------------------*/
 
bool Rational::IsValid() const
{
  return ( Denominator_ != 0 ); 
}

/*-----------------------------------------------------------------------------
   Name:  Numerator
 
   Purpose:  extract numerator from rational number
        Return:  numerator
-----------------------------------------------------------------------------*/

int Rational::Numerator() const
{
        return Numerator_;
}

/*-----------------------------------------------------------------------------
   Name:  Denominator
 
   Purpose:  extract denominator from rational number
        Return:          denominator
-----------------------------------------------------------------------------*/

int Rational::Denominator() const
{
        return Denominator_;
}

/*-----------------------------------------------------------------------------
   Name:  operator==
 
   Purpose:  compare 2 rationals for equality
        Recieve:         the 2 rationals
        Return:  boolean result of the comparison
-----------------------------------------------------------------------------*/

bool operator==( const Rational& A, const Rational& B ) 
{
        A.Simplify();
        B.Simplify();

        return(A.Numerator() == B.Numerator() and A.Denominator()== B.Denominator());
}
 

/*-----------------------------------------------------------------------------
   Name:  operator!=
 
   Purpose:  compare 2 rationals for inequality
        Recieve:         the 2 rationals
        Return:  boolean result of the comparison
-----------------------------------------------------------------------------*/

bool operator!=( const Rational& A, const Rational& B ) 
{
        A.Simplify();
        B.Simplify();

        return(A.Numerator() != B.Numerator() and A.Denominator()!= B.Denominator());
}

/*-----------------------------------------------------------------------------
   Name:  operator<<br mode="hold" /> 
   Purpose:  tell whether A is less than B
        Recieve:         the 2 rationals A and B
        Return:  boolean result of the comparison
-----------------------------------------------------------------------------*/

bool operator<( const Rational& A, const Rational& B ) 
{
        A.Simplify();
        B.Simplify();

        return(A.Numerator()*B.Denominator())<(A.Denominator()*B.Numerator());
}

/*-----------------------------------------------------------------------------
   Name:  operator<=
 
   Purpose:  tell whether A is less than or equal to B
        Recieve:         the 2 rationals A and B
        Return:  boolean result of the comparison
-----------------------------------------------------------------------------*/

bool operator<=( const Rational& A, const Rational& B ) 
{
        A.Simplify();
        B.Simplify();

        return(A.Numerator()*B.Denominator())<=(A.Denominator()*B.Numerator());
}


/*-----------------------------------------------------------------------------
   Name:  operator>
 
   Purpose:  tell whether A is greater than B
        Recieve:         the 2 rationals A and B
        Return:  boolean result of the comparison
-----------------------------------------------------------------------------*/

bool operator>( const Rational& A, const Rational& B ) 
{
        A.Simplify();
        B.Simplify();

        return(A.Numerator()*B.Denominator())>(A.Denominator()*B.Numerator());
}

/*-----------------------------------------------------------------------------
   Name:  operator>=
 
   Purpose:  tell whether A is greater than or equal to B
        Recieve:         the 2 rationals A and B
        Return:  boolean result of the comparison
-----------------------------------------------------------------------------*/

bool operator>=( const Rational& A, const Rational& B ) 
{
        A.Simplify();
        B.Simplify();

        return(A.Numerator()*B.Denominator())>=(A.Denominator()*B.Numerator());
}

/*-----------------------------------------------------------------------------
   Name:  operator+
 
   Purpose:  Add two rational numbers
        Recieve:         The two rationals to be added
        Return:  The rational result of adding the two rationals
-----------------------------------------------------------------------------*/

Rational operator+( const Rational& A, const Rational B ) 
{
        int Num;
        int Den;

        Num = A.Numerator()*B.Denominator()+A.Denominator()*B.Numerator();
        Den = A.Denominator()*B.Denominator();

        Rational C(Num, Den);
        return C.Simplify();
}


/*-----------------------------------------------------------------------------
   Name:  operator-
 
   Purpose:  Subtract two rational numbers
        Recieve:         The two rationals to be subtracted
        Return:  The rational result of subtracting the two rationals
-----------------------------------------------------------------------------*/

Rational operator-( const Rational& A, const Rational B ) 
{
        int Num;
        int Den;

        Num = A.Numerator()*B.Denominator()-A.Denominator()*B.Numerator();
        Den = A.Denominator()*B.Denominator();

        Rational C(Num, Den);
        return C.Simplify();
}

/*-----------------------------------------------------------------------------
   Name:  operator*
 
   Purpose:  Multiply two rational numbers
        Recieve:         The two rationals to be multiplied
        Return:  The rational result of multiplying the two rationals
-----------------------------------------------------------------------------*/

Rational operator*( const Rational& A, const Rational B ) 
{
        int Num;
        int Den;

        Num = A.Numerator()*B.Numerator();
        Den = A.Denominator()*B.Denominator();

        Rational C(Num, Den);
        return C.Simplify();
}

/*-----------------------------------------------------------------------------
   Name:  operator/
 
   Purpose:  Divide two rational numbers
        Recieve:         The two rationals to be divided
        Return:  The rational result of dividing the two rationals
-----------------------------------------------------------------------------*/

Rational operator/( const Rational& A, const Rational B ) 
{
        int Num;
        int Den;

        Num = A.Numerator()*B.Denominator();
        Den = A.Denominator()*B.Numerator();

        Rational C(Num, Den);
        return C.Simplify();
}


/*-----------------------------------------------------------------------------
   Name:  operator<<

   Purpose:  Put a rational into an output stream
   Receive:  The reference to an output stream
             The refernce to a rational which is to be written
   Return:   The output stream (for chaining)
        Ouput:   A rational number "numerator/denominator"
-----------------------------------------------------------------------------*/

ostream& operator<<( ostream& Out, const Rational& Item ) 
{
        Out << Item.Numerator() << "/" << Item.Denominator();

        return Out;
}


/*-----------------------------------------------------------------------------
   Name:  operator>>

   Purpose:  extract a rational from an input stream
   Receive:  The reference to aninput stream
             The reference to a rational which is to be written
   Return:   The input stream (for chaining)
        Input:   a rational number
-----------------------------------------------------------------------------*/</iostream>

Yusuf5-Mar-09 11:29

Yusuf

5-Mar-09 11:29

what is the error you getting?

Yusuf

aab199025-Mar-09 11:36

5-Mar-09 11:36

proj06.driver.cpp: In function 'int main()':
proj06.driver.cpp:38: warning: the address of 'Rational G()', will always evaluate as 'true'
proj06.rational.cpp: In function 'bool operator==(const Rational&, const Rational&)':
proj06.rational.cpp:150: error: passing 'const Rational' as 'this' argument of 'void Rational::Simplify()' discards qualifiers
proj06.rational.cpp:151: error: passing 'const Rational' as 'this' argument of 'void Rational::Simplify()' discards qualifiers
proj06.rational.cpp: In function 'bool operator!=(const Rational&, const Rational&)':
proj06.rational.cpp:167: error: passing 'const Rational' as 'this' argument of 'void Rational::Simplify()' discards qualifiers
proj06.rational.cpp:168: error: passing 'const Rational' as 'this' argument of 'void Rational::Simplify()' discards qualifiers
proj06.rational.cpp: In function 'bool operator<(const Rational&, const Rational&)':
proj06.rational.cpp:183: error: passing 'const Rational' as 'this' argument of 'void Rational::Simplify()' discards qualifiers
proj06.rational.cpp:184: error: passing 'const Rational' as 'this' argument of 'void Rational::Simplify()' discards qualifiers
proj06.rational.cpp: In function 'bool operator<=(const Rational&, const Rational&)':
proj06.rational.cpp:199: error: passing 'const Rational' as 'this' argument of 'void Rational::Simplify()' discards qualifiers
proj06.rational.cpp:200: error: passing 'const Rational' as 'this' argument of 'void Rational::Simplify()' discards qualifiers
proj06.rational.cpp: In function 'bool operator>(const Rational&, const Rational&)':
proj06.rational.cpp:216: error: passing 'const Rational' as 'this' argument of 'void Rational::Simplify()' discards qualifiers
proj06.rational.cpp:217: error: passing 'const Rational' as 'this' argument of 'void Rational::Simplify()' discards qualifiers
proj06.rational.cpp: In function 'bool operator>=(const Rational&, const Rational&)':
proj06.rational.cpp:232: error: passing 'const Rational' as 'this' argument of 'void Rational::Simplify()' discards qualifiers
proj06.rational.cpp:233: error: passing 'const Rational' as 'this' argument of 'void Rational::Simplify()' discards qualifiers
proj06.rational.cpp: In function 'Rational operator+(const Rational&, Rational)':
proj06.rational.cpp:255: error: conversion from 'void' to non-scalar type 'Rational' requested
proj06.rational.cpp: In function 'Rational operator-(const Rational&, Rational)':
proj06.rational.cpp:276: error: conversion from 'void' to non-scalar type 'Rational' requested
proj06.rational.cpp: In function 'Rational operator*(const Rational&, Rational)':
proj06.rational.cpp:296: error: conversion from 'void' to non-scalar type 'Rational' requested
proj06.rational.cpp: In function 'Rational operator/(const Rational&, Rational)':
proj06.rational.cpp:316: error: conversion from 'void' to non-scalar type 'Rational' requested

Yusuf5-Mar-09 11:55

Yusuf

5-Mar-09 11:55

you are trying to modify const object. Your overloaded operator == takes const parameter

bool operator==( const Rational& A, const Rational& B )

but then you call Simplify which it tries to change the value of your const object.

Here is something that can walk you through const declaration [^] and another one [^] yet another one[^]

Yusuf

Maximilien5-Mar-09 11:39

Maximilien

5-Mar-09 11:39

Well, what are the errors the compiler give you?

I've given it to my XCode compiler (on Mac OSX) and it give me errors with some methods (operators) that receive constant objects that you try to modify with "Simplify".

IMO, for comparator operators (== !=, ... ) you do not want to modify the input, so don't call Simplify.

Also, the Simplidy() method returns void, and you "return" this in a couple of methods.

This signature was proudly tested on animals.

aab199025-Mar-09 12:01