Input and output:
cin : Read formatted data from the
standard input
#include<iostream>
cin.getline : Get a line from the stdin
stream.
cout : Print formatted output to the
standard
output stream.
#include<iostream>
setw(int n) : set the width of the next
output to n chars.
setprecision(int n) : set the number of decimal fractions of
the next input to n chars.
fixed : 以固定小數而非指數方式輸出浮點值
#include<iomainp>
Example :
#include
<iostream>
#include
<string>
#include<iomanip>
using
namespace std;
void
main()
{
double
i;
cin>>i;
cout<<fixed<<setprecision(3)<<setw(10)<<i;
}
Input :
123.4568
Output :
123.457
String manipulation(in C++):
c_str : Transfer a string to char
array.
#include
<string>
using
namespace std;
const
charT* c_str () const;
Example :
#include
<string>
#include
<stdio.h>
using
namespace std;
void
main()
{
string text;
text=”This is a test”;
printf(“%s\n”,text.c_str());
}
Output :
This
is a test
erase : Remove some chars from a
string.
#include
<string>
using
namespace std;
basic_string&
erase (size_type pos = 0, size_type n = npos);
Example :
#include
<string>
#include
<stdio.h>
using
namespace std;
void
main()
{
string text;
text="abcdefghi";
text.erase(4,3);
cout<<text<<endl;
}
Output :
abcdhi
compare : Compare two strings.
#include
<string>
using
namespace std;
int
compare (const basic_string& str);
int
compare(size_type, size_type, const basic_string&)
int
compare(size_type, size_type, const basic_string&, size_type, size_type);
Example :
#include
<iostream>
#include
<string>
using
namespace std;
void
print(int result)
{
if (result < 0)
cout<<"s1
< s2"<<endl;
if (result == 0)
cout<<"s1
== s2"<<endl;
if (result > 0)
cout<<"s1 > s2"<<endl;
}
void
main()
{
string text;
int result;
text = "A jackhammer";
result=text.compare(“jack”);
print(result);
result=text.compare(2,4,”jack”);
print(result);
}
Output :
s1
< s2
s1
== s2
find : find the first occurance of a
char or a substring in a string
rfind : find the last occurance of a
char or a substring in a string
#include<string>
using
namespace std;
size_type
find(const basic_string&, size_type = 0);
size_type
find(const charT*, size_type, size_type);
size_type
find(const charT*, size_type = 0) const;
size_type
find(charT, size_type = 0) const;;
Example1 :
#include
<iostream>
#include
<string>
using
namespace std;
void
main()
{
string text;
text = "Manners maketh man";
cout<<text.find('k')<<endl;
cout<<text.find('x')<<endl;
if(text.find('x') == string::npos)
{
cout<< "Character not
found" << endl;
}
}
Output1 :
10
4294967295
Character
not found
Example2 :
#include
<iostream>
#include
<string>
using
namespace std;
int
main()
{
string text = "Smith had had the
examiners had Bob’s approval.";
string word = "had";
int count = 0;
for(int index = 0 ; (index =
text.find(word, index)) != string::npos ; index += word.length(),
count++)
;
cout << "Your text contained
"<< count << " occurrences of \""<<
word << "\"."
<< endl;
return 0;
}
Output1 :
Your
text contained 3 occurrences of "had".
find_first_of : Find the first
occurance of a set of chars in a string.
find_first_not_of : Find the first
occurance not in a set of chars in a string.
find_last_of : likewise
find_last_not_of : likewise
#include
<string>
using
namespace std;
size_type
find_first_of(const basic_string& str, size_type pos = 0)
size_type
find_first_of(const charT* s, size_type pos, size_type n);
size_type
find_first_of(const charT* s, size_type pos = 0);
Example :
#include
<iostream>
#include
<string>
using
namespace std;
void
main()
{
string text = " Smith
had\"had\" the examiners had Bob's approval.";
string separators = "
,.\"";
int start =
text.find_first_not_of(separators);
int end = 0;
while(start != string::npos)
{
end =
text.find_first_of(separators, start + 1);
if(end == string::npos)
end =
text.length();
cout <<
text.substr(start, end - start)
<< endl;
start =
text.find_first_not_of(separators, end + 1);
}
}
Output :
Smith
had
had
the
examiners
had
Bob's
Approval
insert : insert a substring into a
string.
#include
<string>
using
namespace std;
basic_string&
insert(size_type pos1, const basic_string& s);
basic_string& insert(size_type pos, const basic_string& s, size_type pos2 = 0, size_type n = npos);
Example :
#include
<iostream>
#include
<string>
using
namespace std;
void
main()
{
string text, word;
text = "This is a sample";
word = "very good ";
text.insert(10,word,5,5);
cout<<text<<endl;
}
Output :
This
is a good sample
length : Get the length of a string.
#include
<string>
using
namespace std;
size_type
length() const;
Example :
#include
<iostream>
#include
<string>
using
namespace std;
void
main()
{
string text;
text = "This is a sample";
cout<<"text =
"<<text<<"\nlength of text =
"<<text.length()<<endl;
}
Output :
text
= This is a sample
length
of text = 16
replace : replace a substring of a
string into another string
#include
<string>
using
namespace std;
basic_string&
replace(size_type pos, size_type n1, const basic_string& s);
basic_string&
replace(size_type pos1, size_type n1, const basic_string& str, size_type
pos2, size_type n2);
Example :
#include
<iostream>
#include
<string>
using
namespace std;
void
main()
{
string text, word;
text = "This is a very good
sample";
word = "bad";
text.replace(10,9,word);
cout<<text<<endl;
}
Output :
This
is a bad sample
String manipulation(Compare
of C and C++):
C |
C++ |
char * strcat(char *, const char *); |
string + string |
char * strchr(const char *, int); |
string.find() |
char * strcpy(char *, const char *); |
string = string |
int strcmp(const char *, const char *); |
string1.compare(int index, int len, string2) |
size_t strlen(const char *); |
string.length() |
char * _strlwr(char *); |
for(i = 0;i<string.length();i++) { string[i].tolower(string[i]); } |
char * _strupr(char *) |
for(i = 0;i<string.length();i++) { string[i].toupper(string[i]); } |
char * strstr(const char *, const char *); |
string1.find(string2) |
char * strtok(char *, const char *); |
string1.find_first_of(string2) |
http://cs.stmarys.ca/~porter/csc/ref/c_cpp_strings.html
STL:
vector : A useful array like stuff.
#include
<vector>
Example :
#include
<vector>
#include
<iostream>
using
namespace std;
void
main()
{
int ia[] = {29,23,20,22,17,15,26,51,19,12,35,40};
vector<
int > vec( ia, ia+12 );
}
binary search : Doing binary search,
the input should be sorted
#include
<algorithm>
bool
binary_search (ForwardIterator first, ForwardIterator last,
const T & value [,
Compare ] );
Example :
#include
<algorithm>
#include
<vector>
#include
<functional>
#include
<iostream>
using
namespace std;
void
main()
{
int ia[] = {29,23,20,22,17,15,26,51,19,12,35,40};
vector<
int > vec( ia, ia+12 );
sort(
&ia[0], &ia[12] );
bool
found_it = binary_search( &ia[0], &ia[12], 18 );
sort(
vec.begin(), vec.end(), greater<int>() );
found_it
= binary_search( vec.begin(), vec.end(), 26,
greater<int>() );
if(found_it)
cout
<< "binary_search(): success!\n";
}
Output :
binary_search():
success!
lexicographical_compare : used to
determine the lexicographical order of words.
#include
<algorithm>
bool
lexicographical_compare (InputIterator first1, InputIterator last1,
InputIterator first2, InputIterator
last2 [, BinaryFunction ] );
Example :
#include
<algorithm>
#include
<list>
#include
<string>
#include
<iostream>
using
namespace std;
class
size_compare {
public:
bool
operator()( const string &a, const string &b ) {
return a.length()
<= b.length();
}
};
void
main()
{
string
arr1[] = { "Piglet", "Pooh", "Tigger" };
string
arr2[] = { "Piglet", "Pooch", "Eeyore" };
bool
res;
res =
lexicographical_compare( arr1, arr1+3,
arr2,
arr2+3 );
list<
string > ilist1( arr1, arr1+3 );
list<
string > ilist2( arr2, arr2+3 );
res =
lexicographical_compare(
ilist1.begin(),
ilist1.end(),
ilist2.begin(), ilist2.end(), size_compare() );
if(res)
cout
<< "ok: lexicographical_compare succeeded!\n";
}
Output :
ok:
lexicographical_compare succeeded!
permutation : Get the previous or next
permutation.
#include
<algorithm>
bool
next_permutation (BidirectionalIterator first,
BidirectionalIterator
last, [ Compare ] );
bool
prev_permutation (BidirectionalIterator first,
BidirectionalIterator
last, [ Compare ] );
Example :
#include
<algorithm>
#include
<vector>
#include
<iostream>
using
namespace std;
bool
nameCompare (char * a, char * b) { return strcmp(a, b) <= 0; }
void
main ()
{
ostream_iterator< char >
out_stream( cout, " " );
int start [] = { 1, 2, 3};
do
copy (start, start +
3, ostream_iterator<int,char> (cout, " ")), cout << endl;
while (next_permutation(start, start +
3));
char * words [] = {"Alpha",
"Beta", "Gamma"};
do
copy (words, words +
3, ostream_iterator<char *,char> (cout, " ")), cout <<
endl;
while (next_permutation(words, words +
3, nameCompare));
vector<char> word(4);
word[0] = 'b'; word[1] = 'e'; word[2] =
'l'; word[3] = 'a';
do
copy(
word.begin(), word.end(), out_stream ), cout << endl;
while (prev_permutation
(word.begin(),word.end()));
cout << endl;
}
Output :
1
2 3
1
3 2
2
1 3
2
3 1
3
1 2
3
2 1
Alpha
Beta Gamma
Alpha
Gamma Beta
Beta
Alpha Gamma
Beta
Gamma Alpha
Gamma
Alpha Beta
Gamma
Beta Alpha
b
e l a
b
e a l
b
a l e
b
a e l
a
l e b
a
l b e
a
e l b
a
e b l
a
b l e
a
b e l
sort : Sort the elements.
void
sort (RandomAccessIterator first,
RandomAccessIterator
last [, Compare ] );
void
stable_sort (RandomAccessIterator first,
RandomAccessIterator
last [, Compare ] );
The
sort() algorithm is slightly faster, but it does not guarantee that equal
elements in the original sequence retain their relative orderings in the final
result. If order is important, the stable_sort() version should be used.
Example :
#include
<algorithm>
#include
<vector>
#include<queue>
#include
<iostream>
using
namespace std;
int
randomInteger (unsigned int n) { return rand() % n; }
int
randomValue () { return randomInteger(100); }
void
main ()
{
vector<int> aVec(15);
deque<int> aDec(15);
ostream_iterator< int >
out_stream( cout, " " );
generate (aVec.begin(), aVec.end(),
randomValue);
generate (aDec.begin(), aDec.end(),
randomValue);
sort (aVec.begin(), aVec.end());
copy( aVec.begin(), aVec.end(),
out_stream ); cout << "\n";
sort (aDec.begin(), aDec.end(),
greater<int>() );
copy( aDec.begin(), aDec.end(),
out_stream ); cout << "\n";
sort (aVec.rbegin(), aVec.rend());
copy( aVec.begin(), aVec.end(),
out_stream ); cout << "\n";
}
Output :
0 5 24 27 34 41 45 58 61 62 64 67 69 78 81
95 95 92 91 91 82 53 42 36 27 21 18 16 4 2
81 78 69 67 64 62 61 58 45 41 34 27 24 5 0