C++结构与指针解析-优快云博客

本文链接：https://blog.youkuaiyun.com/xmxoxo/article/details/1389743

Echo
(66189??) 23:25:33
C++学习笔记之“动态数组”
http://blog.youkuaiyun.com/xmxoxo/archive/2006/11/05/1367855.aspx

Echo
(66189??) 23:26:05
指针还可以指向指针

Echo
(66189??) 23:26:11
很好用

橘子/tp
(613184??) 23:26:50
嗯，

Echo
(66189??) 23:26:50
指向结构；指向函数

橘子/tp
(613184??) 23:27:04
对了，结构指针是怎么回事啊

橘子/tp
(613184??) 23:27:31
就是在创建链表的时候会用到那个＊ｎｅｘｔ

Echo
(66189??) 23:27:32
就像一个小标签，你想记什么东西，不用记一大堆，拿个小标签，写上东西在哪，拿着这个小标签就行了

Echo
(66189??) 23:28:11
要找的时候，找小标签，看上面写的内容，就知道东西在哪个房间，去找就找到了

橘子/tp
(613184??) 23:28:21
ｔｙｐｅｄｅｆ　ｓｔｒｕｃｔ　ｎｙｒ｛
ｉｎｔ　ｄａｔｅ；
ｓｔｒｕｃｔ　ｎｙｒ　＊ｎｅｘｔ；
｝；

Echo
(66189??) 23:28:37
只要理解是个标签很好明白了

橘子/tp
(613184??) 23:28:46
嗯，

Echo
(66189??) 23:28:51
链表之类的都是这样

橘子/tp
(613184??) 23:29:10
嗯，　

Echo
(66189??) 23:29:52
相当于我放了个礼物在103房间，同时在103房间里放了个纸条，上面写着另一个礼物在哪个房间

橘子/tp
(613184??) 23:29:55
呵呵，我现在有点明白这个意思了呵呵

Echo
(66189??) 23:30:14
你先去103房间，拿礼物，再看纸条

Echo
(66189??) 23:30:21
就知道下个礼物在哪了

橘子/tp
(613184??) 23:30:38
呵呵，真的很贴切

橘子/tp
(613184??) 23:30:40
呵呵

Echo
(66189??) 23:30:54
比如给你100个礼物，我不用给你100个纸条啊

Echo
(66189??) 23:31:00
只要给你第一个纸条

Echo
(66189??) 23:31:13
第一个纸条上面写103，你就去103，

Echo
(66189??) 23:31:22
里面有礼物和下一个礼物的房间号

Echo
(66189??) 23:31:33
然后下一个房间里也是这样

Echo
(66189??) 23:31:37
这样串下去

橘子/tp
(613184??) 23:31:38
嗯　

Echo
(66189??) 23:31:47
你就找到全部100个了

橘子/tp
(613184??) 23:32:05
嗯，
'----------------------------------------------------------
Echo
(66189??) 23:32:06
如果你要找最后一个，哈，没办法，只好从第一个找起

橘子/tp
(613184??) 23:32:17
呵呵，　嗯　

Echo
(66189??) 23:32:29
双向链表；循环链表。。。。其它的都是这样

橘子/tp
(613184??) 23:32:44
嗯呵呵

橘子/tp
(613184??) 23:33:21
呵呵，真是太谢谢你了，每次有问题，都得麻烦你呵呵

Echo
(66189??) 23:33:30
定义这个结构的时候，只是描述一下房间，以及房间里的礼物（就是数据）和纸条（就是指针）怎么放的

Echo
(66189??) 23:34:07
纸条上写的是房间号，房间就是另一个结构，号就是他的地址

Echo
(66189??) 23:34:16
这样说很简单了吧

橘子/tp
(613184??) 23:34:26
那是不是说，我定义的结构指针只要我下次用到这个结构体的时候它就会自动产生一个指针，不用我在单独另外定义了，是吧？

Echo
(66189??) 23:35:09
当然，你每次找个房间，里面就会有一个纸条，只不过刚开始纸条上没写字

Echo
(66189??) 23:35:14
或者是乱写的

