C++

Forum

 
string.find()

josepho16 (28)
okay im trying to use the find function to find a character or word in my string....

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
  #include <iostream>
#include <string>
#include <cstdlib>
using namespace std;
//http://www.cplusplus.com/forum/articles/12974/

string vowelfinder(string nfirst, string nlast);


int main()
{
    string nfirst, nlast, nfull;



cout<<"Enter Your First Name: ";
cin>>nfirst;
cout<<"Enter Your Last Name: ";
cin>>nlast;

nfull=nfirst+ " " +nlast;
cout<<nfull;

string vowelfinder(nfirst, nlast);

}



string vowelfinder(string nfirst, string nlast)
{

    system("cls");
cout<<nfirst.find('a');





}

when I run it, it opens up "stl_iterator_base_types.h", and gives an error on line 83(typedef typename _Iterator::iterator_category iterator_category;) that reads "error: no type named 'iterator_category' in 'class std::basic_string<char>'" what the what...how did this open, and why does my "cout<<nfirst.find('a');" not print anything out? thank you. btw i could not fit the entire header file in this

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
 

  namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

  /**
   *  @defgroup iterators Iterators
   *  Abstractions for uniform iterating through various underlying types.
  */
  //@{ 

  /**
   *  @defgroup iterator_tags Iterator Tags
   *  These are empty types, used to distinguish different iterators.  The
   *  distinction is not made by what they contain, but simply by what they
   *  are.  Different underlying algorithms can then be used based on the
   *  different operations supported by different iterator types.
  */
  //@{ 
  ///  Marking input iterators.
  struct input_iterator_tag { };

  ///  Marking output iterators.
  struct output_iterator_tag { };

  /// Forward iterators support a superset of input iterator operations.
  struct forward_iterator_tag : public input_iterator_tag { };

  /// Bidirectional iterators support a superset of forward iterator
  /// operations.
  struct bidirectional_iterator_tag : public forward_iterator_tag { };

  /// Random-access iterators support a superset of bidirectional
  /// iterator operations.
  struct random_access_iterator_tag : public bidirectional_iterator_tag { };
  //@}

  /**
   *  @brief  Common %iterator class.
   *
   *  This class does nothing but define nested typedefs.  %Iterator classes
   *  can inherit from this class to save some work.  The typedefs are then
   *  used in specializations and overloading.
   *
   *  In particular, there are no default implementations of requirements
   *  such as @c operator++ and the like.  (How could there be?)
  */
  template<typename _Category, typename _Tp, typename _Distance = ptrdiff_t,
           typename _Pointer = _Tp*, typename _Reference = _Tp&>
    struct iterator
    {
      /// One of the @link iterator_tags tag types@endlink.
      typedef _Category  iterator_category;
      /// The type "pointed to" by the iterator.
      typedef _Tp        value_type;
      /// Distance between iterators is represented as this type.
      typedef _Distance  difference_type;
      /// This type represents a pointer-to-value_type.
      typedef _Pointer   pointer;
      /// This type represents a reference-to-value_type.
      typedef _Reference reference;
    };

  /**
   *  @brief  Traits class for iterators.
   *
   *  This class does nothing but define nested typedefs.  The general
   *  version simply @a forwards the nested typedefs from the Iterator
   *  argument.  Specialized versions for pointers and pointers-to-const
   *  provide tighter, more correct semantics.
  */
#ifdef __GXX_EXPERIMENTAL_CXX0X__

_GLIBCXX_HAS_NESTED_TYPE(iterator_category)

  template<typename _Iterator,
	   bool = __has_iterator_category<_Iterator>::value>
    struct __iterator_traits { };

  template<typename _Iterator>
    struct __iterator_traits<_Iterator, true>
    {
      typedef typename _Iterator::iterator_category iterator_category;
      typedef typename _Iterator::value_type        value_type;
      typedef typename _Iterator::difference_type   difference_type;
      typedef typename _Iterator::pointer           pointer;
      typedef typename _Iterator::reference         reference;
    };

  template<typename _Iterator>
    struct iterator_traits
    : public __iterator_traits<_Iterator> { };
#else
  template<typename _Iterator>
    struct iterator_traits
    {
      typedef typename _Iterator::iterator_category iterator_category;
      typedef typename _Iterator::value_type        value_type;
      typedef typename _Iterator::difference_type   difference_type;
      typedef typename _Iterator::pointer           pointer;
      typedef typename _Iterator::reference         reference;
    };
#endif

  /// Partial specialization for pointer types.
  template<typename _Tp>
    struct iterator_traits<_Tp*>
    {
      typedef random_access_iterator_tag iterator_category;
      typedef _Tp                         value_type;
      typedef ptrdiff_t                   difference_type;
      typedef _Tp*                        pointer;
      typedef _Tp&                        reference;
    };

  /// Partial specialization for const pointer types.
  template<typename _Tp>
    struct iterator_traits<const _Tp*>
    {
      typedef random_access_iterator_tag iterator_category;
      typedef _Tp                         value_type;
      typedef ptrdiff_t                   difference_type;
      typedef const _Tp*                  pointer;
      typedef const _Tp&                  reference;
    };

  /**
   *  This function is not a part of the C++ standard but is syntactic
   *  sugar for internal library use only.
  */
  template<typename _Iter>
    inline typename iterator_traits<_Iter>::iterator_category
    __iterator_category(const _Iter&)
    { return typename iterator_traits<_Iter>::iterator_category(); }

  //@}
Last edited on
giblit (3750)
On line 24 you don't need to give the return type. Also, the function is not actually returning anything. std::string::find returns a std::size_t (unsigned int) even if you tried to return that. If it is equal to std::string::npos (-1 I believe but since it is unsigned it should be 232 - 1) it did not find it. Is there a reason you are passing by first and last instead of the full name?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
#include <iostream>
#include <string>

void vowelfinder(std::string fullname);


int main()
{
    std::string nfirst, nlast;

    std::cout << "Enter Your First Name: ";
    std::cin >> nfirst;
    std::cout << "Enter Your Last Name: ";
    std::cin >> nlast;

    std::string nfull = nfirst + " " + nlast;

    vowelfinder(nfull);

}



void vowelfinder(std::string fullname)
{
    std::size_t pos = fullname.find('a'); //first 'a' found
    if(pos != std::string::npos) //-1 if you want
    {
        std::cout << "The first 'a' vowel was found at position: " << pos << std::endl;
    }
    else
    {
        std::cout << fullname << " contains no 'a'." << std::endl;
    }
}
 
fred flinstone contains no 'a'.
The first 'a' vowel was found at position: 6
The first 'a' vowel was found at position: 1

http://coliru.stacked-crooked.com/a/b34d8ea772cd22b0
josepho16 (28)
ah okay thank you that fixed the random file problem...yes, im trying to do a challenge that you can see in the code i provided, its the url in the comment line..
Topic archived. No new replies allowed.