求对txt文件进行删除行操作代码

goodlardy

求对txt文件进行删除行操作代码 [复制链接]

本人想把一个几万行的txt文件内的，某些行删除，手工太慢。想把带有某些字符（比如一个单词）的行全部删除。操作以后保存退出。

请问用到什么方法？

jianglongbiao

循环读取文件内容，每次读1行或10行，行数随便，然后字符串查找，找到了就删除，把剩下的追加到临时文件里，最后替换原来的文件。

longtoon

用脚本语言处理吧，两三行代码搞定。
比如：perl

liulirong1985

fgets()一行一行读文件，一行一行处理，再把处理结构写入新文件。
完成后，关闭新，老文件。删除老文件，最后把新文件改名为老文件。

yaoyao11

几万行？
文件多大？
可以考虑用内存映射文件操作

麦兜仔仔

把分给我吧， 正好写过一个过滤的应用

1. 
   
2. 
   
3. #include "stdafx.h"
   
4. #include
   
5. #include
   
6. #pragma warning(disable:4244 4267)
   
7. 
   
8. ////////////////////////////////////////////////////////////////////////////////////////////////////////
   
9. template struct Str_LookupA;                                                // ANSI字符集字符串查找模板
   
10. template struct Str_LookupW;                                                // UNICODE 字符集字串查找模板
    
11. template struct Str_Filter_Word;        // 字符串过滤模板框架 -- 只过滤输入单词
    
12. template struct Str_Filter_Line;        // 字符串过滤模板框架 -- 过滤包含输入单词段落
    
13. ////////////////////////////////////////////////////////////////////////////////////////////////////////
    
14. //
    
15. // 模板参数 t_fMatch, 指明查找字串是否区分大小写。
    
16. //                        t_fMatch = true，查找函数将不区分大小写
    
17. //                        t_fMatch = false, 默认方式，按照输入查找字串进行匹配
    
18. //
    
19. template struct Str_LookupA
    
20. {
    
21.         enum { TYPE_SIZE = sizeof(CHAR)};
    
22.         typedef CHAR*                _Type;
    
23.         typedef const CHAR* _constType;
    
24.         typedef _Type                _ReturnType;
    
25. 
    
26.         _ReturnType operator()(_Type pSrc,_constType pSearch)
    
27.         {
    
28.                 return t_fMatch ? StrStrIA(pSrc,pSearch) : StrStrA(pSrc,pSearch);
    
29.         }
    
30.         _ReturnType LineStart(_Type pSrc,_Type pLast)
    
31.         {
    
32.                 _Type pStart = StrRStrIA(pSrc,pLast,"\r\n");
    
33.                 return pStart ? pStart + 2 : pSrc;
    
34.         }
    
35.         _ReturnType LineEnd(_Type pSrc)
    
36.         {
    
37.                 _Type pEnd = StrStrA(pSrc,"\r\n");
    
38.                 return pEnd ? pEnd + 2 : NULL;
    
39.         }
    
40.         DWORD Length(_constType pStr)
    
41.         {
    
42.                 return lstrlenA(pStr);
    
43.         }
    
44. };
    
45. 
    
46. template struct Str_LookupW
    
47. {
    
48.         enum { TYPE_SIZE = sizeof(WCHAR)};
    
49.         typedef WCHAR*                _Type;
    
50.         typedef _Type                _ReturnType;
    
51.         typedef const WCHAR* _constType;
    
52. 
    
53.         _ReturnType operator()(_Type pSrc, _constType pSearch)
    
54.         {
    
55.                 return t_fMatch ? StrStrIW(pSrc,pSearch) : StrStrW(pSrc,pSearch);
    
56.         }
    
57.         _ReturnType LineStart(_Type pSrc,_Type pLast)
    
58.         {
    
59.                 _Type pStart = StrRStrIW(pSrc,pLast,L"\r\n");
    
60.                 return pStart ? pStart + 2 : pSrc;
    
61.         }
    
62.         _ReturnType LineEnd(_Type pSrc)
    
63.         {
    
64.                 _Type pEnd = StrStrW(pSrc,L"\r\n");
    
65.                 return pEnd ? pEnd + 2 : NULL;
    
66.         }
    
67.         DWORD Length(_constType pStr)
    
68.         {
    
69.                 return lstrlenW(pStr);
    
70.         }
    
71. 
    
72. };
    
73. 
    
74. template >
    
75. struct Str_Filter_Word
    