橘子/tp
(613184??) 23:35:21
就像构造函数一样

橘子/tp
(613184??) 23:35:35
恩，

Echo
(66189??) 23:35:39
构造函数那是类

橘子/tp
(613184??) 23:35:54
嗯，我是说他们都可以自动分配

橘子/tp
(613184??) 23:35:57
赫赫

Echo
(66189??) 23:36:05
构造函数不是分配

橘子/tp
(613184??) 23:36:11
？？？？？？？

Echo
(66189??) 23:36:28
那是类，不是结构

Echo
(66189??) 23:36:31
有些不一样

橘子/tp
(613184??) 23:36:38
嗯

Echo
(66189??) 23:36:55
结构只是一个东西的描述，他只有数据

Echo
(66189??) 23:37:11
没有动作，简单理解就是没有生命

橘子/tp
(613184??) 23:37:22
嗯，

Echo
(66189??) 23:37:41
我好象另外有一篇

橘子/tp
(613184??) 23:37:49
噢，对对

橘子/tp
(613184??) 23:37:53
呵呵

橘子/tp
(613184??) 23:38:09
很贴切，　没有生命的，　嗯，对

Echo
(66189??) 23:38:12
http://xmxoxo.blog.hexun.com/6232338_d.html

橘子/tp
(613184??) 23:38:14
呵呵

Echo
(66189??) 23:38:38
类的意思就是，定义一下我要造的这个生命是怎么个样子的

Echo
(66189??) 23:38:57
比如我要造“鸟”

Echo
(66189??) 23:39:03
就定义一个“鸟”类

Echo
(66189??) 23:39:23
是怎么样的呢？有名字，有翅膀

Echo
(66189??) 23:39:42
有羽毛，有颜色

橘子/tp
(613184??) 23:40:07
嗯，

Echo
(66189??) 23:40:11
上面这些是固定的，他生出来就定了

Echo
(66189??) 23:40:14
叫属性

橘子/tp
(613184??) 23:40:21
嗯

Echo
(66189??) 23:40:24
另外还有动作

Echo
(66189??) 23:40:33
比如：看到东西会叫（动作）

Echo
(66189??) 23:40:43
看到小吃会吃（动作）

Echo
(66189??) 23:40:48
会叫应该是事件

橘子/tp
(613184??) 23:41:19
嗯，

Echo
(66189??) 23:41:22
会生出小小鸟（继承），生的小小鸟跟他有点像

Echo
(66189??) 23:41:30
但又不全像

Echo
(66189??) 23:42:01
那我描述完了，还是没有一只鸟，我只是这么想，鸟是怎么样的而已

Echo
(66189??) 23:42:05
还没造出来

橘子/tp
(613184??) 23:42:16
嗯

Echo
(66189??) 23:42:34
然后我就要造了

Echo
(66189??) 23:42:43
比如这个类叫bird

橘子/tp
(613184??) 23:42:49
嗯

Echo
(66189??) 23:42:59
造个真的就是：
bird mybird;

Echo
(66189??) 23:43:10
这里就有个问题了

Echo
(66189??) 23:43:24
一造出来的鸟是怎么样的？

Echo
(66189??) 23:43:54
当然我可以造完后来改变他的名字：
mybird.name="very";

Echo
(66189??) 23:44:06
但是在我没做任何动作之前

Echo
(66189??) 23:44:15
这只鸟是怎么样的呢？

Echo
(66189??) 23:44:33
这个工作就是类的构造函数完成的

橘子/tp
(613184??) 23:44:44
嗯

Echo
(66189??) 23:44:48
比如鸟的颜色

Echo
(66189??) 23:45:07
假设我会做三种颜色:blue, red,green

Echo
(66189??) 23:45:38
我可以在构造函数里

橘子/tp
(613184??) 23:45:46
嗯

Echo
(66189??) 23:45:49
color=blue;

橘子/tp
(613184??) 23:45:58
嗯

Echo
(66189??) 23:46:08
那凡是刚出生的都是蓝色

Echo
(66189??) 23:46:11
也可以复杂点

Echo
(66189??) 23:46:28
先搞个随机函数，随机选一个颜色

