【C++】从设计原理来看string类

typedef char* PCHAR;
PCHAR pa, pb; // 同时声明两个char类型的指针pa和pb
char* pa, pb; // 声明一个指针（pa）和一个char变量（pb）
// 下边的声明也是创建两个char类型的指针。但相对没有typedef的形式直观，尤其在需要大量指针的地方
char *pa, *pb;

char *pa; // 强调*pa是一个char类型的值，C中多用这种格式。
char* pa; // 强调char*是一种类型——指向char的指针。C++中多用此种格式。另外在C++中char*是一种复合类型。

1 // 定义
2 struct StudentStruct
3 {
4 int ID;
5 string name;
6 };
7 // C声明StudentStruct类型对象
8 struct StudentStruct s1;

1 // 定义
2 typedef struct StudentStruct
3 {
4 int ID;
5 string name;
6 }Student;
7 // C声明StudentStruct类型对象s1和s2
8 Student s1, s2;

// C++声明StudentStruct类型对象s1和s2
StudentStruct s1，s2;

typedef long double REAL;

typedef double REAL;

typedef float REAL;

1 // Definitions of common types
2 #ifdef _WIN64
3 typedef unsigned __int64 size_t;
4 typedef __int64 ptrdiff_t;
5 typedef __int64 intptr_t;
6 #else
7 typedef unsigned int size_t;
8 typedef int ptrdiff_t;
9 typedef int intptr_t;
10 #endif

1 // 理解下边这种复杂声明可用“右左法则”：
2 // 从变量名看起，先往右，再往左，碰到一个圆括号就调转阅读的方向；括号内分析完就跳出括号，还是按先右后左的顺序，如此循环，直到整个声明分析完。
3
4 // 例1
5 void* (*(*a)(int))[10];
6 // 1、找到变量名a，往右看是圆括号，调转方向往左看到*号，说明a是一个指针；
7 // 2、跳出内层圆括号，往右看是参数列表，说明a是一个函数指针，接着往左看是*号，说明指向的函数返回值是指针；
8 // 3、再跳出外层圆括号，往右看是[]运算符，说明函数返回的是一个数组指针，往左看是void*，说明数组包含的类型是void*。
9 // 简言之，a是一个指向函数的指针，该函数接受一个整型参数并返回一个指向含有10个void指针数组的指针。
10
11 // 例2
12 float(*(*b)(int, int, float))(int);// 1、找到变量名b，往右看是圆括号，调转方向往左看到*号，说明b是一个指针；
13 // 2、跳出内层圆括号，往右看是参数列表，说明b是一个函数指针，接着往左看是*号，说明指向的函数返回值是指针；
14 // 3、再跳出外层圆括号，往右看还是参数列表，说明返回的指针是一个函数指针，该函数有一个int类型的参数，返回值类型是float。
15 // 简言之，b是一个指向函数的指针，该函数接受三个参数(int, int和float)，且返回一个指向函数的指针，该函数接受一个整型参数并返回一个float。
16
17 // 例3
18 double(*(*(*c)())[10])();
19 // 1、先找到变量名c（这里c其实是新类型名），往右看是圆括号，调转方向往左是*，说明c是一个指针；
20 // 2、跳出圆括号，往右看是空参数列表，说明c是一个函数指针，接着往左是*号，说明该函数的返回值是一个指针；
21 // 3、跳出第二层圆括号，往右是[]运算符，说明函数的返回值是一个数组指针，接着往左是*号，说明数组中包含的是指针；
22 // 4、跳出第三层圆括号，往右是参数列表，说明数组中包含的是函数指针，这些函数没有参数，返回值类型是double。
23 // 简言之，c是一个指向函数的指针，该函数无参数，且返回一个含有10个指向函数指针的数组的指针，这些函数不接受参数且返回double值。
24
25 // 例4
26 int(*(*d())[10])(); // 这是一个函数声明，不是变量定义
27 // 1、找到变量名d，往右是一个无参参数列表，说明d是一个函数，接着往左是*号，说明函数返回值是一个指针；
28 // 2、跳出里层圆括号，往右是[]运算符，说明d的函数返回值是一个指向数组的指针，往左是*号，说明数组中包含的元素是指针；
29 // 3、跳出外层圆括号，往右是一个无参参数列表，说明数组中包含的元素是函数指针，这些函数没有参数，返回值的类型是int。
30 // 简言之，d是一个返回指针的函数，该指针指向含有10个函数指针的数组，这些函数不接受参数且返回整型值。