76. {
    
77.         typedef typename _RT::_Type                        _Type;
    
78.         typedef typename _RT::_constType        _constType;
    
79.         typedef typename _RT::_ReturnType        _ReturnType;
    
80. 
    
81.         _ReturnType operator()(_Type pBuffer, DWORD cbSize, _constType *pWord, DWORD cbCount, DWORD* pcbRemoved = NULL)
    
82.         {
    
83.                 ATLASSERT(pBuffer && pWord && cbSize && cbCount);
    
84.                 _RT Str_Lookup;
    
85.                 DWORD dwRemoved = 0;
    
86.                 DWORD cbStart = 0;
    
87.                 DWORD cbEnd = cbSize;
    
88.                 for (DWORD i = 0; i < cbCount; i++)
    
89.                 {
    
90.                         _Type pStart = pBuffer;
    
91.                         _Type pEnd = pBuffer + cbEnd;
    
92.                         _constType pSearch = pWord[i];
    
93.                         DWORD cbLength = Str_Lookup.Length(pSearch);
    
94.                         if (!pSearch)
    
95.                                 break;
    
96.                         for (;;)
    
97.                         {
    
98.                                 _Type p = Str_Lookup(pStart,pSearch);
    
99.                                 if (!p)        break;
    
100.                                 dwRemoved++;
     
101.                                 _Type pNext = p + cbLength;
     
102. 
     
103.                                 if (pNext && pNext <=pEnd)
     
104.                                 {
     
105.                                         cbStart = p - pBuffer;
     
106.                                         memmove(p,pNext,_RT::TYPE_SIZE * (cbEnd - cbStart));
     
107.                                         pStart = p;
     
108.                                         cbEnd -= cbLength;
     
109.                                   }
     
110.                                 else
     
111.                                 {
     
112.                                         memset(pStart,0, _RT::TYPE_SIZE * (cbEnd - cbStart));
     
113.                                         break;
     
114.                                 }
     
115.                         }
     
116.                 }
     
117.                 if (pcbRemoved) *pcbRemoved = dwRemoved;
     
118.                 return pBuffer;
     
119.         }
     
120. 
     
121.         _ReturnType operator()(_Type pBuffer, DWORD cbSize, _constType pWord, DWORD* pcbRemoved = NULL)
     
122.         {
     
123.                 _constType pWords[] = {pWord,0};
     
124.                 return operator()(pBuffer,cbSize,pWords,1,pcbRemoved);
     
125.         }
     
126. };
     
127. 
     
128. template >
     
129. struct Str_Filter_Line
     
130. {
     
131.         typedef typename _RT::_Type                        _Type;
     
132.         typedef typename _RT::_constType        _constType;
     
133.         typedef typename _RT::_ReturnType        _ReturnType;
     
134. 
     
135.         _ReturnType operator()(_Type pBuffer, DWORD cbSize, _constType *pWord, DWORD cbCount, DWORD* pcbRemoved = NULL)
     
136.         {
     
137.                 ATLASSERT(pBuffer && pWord && cbSize && cbCount);
     
138.                 _RT Str_Lookup;
     
139.                 DWORD dwRemoved = 0;
     
140.                 DWORD cbStart = 0;
     
141.                 DWORD cbEnd = cbSize;
     
142.                 for (DWORD i = 0; i < cbCount; i++)       
     
143.                 {
     
144.                         _Type pStart = pBuffer;
     
145.                         _Type pEnd = pBuffer + cbEnd;
     
146.                         _constType pSearch = pWord[i];
     
147.                         if (!pSearch) break;
     
148. 
     
149.                         for (;;)
     
150.                         {
     
151.                                 _Type p = Str_Lookup(pStart,pSearch);
     
152.                                 if (!p)        break;
     
153. 
     
154.                                 dwRemoved++;
     
155.                                 pStart = Str_Lookup.LineStart(pBuffer,p);
     
156.                                 _Type pLineEnd = Str_Lookup.LineEnd(p);
     
157.                                 if (pLineEnd)
     
158.                                 {
     
159.                                         cbStart = pStart - pBuffer;
     
160.                                         memmove(pStart,pLineEnd,_RT::TYPE_SIZE * (cbEnd - cbStart));
     
161.                                         cbEnd -= (pLineEnd - pStart);
     
162.                                 }
     
163.                                 else
     
164.                                 {
     
165.                                         memset(pStart,0, _RT::TYPE_SIZE * (cbEnd - cbStart));
     
166.                                         break;
     
167.                                 }
     
168.                         }
     
169.                 }
     
170.                 if (pcbRemoved) *pcbRemoved = dwRemoved;
     
171.                 return pBuffer;
     
172.         }
     
173. 
     
174.         _ReturnType operator()(_Type pBuffer, DWORD cbSize, _constType pWord, DWORD* pcbRemoved = NULL)
     
175.         {
     
176.                 _constType pWords[] = {pWord,0};
     
177.                 return operator()(pBuffer,cbSize,pWords,1,pcbRemoved);
     
178.         }
     
179. 
     
180. };
     