橘子/tp
(613184??) 23:46:37
嗯，对

Echo
(66189??) 23:46:41
那刚出生的就是随机的了

橘子/tp
(613184??) 23:46:44
有道理～～

Echo
(66189??) 23:47:27
构造函数就是在对类进行实例化时做的工作

Echo
(66189??) 23:47:32
我就是这么理解的

Echo
(66189??) 23:47:41
有出生就有死亡

Echo
(66189??) 23:47:58
构造函数是出生；那析构函数就是死亡

橘子/tp
(613184??) 23:48:06
嗯，所以有了析构函数

橘子/tp
(613184??) 23:48:07
嗯　

Echo
(66189??) 23:48:09
他死了的时候要干哪些

Echo
(66189??) 23:48:26
还有就是复制函数

Echo
(66189??) 23:48:37
复制一个他时做的工作

橘子/tp
(613184??) 23:48:44
嗯

Echo
(66189??) 23:48:57
继承和多态没有研究过，所以没有心得

橘子/tp
(613184??) 23:49:05
唉～～

Echo
(66189??) 23:49:11
以后有了再交流

橘子/tp
(613184??) 23:49:11
我们的老师要有你讲的一半好就好了

Echo
(66189??) 23:49:15
呵。

Echo
(66189??) 23:49:25
还有友元

Echo
(66189??) 23:49:37
保护，私有

Echo
(66189??) 23:49:39
公有

橘子/tp
(613184??) 23:49:41
其实你要去大学里当个教授一定会很出色的

Echo
(66189??) 23:49:53
以前也讲课来着

Echo
(66189??) 23:50:30
很好玩吧，这样的例子很多

橘子/tp
(613184??) 23:50:30
呵呵，我说的，呵呵，确实讲相当不错，深入浅出

橘子/tp
(613184??) 23:51:02
嗯，呵呵

Echo
(66189??) 23:51:33
保护，私有，这些理解成个性

Echo
(66189??) 23:51:43
每个小鸟有自己的个性

橘子/tp
(613184??) 23:51:53
嗯

Echo
(66189??) 23:52:08
公有就是普遍性了

Echo
(66189??) 23:52:21
都会飞，等等

橘子/tp
(613184??) 23:52:28
嗯　

Echo
(66189??) 23:52:49
保护函数好象也可以继承

橘子/tp
(613184??) 23:52:59
嗯

Echo
(66189??) 23:53:18
呵。为什么叫类，叫对象，这本身就是想模拟现实世界吧

Echo
(66189??) 23:53:36
所以为什么有病毒

Echo
(66189??) 23:53:42
病毒会传播

橘子/tp
(613184??) 23:53:57
嗯，呵呵

Echo
(66189??) 23:54:16
下一代会有上一代的影子

Echo
(66189??) 23:54:47
多态没看过，理解成同一个人，有多重性格？

Echo
(66189??) 23:55:11
见人说人话，见鬼说鬼话

Echo
(66189??) 23:55:25
就像重载

橘子/tp
(613184??) 23:55:30
呵呵，嗯，对

Echo
(66189??) 23:56:10
void 送礼（领导）
void 送礼（同事）

橘子/tp
(613184??) 23:56:30
等会儿我的把咱们的聊天记录好好整理一下，总结些东西

Echo
(66189??) 23:56:32
同事，一种送礼方法；
领导，另一个送礼方法

橘子/tp
(613184??) 23:56:32
呵呵

Echo
(66189??) 23:57:09
NND，领导送1000红包，同事送个小本本留个纪念

橘子/tp
(613184??) 23:57:50
呵呵

Echo
(66189??) 23:59:17
有些函数允许重载。这么个理解：
有些领导办事方式是可以变的，只要你功底够，你想怎么办就怎么办。。。

橘子/tp
(613184??) 23:59:43
呵呵，太有道理了呵呵，
Echo
(66189??) 23:59:57
又想到一个：指针的指针就是，拿到一张藏宝图，上面写了个地点，好不容易找到了跑进去一下，里面啥都没有，又是一张藏宝图

编程概念的理解