blocks|key|1518687|text|“四人帮”一书(Design+Patterns)有一个基于图形用户界面的文本编辑器作为它的主要示例来源，是一本值得拥有的书。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1518688|一般的“纯文本”编辑器可能使用ropes，SGI的STL有一个implementation。基本上，它们是字符缓冲区的链表。这样，插入/删除字符需要更改较小的缓冲区和一些指针，而不是将整个文档存储在单个缓冲区中，然后必须对所有内容进行移位。|1518689|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Design_Patterns|1|http://www.sgi.com/tech/stl/Rope.html^0|8|F|0|0|V|E|1|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]]|C|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@$A|U|B|V|1|W]]|C|$]]|$1|F|3|-4|5|6|7|X|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]|N|$5|I|J|K|C|$L|O]]]]

The "Gang of Four" book (<a href="http://en.wikipedia.org/wiki/Design_Patterns" rel="nofollow noreferrer">Design Patterns</a>) has a GUI-based text editor as it's main source of examples and is a worthwhile book to own.

The general "pure text" editor probably uses ropes, which SGI's STL has an <a href="http://www.sgi.com/tech/stl/Rope.html" rel="nofollow noreferrer">implementation</a> of. Basically, they are a linked list of character buffers. That way, inserting/deleting characters involves changing smaller buffers and a few pointers, instead of storing the entire document in a single buffer and having to shift everything.

blocks|key|1733726|text|查看vim，它是开源的。看看它是如何处理你想要的东西的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1733727|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Check out vim, it's open-source. Poke around in it to see how it handles what you want.

blocks|key|1518823|text|一种简单的方法是面向行的--将文件表示为char/wchar_t数组/向量的数组/向量，每行一个。插入和删除的工作方式与您预期的一样，尽管行尾是一个特例。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1518824|我将从这个开始，在完成所有工作之后，可能会用更有效地支持长行上的插入/删除操作的行数据结构来替换。|1518825|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

A simple approach would be line oriented -- represent the file as an array/vector of char/wchar_t arrays/vectors, one per line. Insertions and deletions work the way you'd expect, although end of line is a special case.

I'd start with that and possibly replace the line data structure with something more efficiently supporting inserts/deletes on long lines after you have everything else working.

blocks|key|1733892|text|这真的取决于你的设计。几年前，我用咒语写了一个小编辑器。我使用了双向链表，其中每个节点都是一个字符(这是一个相当浪费的设计..但它使格式化和屏幕刷新例程变得非常容易)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1733893|我的朋友使用的其他数据结构是(这是一个家庭作业项目)：1)数组的链表，每个数组代表一条线。2)+2D链表(只是虚构的名称)。它是一个字符的链表，但每个字符都链接到上下的字符。3)链表数组|1733894|但是，我建议您查看一些简单编辑器的源代码，比如pico，看看他们使用的是什么ds。|1733895|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

This really depends on your design. Couple of years back, I wrote a small editor using curses. I used doubly linked list where each node was a character (quite a wasteful design.. but it makes formatting and screen refresh routines really easy).

Other data structures used by my friends were (this was a homework project):
1)linked list of arrays with each array representing a line.
2)a 2D linked list (just made up that name).. it was a linked list of characters but each character was linked to the character above and below.
3)Array of linked list

However, I would suggest you to go through the source code of some simple editors like pico to see what ds they are using.

blocks|key|1519008|text|您的主要数据结构是一个包含文本的结构。您可能需要一个行数组，而不是使用长缓冲区来包含文本，因为在行的中间插入字符比在大缓冲区的中间插入字符更快。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1519009|你需要决定你的文本编辑器是否应该支持嵌入式格式。例如，如果您需要使用字体、粗体、下划线等，那么您的数据结构将需要包括在文本中嵌入格式化代码的方法。在8位字符的好日子里，我们可以使用整数的高8位来存储任何格式化标志，而低8位来存储字符本身。|1519010|实际的代码将取决于您使用的语言。在C#或C%2B%2B中，您可能会对行使用字符串数组。在C语言中，您将拥有一个基于堆的字符数组。|1519011|尽可能地将显示代码与文本处理代码分开。代码的中心将是一个紧密的循环，类似于：|1519012|while+(editing)+{
++++GetCharacter();
++++ProcessCharacter();
++++UpdateDisplay();
}|code-block|syntax|javascript|1519013|更复杂的编辑器将使用单独的线程进行字符获取/处理和显示更新。|1519014|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|S|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|T|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|U|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Your primary data structure is one to contain the text. Rather than using a long buffer to contain the text, you'll probably want an array of lines because it's faster to insert a character into the middle of a line then it is to insert a character into the middle of a large buffer.

You'll need to decide if your text editor should support embedded formatting. If, for example, you need to use fonts, bolding, underlining, etc, then your data structure will need to include ways of embedding formatting codes within your text. In the good old days of 8-bit characters we could use the upper 8-bits of an integer to store any formatting flags and the lower 8-bits to store the character itself.

The actual code will depend on the language you're using. In C# or C++ you'll probably use an array of strings for the lines. In C you'll have an array of heap-based character arrays.

Separate out the display code from the text handling code as much as possible. The center of your code will be a tight loop something like:

<pre><code>while (editing) {
 GetCharacter();
 ProcessCharacter();
 UpdateDisplay();
}
</code></pre>

A more sophisticated editor will use separate threads for the character getting/processing and the display updating.