void* (*(*a)(int))[10];
void* (*(*a2)(int))[10];

// 在之前的定义前边加typedef，然后将变量名a替换为类型名A
typedef void* (*(*A)(int))[10];// 定义相同类型的变量a和a2
A a, a2;

typedef char* PSTR;
int mustrcmp(const PSTR, const PSTR); 

typedef static int INT2; 

1 #define add(x, y) (x + y) //此处要打括号，不然执行2*add(x,y)会变成 2*x + y
2 int main()
3 {
4 std::cout << add(9, 12) << std::endl; // 输出21
5 return 0;
6 }

#ifndef DATATYPE_H
#define DATATYPE_H
...
#endif

1 #ifdef WINDOWS
2 ...
3 (#else)
4 ...
5 #endif
6 #ifdef LINUX
7 ...
8 (#else)
9 ...
10 #endif

1 #include <stdio.h>
2 #define trace(x, format) printf(#x " = %" #format "\n", x)
3 #define trace2(i) trace(x##i, d)
4
5 int main(int argc, _TCHAR* argv[])
6 {
7 int i = 1;
8 char *s = "three";
9 float x = 2.0;
10
11 trace(i, d); // 相当于 printf("x = %d\n", x)
12 trace(x, f); // 相当于 printf("x = %f\n", x)
13 trace(s, s); // 相当于 printf("x = %s\n", x)
14
15 int x1 = 1, x2 = 2, x3 = 3;
16 trace2(1); // 相当于 trace(x1, d)
17 trace2(2); // 相当于 trace(x2, d)
18 trace2(3); // 相当于 trace(x3, d)
19
20 return 0;
21 }
22
23 // 输出：
24 // i = 1
25 // x = 2.000000
26 // s = three
27 // x1 = 1
28 // x2 = 2
29 // x3 =3

1 #define PR(...) printf(__VA_ARGS__)
2 int main()
3 {
4 int wt=1,sp=2;
5 PR("hello\n"); // 输出：hello
6 PR("weight = %d, shipping = %d",wt,sp); // 输出：weight = 1, shipping = 2
7 return 0;
8 }

#include // 包含一个源代码文件
#define // 定义宏
#undef // 取消已定义的宏
#if // 如果给定条件为真，则编译下面代码
#ifdef // 如果宏已定义，则编译下面代码
#ifndef // 如果宏没有定义，则编译下面代码
#elif // 如果前面#if给定条件不为真，当前条件为真，则编译下面代码
#endif // 结束一个#if...#else条件编译块
#error // 停止编译并显示错误信息__FILE__ // 在预编译时会替换成当前的源文件cpp名
__LINE__ // 在预编译时会替换成当前的行号
__FUNCTION__ // 在预编译时会替换成当前的函数名称
__DATE__ // 进行预处理的日期（“Mmm dd yyyy”形式的字符串文字）
__TIME__ // 源文件编译时间，格式为“hh：mm：ss”

#define BYTE char // 将Byte作为char的别名
typedef char byte;

typedef float* float_pointer;

#define FLOAT_POINTER float*
FLOAT_POINTER pa, pb;

using namespace std; // 也可在代码中直接使用std::

// 使用using（C++11）
using counter = long;// 使用typedef（C++03）
// typedef long counter;

1 // 使用using（C++11）
2 using func = void(*)(int);
3
4 // 使用typedef（C++03）
5 // typedef void (*func)(int);
6
7 // func can be assigned to a function pointer value
8 void actual_function(int arg) { /* ... */ }
9 func fptr = &actual_function;

template<typename T> using ptr = T*;// the name 'ptr<T>' is now an alias for pointer to T
ptr<int> ptr_int;

template <class T1, class T2>...
template <typename T1, typename T2>...

template<class T> class X
{
typename T::Y m_y; // m_y依赖于模板参数T，所以m_y是依赖名称；m_y同时又嵌套在X类中，所以m_y又是嵌套依赖名称
};

1 template <class T>
2 class C1 : typename T::InnerType // Error - typename not allowed.
3 {};
4 template <class T>
5 class C2 : A<typename T::InnerType> // typename OK.
6 {};

template <typename T> // or template <class T>
void f(T a, T b)
{...}

1 #include <iostream>
2
3 // 常规模板
4 template <typename T>
5 void Swap(T &a, T &b);
6
7 struct job
8 {
9 char name[40];
10 double salary;
11 int floor;
12 };
13
14 // 显示具体化
15 template <> void Swap<job>(job &j1, job &j2);
16
17 int main()
18 {
19 using namespace std;
20 cout.precision(2); // 保留两位小数精度
21 cout.setf(ios::fixed, ios::floatfield); // fixed设置cout为定点输出格式；floatfield设置输出时按浮点格式，小数点后有6为数字
22
23 int i = 10, j = 20;
24 Swap(i, j); // 生成Swap的一个实例：void Swap(int &, int&)
25 cout << "i, j = " << i << ", " << j << ".\n";
26
27 job sxx = { "sxx", 200, 4 };
28 job xt = { "xt", 100, 3 };
29 Swap(sxx, xt); // void Swap(job &, job &）
30 cout << sxx.name << ": " << sxx.salary << " on floor " << sxx.floor << endl;
31 cout << xt.name << ": " << xt.salary << " on floor " << xt.floor << endl;
32
33 return 0;
34 }
35
36 // 通用版本，交换两个类型的内容，该类型可以是结构体
37 template <typename T>
38 void Swap(T &a, T &b)
39 {
40 T temp;
41 temp = a;
42 a = b;
43 b = temp;
44 }
45
46 // 显示具体化，仅仅交换job结构的salary和floor成员，而不交换name成员
47 template <> void Swap<job>(job &j1, job &j2)
48 {
49 double t1;
50 int t2;
51 t1 = j1.salary;
52 j1.salary = j2.salary;
53 j2.salary = t1;
54 t2 = j1.floor;
55 j1.floor = j2.floor;
56 j2.floor = t2;
57 }

1 template <class T>
2 void Swap(T &, T &); // 模板原型
3
4 template <> void Swap<job>(job &, job &); // 显示具体化
5 template void Swap<char>(char &, char &); // 显式实例化
6
7 int main(void)
8 {
9 short a, b;
10 Swap(a, b); // 隐式实例化
11
12 job n, m;
13 Swap(n, m); // 使用显示具体化
14
15 char g, h;
16 Swap(g, h); // 使用显式模板实例化
17 }

template <class T1, Class T2>
auto ft(T1 x, T2 y) -> decltype(x + y)
{
return x + y;
}

1 // 类模板定义
2 template <typename T> // or template <class T>
3 class A
4 {...}
5
6 // 实例化
7 A<t> st; // 用具体类型t替换泛型标识符(或者称为类型参数）T

1 // 通用模板
2 template <typename T1, typename T2> class Pair {...};
3 // 部分具体化模板（T1不变，T2具体化为int）
4 template <typename T1> class Pair<T1, int> {...};
5 // 显示具体化（T1和T2都具体化为int）
6 template <> calss Pair<int, int> {...};

Pair<double, double> p1; // 使用通用模板进行实例化
Pair<double, int> p2; // 使用Pair<T1, int>部分具体化模板进行实例化
Pair<int, int> p3; // 使用Pair<T1, T2>显式具体化模板进行实例化

// 通用模板
template <typename T> class Feeb {...};
// 指针部分具体化模板
template <typename T*> class Feeb {...};

Feeb<char> fb1; // 使用通用模板，T为char类型
Feeb<char *> fb2; // 使用Feeb T*具体化，T为char类型

1 #include <iostream>
2 using std::cout;
3 using std::endl;
4
5 template <typename T>
6 class beta
7 {
8 private:
9 template <typename V> // 嵌套的模板类成员（只能在beta类中访问）
10 class hold
11 {
12 private:
13 V val;
14 public:
15 hold(V v = 0) :val(v) {}
16 void show() const { cout << val << endl; }
17 V value() const { return val; }
18 };
19 // beta类使用hold模板声明两个数据成员
20 hold<T> q; // q是基于T类型（beta模板参数）的hold对象
21 hold<int> n; // n是基于int的hold对象
22 public:
23 beta(T t, int i) :q(t), n(i) {}
24 template <typename U> // 模板方法
25 U blab(U u, T t) { return (n.value() + q.value()) * u / t; }
26 void Show() const { (q.show(); n.show(); }
27 };
28
29 int main()
30 {
31 beta<double> guy(3.5, 3);
32 cout << "T was set to double\n";
33 guy.Show();
34 cout << "V was set to T, which id double, then V was set to int\n";
35 cout << guy.blab(10, 2.3) << endl;
36 cout << "U was set to int\n";
37 cout << guy.blab(10.0, 2.3) << endl;
38 cout << "U was set to double\n";
39 cout << "Done\n";
40 return 0;
41 }

template <template <typename T> class Type>
class B

1 #include <iostream>
2 #include "stacktp.h"
3 template <template <typename T> class Thing>
4 class Crab
5 {
6 private:
7 Thing<int> s1;
8 Thing<double> s2;
9 public:
10 Crab() {};
11 // 假设pop()和push()是Thing类的成员函数
12 bool push(int a, double x) { return s1.push(a) && s2.push(x); }
13 bool pop(int& a, double& x) { return s1.pop(a) && s2.pop(x); }
14 };
15
16 int main()
17 {
18 using std::cout;
19 using std::cin;
20 using std::endl;
21
22 Crab<Stack> nebula;
23 int ni;
24 double nb;
25 while (cin >> ni >> nb && ni > 0 && nb > 0)
26 {
27 if (!nebula.push(ni, nb))
28 break;
29 }
30 while (nebula.pop(ni, nb))
31 cout << ni << ", " << nb << endl;
32 cout << "Done.\n";
33 return 0;
34 }

vector<int> vec{ 0,1,2,3,4 };
for (auto it = begin(vec); it != end(vec); it++)
{
// 使用解除引用运算符访问元素
cout << *it << " ";
}

for (auto num : vec)
{
// 不使用解除引用运算符
cout << num << " ";
}

#define SQUARE(X) X*X
a = SQUARE(2 + 3) // 相当于 a = 2 + 3 * 2 + 3

1 class Time
2 {
3 private:
4 int hours;
5 int minutes;
6 public:
7 Time();
8 Time(int h, int m = 0);
9 void AddMin(int m);
10 void AddHr(int h);
11 void Reset(int h = 0, int m = 0);
12 Time Sum(const Time& t) const; // Sum函数
13 Time operator+ (const Time & t) const; // 使用重载的加法运算符
14 void Show() const;
15 };
16
17 Time::Time()
18 {
19 hours = minutes = 0;
20 }
21
22 Time::Time(int h, int m)
23 {
24 hours = h;
25 minutes = m;
26 }
27
28 void Time::AddMin(int m)
29 {
30 minutes += m;
31 hours += minutes / 60;
32 minutes %= 60;
33 }
34
35 void Time::AddHr(int h)
36 {
37 hours += h;
38 }
39
40 void Time::Reset(int h, int m)
41 {
42 hours = h;
43 minutes = m;
44 }
45
46 // 注意：不要返回指向局部变量或临时对象的引用。函数执行完毕后，局部变量和临时对象将消失，引用将指向不存在的数据。
47 Time Time::Sum(const Time& t) const
48 {
49 Time sum;
50 sum.minutes = minutes + t.minutes;
51 sum.hours = hours + t.hours + t.minutes / 60;
52 sum.minutes %= 60;
53 return sum;
54 }
55
56 Time Time::operator+(const Time& t) const
57 {
58 Time sum;
59 sum.minutes = minutes + t.minutes;
60 sum.hours = hours + t.hours + t.minutes / 60;
61 sum.minutes %= 60;
62 return sum;
63 }
64
65 void Time::Show() const
66 {
67 std::cout << hours << " hours, " << minutes << " minutes";
68 }
69
70 int main()
71 {
72 using std::cout;
73 using std::endl;
74 Time planning;
75 Time coding(2, 40);
76 Time fixing(5, 55);
77 Time total;
78
79 cout << "planning time = ";
80 planning.Show();
81 cout << endl;
82
83 cout << "coding time = ";
84 coding.Show();
85 cout << endl;
86
87 cout << "fixing time = ";
88 fixing.Show();
89 cout << endl;
90
91 // Sum函数
92 total = coding.Sum(fixing);
93 cout << "coding.sum(fixing) = ";
94 total.Show();
95 cout << endl;
96
97 // 使用重载运算符
98 total = coding + fixing; // 与下一句代码等效
99 total = coding.operator+(fixing);
100 cout << "coding + fixing = ";
101 total.Show();
102 cout << endl;
103
104 return 0;
105 }

total = coding + fixing;
total = coding.operator+(fixing);

1 void (Test::*pfunc)() = &Test::func;
2 Test t1;
3 Test* t2 = new Test();
4
5 t1.func(); // 正常调用类成员方法
6 (t1.*pfunc)(); // 通过函数指针调用类成员方法
7
8 t2->func(); // 正常调用类成员方法
9 (t2->*pfunc)(); // 通过函数指针调用类成员方法

1 #include <iostream>
2
3 using namespace std;
4 class Point
5 {
6 friend void ChangePrivate(Point&);
7 public:
8 Point(void) : m_i(0) {} // 构造函数成员初始化列表
9 void PrintPrivate(void) { cout << m_i << endl; }
10
11 private:
12 int m_i;
13 };
14
15 void ChangePrivate(Point& i) { i.m_i++; }
16
17 int main()
18 {
19 Point sPoint;
20 sPoint.PrintPrivate();
21 ChangePrivate(sPoint);
22 sPoint.PrintPrivate();
23 // Output: 0
24 // 1
25 }

1 Class Tv; // 前向声明，避免循环依赖
2
3 class Remote
4 {
5 public:
6 void set_chan(Tv & t, int c) {t.channel = c;} // 内联函数
7 ...
8 };
9
10 Class Tv
11 {
12 private:
13 int channel;
14 public:
15 friend void Remote::set_chan(Tv & t, int c);
16 ...
17 };

1 Class Tv
2 {
3 friend class Remote;
4 public:
5 void buzz(Remote & r);
6 ...
7 };
8
9 class Remote
10 {
11 friend class Tv;
12 public:
13 void Bool volup(Tv & t) { t.volup(); }
14 ...
15 };
16
17 inline void Tv::buzz(Remote & r)
18 {
19 ...
20 }

1 class B; // 前向声明（forward declaration）
2 class A
3 {
4 friend void sync(B& a, const A& p); // sync a to p
5 friend void sync(A& P, const B& a); // sync p to a
6 };
7 class B
8 {
9 friend void sync(B& a, const A& p); // sync a to p
10 friend void sync(A& P, const B& a); // sync p to a
11 };
12
13 // 友元函数定义
14 inline void sync(B& a, const A& p)
15 {
16 ...
17 }
18 inline void sync(A& P, const B& a)
19 {
20 ...
21 }

1 #include <iostream>
2
3 int main()
4 {
5 using namespace std;
6 char ch = 'M';
7 int i = ch;
8 cout << "The ASCII code for " << ch << " is " << i << endl;
9
10 ch += 1;
11 i = ch;
12 cout << "The ASCII code for " << ch << " is " << i << endl;
13
14 cout << "Displaying char ch using cout.put(ch): ";
15 cout.put(ch);
16
17 cout.put('!');
18 return 0;
19 }

cout << endl;
cout << '\n';
cout << "\n"; // 相当于'\n'在字符串中，不需要加单引号

wchar_t blb = L'P'
wcout << L"tall" << endl;

1 #define _STD ::std::
2
3 template <class _Elem, // _Elem是存储在字符串中的类型
4 class _Traits = char_traits<_Elem>, // _Traits参数是一个类，定义了类型要被表示为字符串时，所必须具备的特征
5 class _Alloc = allocator<_Elem>> // _Alloc是用于处理字符串内存分配的类
6 class basic_string
7 { // null-terminated transparent array of elements
8 private:
9 friend _Tidy_deallocate_guard<basic_string>;
10 friend basic_stringbuf<_Elem, _Traits, _Alloc>;
11
12 using _Alty = _Rebind_alloc_t<_Alloc, _Elem>;
13 using _Alty_traits = allocator_traits<_Alty>;
14
15 ...
16
17 public:
18 // using源于C++11，等价于C++98的typedef，比如下边第一行代码相当于：typedef _Traits traits_type;
19 using traits_type = _Traits; // _Traits是对应于特定类型（如char_traits<char>）的模板参数
20 using allocator_type = _Alloc;
21
22 using value_type = _Elem;
23 using size_type = typename _Alty_traits::size_type; // 根据存储的类型返回字符串的长度（无符号类型）
24 using difference_type = typename _Alty_traits::difference_type; // 用于度量字符串中两个元素之间的距离（size_type有符号版本）
25 using pointer = typename _Alty_traits::pointer; // 对于char具体化，pointer类型为char *，与基本指针有着相同的特征
26 using const_pointer = typename _Alty_traits::const_pointer;
27 using reference = value_type&; // 对于char具体化，reference类型为char &，与基本引用有着相同的特征
28 using const_reference = const value_type&;
29
30 using iterator = _String_iterator<_Scary_val>; // 迭代器类型
31 using const_iterator = _String_const_iterator<_Scary_val>;
32
33 using reverse_iterator = _STD reverse_iterator<iterator>;
34 using const_reverse_iterator = _STD reverse_iterator<const_iterator>;
35
36 ...
37
38 // 静态常量npos，size_type是无符号的，因此将-1赋给npos相当于将最大的无符号值赋给它，这个值比可能的最大数组索引大1
39 static constexpr auto npos{ static_cast<size_type>(-1) };
40 };

using string = basic_string<char, char_traits<char>, allocator<char>>;
using wstring = basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t>>;
using u16string = basic_string<char16_t, char_traits<char16_t>, allocator<char16_t>>;
using u32string = basic_string<char32_t, char_traits<char32_t>, allocator<char32_t>>;

1 #include <string>
2 #include <iostream>
3
4 int main()
5 {
6 using namespace std;
7
8 string one("SXX Winner!"); // ctor 1，将string对象one初始化为常规的C-风格字符串
9 cout << one << endl;
10
11 string two(20, '$'); // ctor 2，将string对象two初始化为由20个$字符组成的字符串
12 cout << two << endl;
13
14 string three(one); // ctor 3，复制构造函数将string对象three初始化为one
15 cout << three << endl;
16
17 one += " Oops!";
18 cout << one << endl;
19
20 two = "Sorry! That was ";
21 three[0] = 'Y';
22 string four; // ctor 4，默认构造函数创建一个以后可以对其进行赋值的空字符串
23 four = two + three;
24 cout << four << endl;
25
26 char alls[] = "All's well that ends well";
27 string five(alls, 20); // ctor 5, 将five初始化为alls的前20个字符
28 cout << five << "!\n";
29
30 string six(alls + 6, alls + 10);
31 cout << six << ", "; // ctor 6，将string对象six初始化为区间[6,10)内的字符
32
33 string seven(&five[6], &five[10]); // ctor 6, five[6]是一个char值，&five[6]是地址
34 cout << seven << "...\n";
35
36 string eight(four, 7, 16); // ctor 7, 将对象four的部分内容复制到构造的对象中
37 cout << eight << " in motion!" << endl;
38
39 return 0;
40 }

1 // 能够使用数组表示法来访问字符串的元素，可用于检索或更改值
2 reference operator[](size_type pos);
3 // 可用于const对象，但只能用来检索值
4 const_reference operator[](size_type pos) const;
5 // 功能同第一句代码，索引通过函数参数提供
6 reference at(size_type n);
7 // 功能同第二句代码，索引通过函数参数提供
8 const_reference at(size_type n) const;

string snake("cobra");
int where = snake.find_first_of("hark") // 返回r在“cobra”中的位置（即索引3）

string snake("cobra");
int where = snake.find_last_of("hark") // 返回a在“cobra”中的位置（即索引4）

string snake("cobra");
int where = snake.find_first_not_of("hark") // 返回c在“cobra”中的位置（即索引0）,因为“hark”中没有c

string snake("cobra");
int where = snake.find_first_not_of("hark") // 返回b在“cobra”中的位置（即索引2）,因为“hark”中没有b

basic_string& assign(const basic_string& str)

// copy()原型，s指向目标数组，n是要复制的字符串，pos指从string对象的什么位置开始复制
size_type copy(charT* s, size_type n, size_type pos = 0) const;// swap()原型
void swap(basic_string& str);

char info[100];
cin >> info; // read a word
cin.getline(info, 100); // read a line, discard \n
cin.get(info, 100); // read a line, leave \n in queue

string stuff;
cin >> stuff; // read a word
getline(cin, stuff); // read a line, discard \n

cin.getline(info, 100, ':'); // read up to :, discard :
getline(cin, stuff, ':'); // read up to :, discard :