c++ string problem

This is a discussion on c++ string problem within the C++ Programming forums, part of the General Programming Boards category; this is suppose to be a part for my game . wut it does is,asks you for your characters name ...

  1. #1
    Registered User
    Join Date
    Sep 2005
    Posts
    196

    c++ string problem

    this is suppose to be a part for my game .
    wut it does is,asks you for your characters name you give it,ask you for you characters class you type wut u want yur characters class to be but theres an error and im confused

    Code:
    #include<iostream>
    #include<cstring>
    using namespace std;
    int main()
    {
     char name[50];
    int answer;
    
    cout<<"please enter your characters name :";
    cin.getline ( name, 50 );
    
    cout<<"what would you like your players class to be :";
    
    cout<<"1 dragon";
    cout<<" 2 vampire hunter";
    strcat ( name );
    cin>> answer;
    if ( int answer = 1 )
    {
    cout>>"so your characters name is "<<name <<"\n";
    }
    cin.get;
    }
    and ive figured out and debuged most the problems but im at a blank here i dont even know wut this is

    Code:
    /*
     * string.h
     * This file has no copyright assigned and is placed in the Public Domain.
     * This file is a part of the mingw-runtime package.
     * No warranty is given; refer to the file DISCLAIMER within the package.
     *
     * Definitions for memory and string functions.
     *
     */
    
    #ifndef _STRING_H_
    #define	_STRING_H_
    
    /* All the headers include this file. */
    #include <_mingw.h>
    
    /*
     * Define size_t, wchar_t and NULL
     */
    #define __need_size_t
    #define __need_wchar_t
    #define	__need_NULL
    #ifndef RC_INVOKED
    #include <stddef.h>
    #endif	/* Not RC_INVOKED */
    
    #ifndef RC_INVOKED
    
    #ifdef __cplusplus
    extern "C" {
    #endif
    
    /*
     * Prototypes of the ANSI Standard C library string functions.
     */
    _CRTIMP void* __cdecl	memchr (const void*, int, size_t) __MINGW_ATTRIB_PURE;
    _CRTIMP int __cdecl 	memcmp (const void*, const void*, size_t) __MINGW_ATTRIB_PURE;
    _CRTIMP void* __cdecl 	memcpy (void*, const void*, size_t);
    _CRTIMP void* __cdecl	memmove (void*, const void*, size_t);
    _CRTIMP void* __cdecl	memset (void*, int, size_t);
    _CRTIMP char* __cdecl	strcat (char*, const char*);
    _CRTIMP char* __cdecl	strchr (const char*, int)  __MINGW_ATTRIB_PURE;
    _CRTIMP int __cdecl	strcmp (const char*, const char*)  __MINGW_ATTRIB_PURE;
    _CRTIMP int __cdecl	strcoll (const char*, const char*);	/* Compare using locale */
    _CRTIMP char* __cdecl	strcpy (char*, const char*);
    _CRTIMP size_t __cdecl	strcspn (const char*, const char*)  __MINGW_ATTRIB_PURE;
    _CRTIMP char* __cdecl	strerror (int); /* NOTE: NOT an old name wrapper. */
    
    _CRTIMP size_t __cdecl	strlen (const char*)  __MINGW_ATTRIB_PURE;
    _CRTIMP char* __cdecl	strncat (char*, const char*, size_t);
    _CRTIMP int __cdecl	strncmp (const char*, const char*, size_t)  __MINGW_ATTRIB_PURE;
    _CRTIMP char* __cdecl	strncpy (char*, const char*, size_t);
    _CRTIMP char* __cdecl	strpbrk (const char*, const char*)  __MINGW_ATTRIB_PURE;
    _CRTIMP char* __cdecl	strrchr (const char*, int)  __MINGW_ATTRIB_PURE;
    _CRTIMP size_t __cdecl	strspn (const char*, const char*)  __MINGW_ATTRIB_PURE;
    _CRTIMP char* __cdecl	strstr (const char*, const char*)  __MINGW_ATTRIB_PURE;
    _CRTIMP char* __cdecl	strtok (char*, const char*);
    _CRTIMP size_t __cdecl	strxfrm (char*, const char*, size_t);
    
    #ifndef __STRICT_ANSI__
    /*
     * Extra non-ANSI functions provided by the CRTDLL library
     */
    _CRTIMP char* __cdecl	_strerror (const char *);
    _CRTIMP void* __cdecl	_memccpy (void*, const void*, int, size_t);
    _CRTIMP int __cdecl 	_memicmp (const void*, const void*, size_t);
    _CRTIMP char* __cdecl 	_strdup (const char*) __MINGW_ATTRIB_MALLOC;
    _CRTIMP int __cdecl	_strcmpi (const char*, const char*);
    _CRTIMP int __cdecl	_stricmp (const char*, const char*);
    _CRTIMP int __cdecl	_stricoll (const char*, const char*);
    _CRTIMP char* __cdecl	_strlwr (char*);
    _CRTIMP int __cdecl	_strnicmp (const char*, const char*, size_t);
    _CRTIMP char* __cdecl	_strnset (char*, int, size_t);
    _CRTIMP char* __cdecl	_strrev (char*);
    _CRTIMP char* __cdecl	_strset (char*, int);
    _CRTIMP char* __cdecl	_strupr (char*);
    _CRTIMP void __cdecl	_swab (const char*, char*, size_t);
    
    #ifdef __MSVCRT__
    _CRTIMP int __cdecl  _strncoll(const char*, const char*, size_t);
    _CRTIMP int __cdecl  _strnicoll(const char*, const char*, size_t);
    #endif
    
    #ifndef	_NO_OLDNAMES
    /*
     * Non-underscored versions of non-ANSI functions. They live in liboldnames.a
     * and provide a little extra portability. Also a few extra UNIX-isms like
     * strcasecmp.
     */
    _CRTIMP void* __cdecl	memccpy (void*, const void*, int, size_t);
    _CRTIMP int __cdecl	memicmp (const void*, const void*, size_t);
    _CRTIMP char* __cdecl	strdup (const char*) __MINGW_ATTRIB_MALLOC;
    _CRTIMP int __cdecl	strcmpi (const char*, const char*);
    _CRTIMP int __cdecl	stricmp (const char*, const char*);
    __CRT_INLINE int __cdecl
    strcasecmp (const char * __sz1, const char * __sz2)
      {return _stricmp (__sz1, __sz2);}
    _CRTIMP int __cdecl	stricoll (const char*, const char*);
    _CRTIMP char* __cdecl	strlwr (char*);
    _CRTIMP int __cdecl	strnicmp (const char*, const char*, size_t);
    __CRT_INLINE int __cdecl
    strncasecmp (const char * __sz1, const char * __sz2, size_t __sizeMaxCompare)
      {return _strnicmp (__sz1, __sz2, __sizeMaxCompare);}
    _CRTIMP char* __cdecl	strnset (char*, int, size_t);
    _CRTIMP char* __cdecl	strrev (char*);
    _CRTIMP char* __cdecl	strset (char*, int);
    _CRTIMP char* __cdecl	strupr (char*);
    #ifndef _UWIN
    _CRTIMP void __cdecl	swab (const char*, char*, size_t);
    #endif /* _UWIN */
    #endif /* _NO_OLDNAMES */
    
    #endif	/* Not __STRICT_ANSI__ */
    
    #ifndef _WSTRING_DEFINED
    /*
     * Unicode versions of the standard calls.
     * Also in wchar.h, where they belong according to ISO standard.
     */
    _CRTIMP wchar_t* __cdecl wcscat (wchar_t*, const wchar_t*);
    _CRTIMP wchar_t* __cdecl wcschr (const wchar_t*, wchar_t);
    _CRTIMP int __cdecl	wcscmp (const wchar_t*, const wchar_t*);
    _CRTIMP int __cdecl	wcscoll (const wchar_t*, const wchar_t*);
    _CRTIMP wchar_t* __cdecl wcscpy (wchar_t*, const wchar_t*);
    _CRTIMP size_t __cdecl	wcscspn (const wchar_t*, const wchar_t*);
    /* Note:  _wcserror requires __MSVCRT_VERSION__ >= 0x0700.  */
    _CRTIMP size_t __cdecl	wcslen (const wchar_t*);
    _CRTIMP wchar_t* __cdecl wcsncat (wchar_t*, const wchar_t*, size_t);
    _CRTIMP int __cdecl	wcsncmp(const wchar_t*, const wchar_t*, size_t);
    _CRTIMP wchar_t* __cdecl wcsncpy(wchar_t*, const wchar_t*, size_t);
    _CRTIMP wchar_t* __cdecl wcspbrk(const wchar_t*, const wchar_t*);
    _CRTIMP wchar_t* __cdecl wcsrchr(const wchar_t*, wchar_t);
    _CRTIMP size_t __cdecl	wcsspn(const wchar_t*, const wchar_t*);
    _CRTIMP wchar_t* __cdecl wcsstr(const wchar_t*, const wchar_t*);
    _CRTIMP wchar_t* __cdecl wcstok(wchar_t*, const wchar_t*);
    _CRTIMP size_t __cdecl	wcsxfrm(wchar_t*, const wchar_t*, size_t);
    
    #ifndef	__STRICT_ANSI__
    /*
     * Unicode versions of non-ANSI string functions provided by CRTDLL.
     */
    
    /* NOTE: _wcscmpi not provided by CRTDLL, this define is for portability */
    #define		_wcscmpi	_wcsicmp
    
    _CRTIMP wchar_t* __cdecl _wcsdup (const wchar_t*);
    _CRTIMP int __cdecl	_wcsicmp (const wchar_t*, const wchar_t*);
    _CRTIMP int __cdecl	_wcsicoll (const wchar_t*, const wchar_t*);
    _CRTIMP wchar_t* __cdecl _wcslwr (wchar_t*);
    _CRTIMP int __cdecl	_wcsnicmp (const wchar_t*, const wchar_t*, size_t);
    _CRTIMP wchar_t* __cdecl _wcsnset (wchar_t*, wchar_t, size_t);
    _CRTIMP wchar_t* __cdecl _wcsrev (wchar_t*);
    _CRTIMP wchar_t* __cdecl _wcsset (wchar_t*, wchar_t);
    _CRTIMP wchar_t* __cdecl _wcsupr (wchar_t*);
    
    #ifdef __MSVCRT__
    _CRTIMP int __cdecl  _wcsncoll(const wchar_t*, const wchar_t*, size_t);
    _CRTIMP int   __cdecl _wcsnicoll(const wchar_t*, const wchar_t*, size_t);
    #if __MSVCRT_VERSION__ >= 0x0700
    _CRTIMP  wchar_t* __cdecl _wcserror(int);
    _CRTIMP  wchar_t* __cdecl __wcserror(const wchar_t*);
    #endif
    #endif
    
    #ifndef	_NO_OLDNAMES
    /* NOTE: There is no _wcscmpi, but this is for compatibility. */
    int __cdecl wcscmpi (const wchar_t * __ws1, const wchar_t * __ws2);
    __CRT_INLINE int __cdecl
    wcscmpi (const wchar_t * __ws1, const wchar_t * __ws2)
      {return _wcsicmp (__ws1, __ws2);}
    _CRTIMP wchar_t* __cdecl wcsdup (const wchar_t*);
    _CRTIMP int __cdecl	wcsicmp (const wchar_t*, const wchar_t*);
    _CRTIMP int __cdecl	wcsicoll (const wchar_t*, const wchar_t*);
    _CRTIMP wchar_t* __cdecl wcslwr (wchar_t*);
    _CRTIMP int __cdecl	wcsnicmp (const wchar_t*, const wchar_t*, size_t);
    _CRTIMP wchar_t* __cdecl wcsnset (wchar_t*, wchar_t, size_t);
    _CRTIMP wchar_t* __cdecl wcsrev (wchar_t*);
    _CRTIMP wchar_t* __cdecl wcsset (wchar_t*, wchar_t);
    _CRTIMP wchar_t* __cdecl wcsupr (wchar_t*);
    #endif	/* Not _NO_OLDNAMES */
    
    #endif	/* Not strict ANSI */
    
    #define _WSTRING_DEFINED
    #endif  /* _WSTRING_DEFINED */
    
    #ifdef __cplusplus
    }
    #endif
    
    #endif	/* Not RC_INVOKED */
    
    #endif	/* Not _STRING_H_ */
    this is a c++ string right it better be
    Last edited by lilhawk2892; 09-22-2005 at 05:02 PM.

  2. #2
    Sweet
    Join Date
    Aug 2002
    Location
    Tucson, Arizona
    Posts
    1,810
    You should use std::string. It is way easier to use than old c style strings.
    Code:
    #include <iostream>
    #include <string>//For the string class
    
    int main()
    {
        //Player's name
        std::string name;
        //What type the player wants to be
        int classType;
        
        std::cout<<"Enter your player's name: ";
        //Use getline to read in your players info from cin
        std::getline(std::cin,name);
        
        std::cout<<"What would you like your players class to be?"<<std::endl;
        std::cout<<"[1] Dragon"<<std::endl;
        std::cout<<"[2] Vampire Hunter"<<std::endl;
        
        //Read in the class they want to be
        std::cin>>classType;
        
        switch(classType)
        {
            case 1:
                std::cout<<"Hello: "<<name<<std::endl;
                std::cout<<"Your class is: Dragon"<<std::endl;
                break;
            //So on so forth
        }
        std::cin.ignore();
        std::cin.get();
        return 0;
    }
    Woop?

  3. #3
    Registered User
    Join Date
    Jan 2005
    Posts
    7,344
    <string.h> and <cstring> have the functions that work with C style strings, which are just null-terminated character arrays. The C++ string class is in <string> and is a class with its own member functions. You are using C style strings.

    As for your code, there are several problems. You have >> instead of << in the cout line. You forgot the parentheses after cin.get. Inside the if, you declare a new variable and assign a value instead of using == to check for equality. You also have a call to strcat which is incorrect and does nothing right now.

    Try starting off with a smaller program and add one thing at a time, making sure that one thing compiles and runs correctly before adding something else. I also recommend you use the C++ string class. It is easier to use and harder to mess up.

  4. #4
    Registered User
    Join Date
    Sep 2005
    Posts
    196
    hey thanks man
    ah crap i have a new problem and again i cant figure it out ive never been able to understand switch statements there complecated

    Code:
    #include <iostream>
    #include <string>//For the string class
    
    int main()
    {
        //Player's name
        std::string name;
        //What type the player wants to be
        int classtype;
        
        std::cout<<"Enter your player's name: ";
        //Use getline to read in your players info from cin
        std::getline(std::cin,name);
        
        std::cout<<"What would you like your players class to be?"<<std::endl;
        std::cout<<"[1] Dragon"<<std::endl;
        std::cout<<"[2] Vampire Hunter"<<std::endl;
        
        //Read in the class they want to be
        std::cin>>classType;
        
        switch(classType)
        {
            case 1:
                std::cout<<"well your name is "<<name<<std::endl;
                std::cout<<"Your class is: Dragon"<<std::endl;
                break;
            //So on so forth
         
        
            case 2:
                std::cout<<"well your name is "<<name<<std::endl;
                std::cout<<"and your class:vampire hunter"<<std::endl;
                break;
         }
        std::cin.ignore();
        std::cin.get();
        return 0;
    }
    Last edited by lilhawk2892; 09-22-2005 at 05:55 PM.

  5. #5
    Sweet
    Join Date
    Aug 2002
    Location
    Tucson, Arizona
    Posts
    1,810
    switch is basically another way to do this
    Code:
    if(num == 1)
    {
    //stuff
    }
    if(num == 2)
    {
    //stuff
    }
    Would translate to this:
    Code:
    switch(num)
    {
        case 1:
        //stuff
        break;
        case 2:
        //stuff
        break;
    }
    Also you can read this http://www.cprogramming.com/tutorial/lesson5.html
    Woop?

  6. #6
    Registered User
    Join Date
    Sep 2005
    Posts
    196
    thanks when you told me that i had just figured out wut i was doing wrong so now im finally on my way

  7. #7
    ~Team work is the best!~ wakish's Avatar
    Join Date
    Sep 2005
    Posts
    85
    Quote Originally Posted by Daved
    <string.h> and <cstring> have the functions that work with C style strings, which are just null-terminated character arrays. The C++ string class is in <string> and is a class with its own member functions. You are using C style strings.
    Daved do u mean that with <string> strings are not null-terminated ?
    what's the mechanism with <string> ?

    tnx!

  8. #8
    Registered User
    Join Date
    Jan 2005
    Posts
    7,344
    Each implementation is free to implement string however they want. Generally they still use character arrays internally and just keep track of the length of the string. C++ strings are allowed to have null characters inside them, so they cannot use the null character as a marker for the end of the string.

Popular pages Recent additions subscribe to a feed

Similar Threads

  1. Replies: 8
    Last Post: 04-25-2008, 03:45 PM
  2. String issues
    By The_professor in forum C++ Programming
    Replies: 7
    Last Post: 06-12-2007, 10:11 AM
  3. Custom String class gives problem with another prog.
    By I BLcK I in forum C++ Programming
    Replies: 1
    Last Post: 12-18-2006, 03:40 AM
  4. Compile Error that i dont understand
    By bobthebullet990 in forum C++ Programming
    Replies: 5
    Last Post: 05-05-2006, 10:19 AM
  5. Replies: 4
    Last Post: 03-03-2006, 02:11 AM

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21