blocks|key|1519154|text|我曾经在一家公司工作，该公司的主要产品是文本编辑器。虽然我主要研究它的脚本语言，但编辑器本身的内部设计自然是一个主要的讨论主题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1519155|它似乎被分成了两个大体思路。一种方法是将每一行单独存储，然后将它们链接到一个链表或其他您满意的整体数据结构中。这样做的好处是，任何面向行的编辑操作(如删除整行，或在文件中移动行块)都不是很容易实现的，因此速度非常快。缺点是加载和保存文件需要更多的工作，因为您必须遍历整个文件并构建这些数据结构。|1519156|当时的另一种思路是，当文本块未被更改时，尝试将文本块保留在一起，而不考虑换行，仅在编辑需要时才将其拆分。这样做的好处是，一个未经编辑的文件块可以很容易地分解成一个文件。因此，加载文件、更改一行和保存文件的简单编辑都非常快。缺点是，面向行或列块的操作执行起来非常耗时，因为您必须解析这些文本块并移动大量数据。|1519157|我们一直坚持以行为导向的设计，不管它有什么价值，我们的产品被认为是当时最快的编辑器之一。|1519158|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

I used to work for a company whose main product was a text editor. While I mainly worked on the scripting language for it, the internal design of the editor itself was naturally a major topic of discussion.

It seemed like it broke down into two general trains of thought. One was that you stored each line by itself, and then link them together in a linked list or other overall data structure that you were happy with. The advantage was that any line-oriented editing actions (such as deleting an entire line, or moving a line block within a file) were beyond trivial to implement and therefore lightning fast. The down side was that loading and saving the file took a bit more work, because you'd have to traverse the entire file and build these data structures.

The other train of thought at that time was to try to keep hunks of text together regardless of line breaks when they hadn't been changed, breaking them up only as required by editing. The advantage was that an unedited hunk of the file could be blasted out to a file very easily. So simple edits where you load a file, change one line, and save the file, were super fast. The disadvantage was that line-oriented or column-block operations were very time consuming to execute because you would have to parse through these hunks of text and move alot of data around.

We always stuck with the line-oriented design, for whatever that is worth, and our product was considered one of the fastest editors at the time.

blocks|key|1734170|text|你看过Scintilla的源代码了吗？|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1734171|entityMap|0|LINK|mutability|MUTABLE|url|http://www.scintilla.org/^0|3|9|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Have you checked out <a href="http://www.scintilla.org/" rel="nofollow noreferrer">Scintilla</a>'s source code?

blocks|key|1734223|text|这是2008年。不要编写文本编辑器；您正在重新发明fire。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1734224|还在这里吗？我不确定这是否适用，也不确定您计划支持哪些平台，但是Neatpad+series+of+tutorials是一个开始考虑编写文本编辑器的好地方。他们专注于将Win32作为基本平台，但所学到的许多经验教训将适用于任何地方。|offset|length|1734225|entityMap|0|LINK|mutability|MUTABLE|url|http://www.catch22.net/tuts/neatpad/^0|0|W|R|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

This is 2008. Don't write a text editor; you're reinventing fire.

Still here? I'm not sure if this applies or what platforms you plan to support, but the <a href="http://www.catch22.net/tuts/neatpad/" rel="noreferrer">Neatpad series of tutorials</a> is a great place to start thinking about writing a text editor. They focus on Win32 as the basic platform, but many of the lessons learned will apply anywhere.

blocks|key|1734303|text|您几乎可以使用任何数据结构来编写文本编辑器。两百万个字符是相当庞大的小说类型，您可以在不到十分之一秒的时间内轻松地向上/向下移动它们(对于简单数组中的插入/删除)。不要听信任何人告诉你不要构建一个，你会得到在所有小细节上完全正确的东西。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1734304|我写了我的，在我做了太多的网页浏览后，我已经习惯了上下翻页就像在滚动条拇指上方/下方点击一样。当你在一个普通的编辑器中输入一个字符时，跳回到你开始滚动条导航之前，对我来说太烦人了，所以我写了我自己的。|1734305|如果我打算重写(在当前版本中，我只对每个文本缓冲区使用delphi+ansistring，并嵌入换行符)，我会为每个字符使用整数或int64s，并在高位编码块的开始/停止、光标位置和行标记，这样在插入或删除东西时就不必调整指针。|1734306|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

You can use almost any data structure to write a text editor. Two million characters is fairly thick novel's worth of typing and you can easily move them up/down (for an insert/delete in a simple array) in less than one-tenth of a second. Don't listen to anyone who tells you not build one, you'll get something which works exactly right in all the small details.
I wrote mine, after I'd done too much web browsing and I'd got used to page up/down being the same as clicking above/below the scrollbar thumb. The jump back to before you started scrollbar navigating when you typed a character in a normal editor, just got too annoying for me, so I wrote my own.
If I was going to do a rewrite (I just used delphi ansistrings for each text buffer in the current version, with newline characters embedded), I'd use integers or int64s for each character and encode block start/stop, cursor position and line markers in the high bits, that way you don't have to adjust pointers when you insert or delete things.

Ok, this is a bit of a cheeky question. I want to build a simple text editor (using my own text mode screen handling). I just want a good example of data structures that can be used to represent the text buffer, and some simple examples of char/text insertion/deletion. I can handle all the rest of the code myself (file i/o, console i/o etc). A link to a nice simple editor source would be great (C or C++).

Editing a text buffer

数据结构

好吧，这是一个有点厚颜无耻的问题。我想构建一个简单的文本编辑器(使用我自己的文本模式屏幕处理)。我只想要一个可以用来表示文本缓冲区的很好的数据结构示例，以及一些字符/文本插入/删除的简单示例。我可以自己处理所有剩余的代码(文件i/o、控制台i/o等)。一个很好的简单编辑器源代码的链接(C或C++)会很棒。

问编辑文本缓冲区
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问编辑文本缓冲区EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问编辑文本缓冲区
EN