10分钟带你复习C++基本的操作--赶快上车

自己选的路，含着泪也要走完。既然选择了C++，就要坚持下去。

高楼想要盖的高，地基要打的好，学习也是，基础一定要打好。所以，要时不时的复习一下基本的知识点。（废话不多说，系好安全带，准备起飞。）

C++ 是 C 语言的超集， 因此它有了C语言之外的新特性：

1. 命名空间 namespace    解决了变量名字冲突的问题。 使用格式 using namespace  命名空间名; 标准命名空间 std;

2.引用　　&  是一个变量的别名，它不是一种数据类型，使用引用时必须对其初始化。

3.对堆空间的操作   new  delete  new运算符分配的空间在明确指定初始化参数时进行初始化，否则不进行初始化。 用法 指针变量名 = new 类型名（初始化表达式）;  delete 指针名;

4.类   class  由 C语言的结构体演变过来，抽象类型的集合。

5.this 指针   this指针是C++实现封装的一种机制，它将对象和该对象的成员函数连接在一起

6.输入/输出 cin cout 以二进制流输入输出 PS：以前在杭电的一道题，用cin用做输入操作，OJ过不来，代码没有动，只是把cin 变成 scanf 就过了，我想这是因为cin 转换乘二进制代码流效率降低了。

7.模版：函数模板，类模板。 template <class T>  此特性增加了代码的重用性。

乐迪加速~~~（小侄子喜欢看《超级飞侠》）

封装：隐藏对象的属性和方法，只能通过公开的接口进行访问。

继承：子类直接使用父类的属性和方法。继承方式 公有继承，保护继承，私有继承

基类成员在派生类中的访问权限如下：

继承方式/成员权限　　　　public　　　　protected　　　　private

public 公有继承　　　　   public　　　　protected　　　　不可访问

private 私有继承　　　　 private 　　　 private   　　　　 不可访问

protected 保护继承         protected       protected             不可访问

多态：向不同的对象发送同一个消息，不同的对象会产生不同的行为。

C++ 支持两种多态形式：

1.编译时的多态，静态联编。是通过重载的方式来实现的。

2.运行时的多态，动态联编。是通过继承和虚函数来实现的。

重载：（以[]重载和<< >> 操作符重载为例）

<<  >> 重载：

 1 #include <iostream>
 2 
 3 using namespace std;
 4 
 5 class  CMoney
 6 {
 7 public:
 8     friend ostream& operator<<(ostream &os,CMoney &m);
 9     friend istream& operator>>(istream &is,CMoney &m);
10     CMoney(int m = 0,int c = 0)
11     {
12         Dollar = m;
13         Cents = c;
14     }
15 public:
16     int Dollar;
17     int Cents;
18 };
19 
20 ostream & operator<<(ostream &os,CMoney &m)
21 {
22     os << "$" << m.Dollar << "元\t" << m.Cents << "分" << endl;
23     return os;
24 }
25 istream & operator>>(istream &is,CMoney &m)
26 {
27     is >> m.Dollar >> m.Cents;
28     return is;
29 }
30 int main()
31 {
32     CMoney m;
33     cin >> m;
34     cout << m;
35     return 0;
36 }

[]重载：

 1 #include <iostream>
 2 #include <string.h>
 3 using namespace std;
 4 
 5 class Parent
 6 {
 7 public:
 8     Parent(char *s)
 9     {
10       this->str = new char [strlen(s) + 1];
11       strcpy(this->str,s);
12       this->m_len = strlen(s);
13     }
14     Parent(int len)
15     {
16         this->m_len = len;
17         str = new char[this->m_len + 1];
18         *(str + this->m_len) = '\0';
19     }
20     ~Parent()
21     {
22         delete str;
23     }
24     char &operator[](int n)
25     {
26 
27         static char ch = 0;
28         if (n > m_len)
29         {
30             cout << "数组下标越界" << endl;
31             return ch;
32         }
33         else
34         {
35             return *(str + n); // 返回偏移量
36 
37         }
38     }
39     void display()
40     {
41         cout << str << endl;
42     }
43 private:
44     int m_len;
45     char *str;
46 };
47 
48 
49 int main()
50 {
51     Parent p1("I love you1very much!");
52     p1.display();
53     cout << p1[0] << endl;
54     p1[0] = 't';
55     Parent p2(10);
56     for (int i = 0;i < 10; ++i)
57     {
58         p2[i] = p1[i];
59     }
60     p2.display();
61     return 0;
62 }

模版在以后的STL学习中至关重要，它提高了代码的重用性。下面以两个简单的例子说明，函数模版，和类模版

函数模版：

 1 #include <iostream>
 2 
 3 using namespace std;
 4 
 5 template <class T>
 6 
 7 void swapx(T &a, T &b)
 8 {
 9     T temp;
10     temp  = a;
11     a  = b;
12     b = temp;
13 }
14 
15 int main()
16 {
17     int a,b;
18     char m,n;
19     double x,y;
20 
21     cin >> a >> b;
22     cin >> m >> n;
23     cin >> x >> y;
24 
25     swapx(a,b);
26     swapx(m,n);
27     swapx(x,y);
28 
29     cout << a << " " << b << endl;
30     cout << m << " " << n << endl;
31     cout << x << " " << y << endl;
32 
33     return 0;
34 }

类模版：

 1 #include <iostream>
 2 
 3 using namespace std;
 4 
 5 struct student
 6 {
 7     int id;
 8     int score;
 9 };
10 template <class T>
11 
12 class buffer
13 {
14 private:
15     T a;
16     int em;
17 public:
18     buffer();
19     T get();
20     void put(T x);
21 };
22 
23 template <class T>
24 
25 buffer <T>::buffer():em(0)
26 {
27 
28 }
29 
30 template <class T>
31 
32 T buffer <T>::get()
33 {
34     if (em == 0)
35     {
36         cout << "em:" << endl;
37     }
38     return a;
39 }
40 template <class T>
41 
42 void buffer<T>::put(T x)
43 {
44     em ++;
45     a = x;
46 }
47 
48 
49 int main()
50 {
51     student s = {541426,99};
52 
53     buffer <int> i1,i2;
54     buffer <student> stu;
55     buffer <double> d;
56     i1.put(13);
57     i2.put(-1101);
58     cout << i1.get() << " " << i2.get() << endl;
59     stu.put(s);
60     int x = stu.get().id;
61     int y = stu.get().score;
62 
63     cout << "debug :" << x << endl;
64     cout << "debug :" << y<< endl;
65 
66     return 0;
67 }

异常处理模式：

1.终止模式：程序抛出异常后，捕捉异常并退出导致异常的子程序或子系统。 默认情况下，C++才用这种处理模式

2.恢复模式：异常抛出后，捕捉异常并试图去纠正或调整引起异常的条件，然后从发生异常的地方继续执行。

在C++的异常处理中，个人感觉比Java的异常处理要难，虽然都是利用try - catch 块来处理，但是C++更贴近于底层，不像Java那样将底层的东西封装好了。

简单的复习到站了，虽然内容简单，但有的概念是必须要知道的，个人觉得学一门语言，并不是了解它的语法和编程法则这么简单，而是去真正去理解它的概念和原理。上文如有错误的地方，欢迎大家指正。稍后会持续更新C++ STL的学习分享，敬请关注。谢谢~

posted @ 2016-09-12 22:12  风景如画  阅读(640)  评论(0)  编辑  收藏  举报