181. 
     
182. HRESULT test_file_filter(LPCTSTR lpszFile, LPCSTR *pWords, DWORD cbWords, bool fLine = false)
     
183. {
     
184.         ATL::CAtlFileMapping map;
     
185.         ATL::CAtlFile file;
     
186.         HRESULT hr;
     
187. 
     
188.         ULONGLONG uSize = 0;
     
189.         if (FAILED(hr = file.Create(lpszFile,GENERIC_READ | GENERIC_WRITE,0,OPEN_EXISTING)))
     
190.                 return hr;
     
191.         if (FAILED(hr = file.GetSize(uSize)))
     
192.                 return hr;
     
193.         size_t nSize = (size_t)uSize;
     
194.         if (FAILED(hr = map.MapFile(file.m_h,nSize,0,PAGE_READWRITE,FILE_MAP_READ | FILE_MAP_WRITE)))
     
195.                 return hr;
     
196.        
     
197.         LPSTR pData = (LPSTR)map.GetData();
     
198.         DWORD cbRemoved = 0;
     
199. 
     
200.         if (fLine)
     
201.         {
     
202.                 // 区分大小写， 过滤包含指定单词的段落
     
203.                 Str_Filter_Line<> filter;
     
204.                 filter(pData,nSize,pWords,cbWords,&cbRemoved);
     
205.         }
     
206.         else
     
207.         {
     
208.                 // 以不区分大小写的模式，过滤指定单词
     
209.                 Str_Filter_Word filter;
     
210.                 filter(pData,nSize,pWords,cbWords,&cbRemoved);
     
211.         }
     
212.         printf(pData);
     
213.         return S_OK;
     
214. }
     
215. 
     
216. int _tmain(int argc, _TCHAR* argv[])
     
217. {
     
218. 
     
219.         // 过滤指定文件中多个单词
     
220.         LPCSTR pWords[] = {"Sec","Time","北国","sample","for",0};
     
221.         HRESULT hr = test_file_filter(_T("c:\\100.txt"),pWords,5);
     
222. 
     
223.         if (FAILED(hr))
     
224.                 printf("failed! hr = 0x08X\n",hr);
     
225. 
     
226.         // 过滤文件中包含指定单词的段落
     
227.         hr = test_file_filter(_T("c:\\300.txt"),pWords,5,true);
     
228.         if (FAILED(hr))
     
229.                 printf("failed! hr = 0x08X\n",hr);
     
230. 
     
231.         _getch();
     
232. 
     
233.         return 0;
     
234. }
     
235. 
     
236. 
     

复制代码

mrbook

5楼的同学，我把你的代码用VC6编译，提示文件无法编译。是不是要建一个工程，要建什么类型的？

chenqd1980

建议用perl等脚本语言，几条语句就搞定了

szjfr

一句搞定

sed -e '/hello/p' test.c > test.c

hello替换为你要查找的单词
test.c为目标文件。

xtydk

测试工程师用VS2005写的。里边测试代码中用了 atlfile.h 这个头文件，这个头文件在VC7以上才有，所以你在VC6中无法编译。 过滤部分在VC6下应该能编译通过。

davidcool

学习拉

yuan1975

引用 9 楼 bdzwj 的回复:
测试工程师用VS2005写的。里边测试代码中用了 atlfile.h 这个头文件，这个头文件在VC7以上才有，所以你在VC6中无法编译。 过滤部分在VC6下应该能编译通过。

那你能否编译好生成一个exe文件发给我一个，谢谢

我的目的是，把一个几万行的文本文件找出几百行需要的行，其余的删除。只要某行包含&com就留下，或者只要&txt 。。就删除

toohai

sed -e '/&txt/d' filename

cat filename | grep \&com

gaoyuanzys

如果你使用Windows平台，建议装一个ActivePerl，处理类似的问题，极为方便。

ssb4587

学习了

xiayue_gogo

问题还没有解决

szm

引用 12 楼 hzcpig 的回复:
sed -e '/&txt/d' filename

cat filename | grep \&com

这个是什么语句？dos?

felngs

引用 8 楼 hzcpig 的回复:
一句搞定

sed -e '/hello/p' test.c > test.c

hello替换为你要查找的单词
test.c为目标文件。

高手啊

hxsljzj

楼上的能否解释一下该语句在什么环境下使用？

20032532

额~~~抱歉，没注意到这个不是linux环境，那句是linux shell下sed工具。sed是一个专门进行行处理的工具。

不过windows下同样有 sed for windows工具。