C++ 读写 EXCEL

admin

1. #include "stdafx.h"
   
2. #include "ExcelOperate.h"
   
3. 
   
4. ExcelOperate::ExcelOperate()
   
5. {
   
6. }
   
7. 
   
8. ExcelOperate::~ExcelOperate()
   
9. {
   
10. }
    
11. 
    
12. BOOL ExcelOperate::CreateApp()
    
13. {
    
14.         COleException pe;
    
15.         //创建Excel 服务器(启动Excel)
    
16.         if (!m_ExcelApp.CreateDispatch(_T("Excel.Application"), &pe))
    
17.         {
    
18.                 AfxMessageBox(_T("启动Excel服务失败，请确保安装了excel 2000或以上版本!"), MB_OK | MB_ICONWARNING);
    
19.                 pe.ReportError();
    
20.                 throw& pe;
    
21.                 return FALSE;
    
22.         }
    
23.         m_ExcelApp.put_DisplayAlerts(FALSE);//屏蔽警告
    
24.         //CString strExcelVersion = m_ExcelApp.get_Version();
    
25.         return true;
    
26. }
    
27. 
    
28. BOOL ExcelOperate::CreateWorkbooks()
    
29. {
    
30.         if (FALSE == CreateApp())
    
31.         {
    
32.                 return FALSE;
    
33.         }
    
34.         m_ecBooks.AttachDispatch(m_ExcelApp.get_Workbooks());
    
35.         if (!m_ecBooks.m_lpDispatch)
    
36.         {
    
37.                 AfxMessageBox(_T("WorkBooks创建失败!"), MB_OK | MB_ICONWARNING);
    
38.                 return FALSE;
    
39.         }
    
40.         return TRUE;
    
41. }
    
42. 
    
43. BOOL ExcelOperate::CreateWorkbook()
    
44. {
    
45.         if (!m_ecBooks.m_lpDispatch)
    
46.         {
    
47.                 AfxMessageBox(_T("WorkBooks为空!"), MB_OK | MB_ICONWARNING);
    
48.                 return FALSE;
    
49.         }
    
50. 
    
51.         COleVariant vOptional((long)DISP_E_PARAMNOTFOUND, VT_ERROR);
    
52. 
    
53.         m_ecBook.AttachDispatch(m_ecBooks.Add(vtMissing));
    
54.         if (!m_ecBook.m_lpDispatch)
    
55.         {
    
56.                 AfxMessageBox(_T("WorkBook为空!"), MB_OK | MB_ICONWARNING);
    
57.                 return FALSE;
    
58.         }
    
59.         /*
    
60.                 //得到document变量
    
61.                 m_wdDoc = m_wdApp.GetActiveDocument();
    
62.                 if (!m_wdDoc.m_lpDispatch)
    
63.                 {
    
64.                         AfxMessageBox(_T("Document获取失败!"), MB_OK|MB_ICONWARNING);
    
65.                         return FALSE;
    
66.                 }
    
67.                 //得到selection变量
    
68.                 m_wdSel = m_wdApp.GetSelection();
    
69.                 if (!m_wdSel.m_lpDispatch)
    
70.                 {
    
71.                         AfxMessageBox(_T("Select获取失败!"), MB_OK|MB_ICONWARNING);
    
72.                         return FALSE;
    
73.                 }
    
74.                 //得到Range变量
    
75.                 m_wdRange = m_wdDoc.Range(vOptional,vOptional);
    
76.                 if(!m_wdRange.m_lpDispatch)
    
77.                 {
    
78.                         AfxMessageBox(_T("Range获取失败!"), MB_OK|MB_ICONWARNING);
    
79.                         return FALSE;
    
80.                 }
    
81.         */
    
82.         return TRUE;
    
83. }
    
84. 
    
85. BOOL ExcelOperate::CreateWorksheets()
    
86. {
    
87.         if (!m_ecBook.m_lpDispatch)
    
88.         {
    
89.                 AfxMessageBox(_T("WorkBook为空!"), MB_OK | MB_ICONWARNING);
    
90.                 return FALSE;
    
91.         }
    
92.         m_ecSheets = m_ecBook.get_Sheets();
    
93.         if (!m_ecSheets.m_lpDispatch)
    
94.         {
    
95.                 AfxMessageBox(_T("WorkSheets为空!"), MB_OK | MB_ICONWARNING);
    
96.                 return FALSE;
    
97.         }
    
98.         return TRUE;
    
99. }
    
100. 
     
101. BOOL ExcelOperate::CreateWorksheet(short index)
     
102. {
     
103.         if (!m_ecSheets.m_lpDispatch)
     
104.         {
     
105.                 AfxMessageBox(_T("WorkSheets为空!"), MB_OK | MB_ICONWARNING);
     
106.                 return FALSE;
     
107.         }
     
108.         m_ecSheet = m_ecSheets.get_Item(COleVariant(index));
     
109.         if (!m_ecSheet.m_lpDispatch)
     
110.         {
     
111.                 AfxMessageBox(_T("WorkSheet为空!"), MB_OK | MB_ICONWARNING);
     
112.                 return FALSE;
     
113.         }
     
114.         //auto name= m_ecSheet.get_Name();
     
115.         return TRUE;
     
116. 
     
117.         /*打开一个Sheet，如不存在，就新增一个Sheet*/
     
118.         //CString strSheetName = _T("NewSheet");
     
119.         //try
     
120.         //{
     
121.         //        /*打开一个已有的Sheet*/
     
122.         //        lpDisp = m_ecSheets.get_Item(_variant_t(strSheetName));
     
123.         //        m_ecSheet.AttachDispatch(lpDisp);
     
124.         //}
     
125.         //catch (...)
     
126.         //{
     
127.         //        /*创建一个新的Sheet*/
     
128.         //        lpDisp = m_ecSheets.Add(vtMissing, vtMissing, _variant_t((long)1), vtMissing);
     
129.         //        m_ecSheet.AttachDispatch(lpDisp);
     
130.         //        m_ecSheet.put_Name(strSheetName);
     
131.         //}
     
132. }
     
133. 
     
134. BOOL ExcelOperate::CreateSheet(short index)
     
135. {
     
136.         if (CreateWorksheets() == FALSE)
     
137.         {
     
138.                 return FALSE;
     
139.         }
     
140.         if (CreateWorksheet(index) == FALSE)
     
141.         {
     
142.                 return FALSE;
     
143.         }
     
144.         return TRUE;
     
145. }
     
146. 
     
147. BOOL ExcelOperate::Create(short index)
     
148. {
     
149.         if (CreateWorkbooks() == FALSE)
     
150.         {
     
151.                 return FALSE;
     
152.         }
     
153.         if (CreateWorkbook() == FALSE)
     
154.         {
     
155.                 return FALSE;
     
156.         }
     
157.         if (CreateSheet(index) == FALSE)
     
158.         {
     
159.                 return FALSE;
     
160.         }
     
161.         return TRUE;
     
162. }
     
163. 
     
164. int ExcelOperate::GetSheetCount()
     
165. {
     
166.         return m_ecSheets.get_Count();
     
167. }
     
168. 
     
169. BOOL ExcelOperate::LoadSheet(const CString& sheet)
     
170. {
     
171. 
     
172.         if (!m_ecSheets.m_lpDispatch)
     
173.         {
     
174.                 AfxMessageBox(_T("WorkSheets为空!"), MB_OK | MB_ICONWARNING);
     
175.                 return FALSE;
     
176.         }
     
177.         m_ecSheet = m_ecSheets.get_Item(COleVariant(sheet));
     
178.         if (!m_ecSheet.m_lpDispatch)
     
179.         {
     
180.                 AfxMessageBox(_T("WorkSheet为空!"), MB_OK | MB_ICONWARNING);
     
181.                 return FALSE;
     
182.         }
     
183.         //auto name= m_ecSheet.get_Name();
     
184.         return TRUE;
     
185. }
     
186. 
     
187. void ExcelOperate::ShowApp()
     
188. {
     
189.         m_ExcelApp.put_Visible(true);
     
190.         m_ExcelApp.put_DisplayFullScreen(true);//设置全屏显示
     
191.         //m_ExcelApp.put_UserControl(FALSE);
     
192. }
     
193. 
     
194. void ExcelOperate::HideApp()
     
195. {
     
196.         m_ExcelApp.put_Visible(FALSE);
     
197.         //m_ExcelApp.put_CutCopyMode(false);
     
198.         //m_ExcelApp.put_UserControl(FALSE);
     
199. }
     
200. 
     
201. BOOL ExcelOperate::OpenWorkbook(const CString& fileName, short index)
     
202. {
     
203.         if (!m_ecBooks.m_lpDispatch)
     
204.         {
     
205.                 AfxMessageBox(_T("WorkSheets为空!"), MB_OK | MB_ICONWARNING);
     
206.                 return FALSE;
     
207.         }
     
208.         //COleVariant vFileName(_T(fileName));  
     
209.         COleVariant VOptional((long)DISP_E_PARAMNOTFOUND, VT_ERROR);
     
210.         m_ecBook = m_ecBooks.Open(fileName, VOptional, VOptional, VOptional, VOptional, VOptional, VOptional, VOptional, VOptional, VOptional, VOptional, VOptional, VOptional, VOptional, VOptional);
     
211.         if (!m_ecBook.m_lpDispatch)
     
212.         {
     
213.                 AfxMessageBox(_T("WorkSheet获取失败!"), MB_OK | MB_ICONWARNING);
     
214.                 return FALSE;
     
215.         }
     
216.         if (CreateSheet(index) == FALSE)
     
217.         {
     
218.                 return FALSE;
     
219.         }
     
220.         return TRUE;
     
221. }
     
222. 
     
223. BOOL ExcelOperate::Open(const CString& fileName)
     
224. {
     
225.         if (CreateWorkbooks() == FALSE)
     
226.         {
     
227.                 return FALSE;
     
228.         }
     
229.         return OpenWorkbook(fileName);
     
230. }
     
231. 
     
232. BOOL ExcelOperate::SetActiveWorkbook(short& i)
     
233. {
     
234.         return 0;
     
235. }
     
236. 
     
237. BOOL ExcelOperate::SaveWorkbook()
     
238. {
     
239.         if (!m_ecBook.m_lpDispatch)
     
240.         {
     
241.                 //AfxMessageBox(_T("Book获取失败!"), MB_OK | MB_ICONWARNING);
     
242.                 return FALSE;
     
243.         }
     
244.         m_ecBook.Save();
     
245.         return TRUE;
     
246. }
     
247. 
     
248. BOOL ExcelOperate::SaveWorkbookAs(const CString& fileName)
     
249. {
     
250.         if (!m_ecBook.m_lpDispatch)
     
251.         {
     
252.                 AfxMessageBox(_T("Book获取失败!"), MB_OK | MB_ICONWARNING);
     
253.                 return FALSE;
     
254.         }
     
255.         COleVariant vTrue((short)TRUE),
     
256.                 vFalse((short)FALSE),
     
257.                 vOptional((long)DISP_E_PARAMNOTFOUND, VT_ERROR);
     
258.         COleVariant vFileName(fileName);
     
259.         long XlFileFormat = 51;
     
260. 
     
261.         CString strSuffix = fileName.Mid(fileName.ReverseFind(_T('.')));
     
262. 
     
263.         if (0 == strSuffix.CompareNoCase(_T(".xls")))
     
264.         {
     
265.                 XlFileFormat = 56;
     
266.         }
     
267.         m_ecBook.SaveAs(
     
268.                 vFileName,    //VARIANT* FileName  
     
269.                 _variant_t(XlFileFormat),    //VARIANT* FileFormat  
     
270.                 vtMissing,    //VARIANT* LockComments  
     
271.                 vtMissing,    //VARIANT* Password  
     
272.                 vtMissing,    //VARIANT* AddToRecentFiles  
     
273.                 vtMissing,    //VARIANT* WritePassword  
     
274.                 0,    //VARIANT* ReadOnlyRecommended  
     
275.                 vtMissing,    //VARIANT* EmbedTrueTypeFonts  
     
276.                 vtMissing,    //VARIANT* SaveNativePictureFormat  
     
277.                 vtMissing,    //VARIANT* SaveFormsData  
     
278.                 vtMissing,    //VARIANT* SaveAsAOCELetter  
     
279.                 vtMissing    //VARIANT* ReadOnlyRecommended  
     
280.         );
     
281.         return    TRUE;
     
282. }
     
283. 
     
284. BOOL ExcelOperate::CloseWorkbook()
     
285. {
     
286.         COleVariant vTrue((short)TRUE),
     
287.                 vFalse((short)FALSE),
     
288.                 vOptional((long)DISP_E_PARAMNOTFOUND, VT_ERROR);
     
289. 
     
290.         m_ecBook.Close(vFalse,    // SaveChanges.  
     
291.                 vTrue,            // OriginalFormat.  
     
292.                 vFalse            // RouteDocument.  
     
293.         );
     
294.         m_ecBook = m_ExcelApp.get_ActiveWorkbook();
     
295.         if (!m_ecBook.m_lpDispatch)
     
296.         {
     
297.                 //AfxMessageBox(_T("Book获取失败!"), MB_OK | MB_ICONWARNING);
     
298.                 return FALSE;
     
299.         }
     
300.         if (CreateSheet(1) == FALSE)
     
301.         {
     
302.                 return FALSE;
     
303.         }
     
304.         return TRUE;
     
305. }
     
306. 
     
307. void ExcelOperate::CloseApp()
     
308. {
     
309.         SaveWorkbook();
     
310.         COleVariant vTrue((short)TRUE),
     
311.                 vFalse((short)FALSE),
     
312.                 vOptional((long)DISP_E_PARAMNOTFOUND, VT_ERROR);
     
313.         //m_ecDoc.Save();  
     
314. 
     
315.         if (m_ecRange.m_lpDispatch)
     
316.                 m_ecRange.ReleaseDispatch();
     
317.         if (m_ecSheet.m_lpDispatch)
     
318.                 m_ecSheet.ReleaseDispatch();
     
319.         if (m_ecSheets.m_lpDispatch)
     
320.                 m_ecSheets.ReleaseDispatch();
     
321.         if (m_ecBook.m_lpDispatch)
     
322.                 m_ecBook.ReleaseDispatch();
     
323.         if (m_ecBooks.m_lpDispatch)
     
324.                 m_ecBooks.ReleaseDispatch();
     
325.         m_ExcelApp.Quit();
     
326.         if (m_ExcelApp.m_lpDispatch)
     
327.                 m_ExcelApp.ReleaseDispatch();
     
328. }
     
329. 
     
330. void ExcelOperate::MergeRange(const CString& begin, const CString& end)
     
331. {
     
332.         if (!m_ecSheet.m_lpDispatch)
     
333.         {
     
334.                 AfxMessageBox(_T("Sheet获取失败!"), MB_OK | MB_ICONWARNING);
     
335.                 return;
     
336.         }
     
337.         m_ecRange = m_ecSheet.get_Range(COleVariant(begin), COleVariant(end));
     
338. 
     
339.         if (!m_ecRange.m_lpDispatch)
     
340.         {
     
341.                 AfxMessageBox(_T("Range获取失败!"), MB_OK | MB_ICONWARNING);
     
342.                 return;
     
343.         }
     
344.         m_ecRange.Merge(_variant_t((long)0));
     
345. 
     
346.         //m_ecRange.put_HorizontalAlignment(_variant_t((long)-4108));      //水平居中对齐
     
347.         //m_ecRange.put_VerticalAlignment(_variant_t((long)-4108));        //竖直居中对齐
     
348.         //m_ecRange.put_ColumnWidth(_variant_t(20));                         //列宽
     
349.         //m_ecRange.put_RowHeight(COleVariant(_T("25")));                          //行高
     
350. 
     
351.         //ft.AttachDispatch(m_ecRange.get_Font());                            //匹配
     
352.         //ft.put_Bold(_variant_t((long)1));           //设置粗体，0-不加粗；1-加粗
     
353.         //ft.put_Italic(_variant_t((long)1));         //设置斜体，0-不斜；1-斜
     
354.         //ft.put_Size(_variant_t((long)18));                         //字大小
     
355.         //ft.put_ColorIndex(_variant_t((long)5));                       //字颜色           
     
356.         //it.AttachDispatch(m_ecRange.get_Interior());
     
357.         //it.put_ColorIndex(_variant_t((long)8));                            //背景色
     
358.         //m_ecRange.BorderAround(_variant_t((long)1), _variant_t((long)2), _variant_t((long)1), vtMissing, vtMissing);//线型            // 线宽              //颜色
     
359. }
     
360. 
     
361. bool ExcelOperate::InsertRow(const long& row, const long& column)
     
362. {
     
363.         if (!m_ecSheet.m_lpDispatch)
     
364.         {
     
365.                 AfxMessageBox(_T("Sheet获取失败!"), MB_OK | MB_ICONWARNING);
     
366.                 return FALSE;
     
367.         }
     
368.         m_ecRange = m_ecSheet.get_Cells();
     
369.         if (!m_ecRange.m_lpDispatch)
     
370.         {
     
371.                 AfxMessageBox(_T("Range获取失败!"), MB_OK | MB_ICONWARNING);
     
372.                 return false;
     
373.         }
     
374.        
     
375.         m_ecRange.AttachDispatch(m_ecRange.get_Item(COleVariant(row), COleVariant(column)).pdispVal, true);
     
376. 
     
377.         //CRange cols = m_ecRange.get_EntireColumn();//获取列
     
378.         //cols.AutoFit();
     
379.         CRange cols = m_ecRange.get_EntireRow();
     
380.         cols.Insert(vtMissing, _variant_t(1));//0是复制上面行格式，1是当前行
     
381.         cols.ReleaseDispatch();
     
382.         return true;
     
383. }
     
384. 
     
385. void ExcelOperate::SetRangeAndValue(const CString& begin, const CString& end, const CString& value)
     
386. {
     
387.         if (!m_ecSheet.m_lpDispatch)
     
388.         {
     
389.                 AfxMessageBox(_T("Sheet获取失败!"), MB_OK | MB_ICONWARNING);
     
390.                 return;
     
391.         }
     
392.         m_ecRange = m_ecSheet.get_Range(COleVariant(begin), COleVariant(end));
     
393. 
     
394.         if (!m_ecRange.m_lpDispatch)
     
395.         {
     
396.                 AfxMessageBox(_T("Range获取失败!"), MB_OK | MB_ICONWARNING);
     
397.                 return;
     
398.         }
     
399.         m_ecRange.put_Value2(COleVariant(value));       
     
400. }
     
401. 
     
402. void ExcelOperate::SetRangeAndValue(const long& row, const long& column, const CString& value)
     
403. {
     
404.         if (!m_ecSheet.m_lpDispatch)
     
405.         {
     
406.                 AfxMessageBox(_T("Sheet获取失败!"), MB_OK | MB_ICONWARNING);
     
407.                 return;
     
408.         }
     
409.         m_ecRange = m_ecSheet.get_Cells();
     
410.         if (!m_ecRange.m_lpDispatch)
     
411.         {
     
412.                 AfxMessageBox(_T("Range获取失败!"), MB_OK | MB_ICONWARNING);
     
413.                 return;
     
414.         }
     
415.         m_ecRange.put_Item(COleVariant(row), COleVariant(column), COleVariant(value));
     
416. 
     
417. 
     
418.         //m_ecRange.AttachDispatch(m_ecSheet.get_UsedRange());//加载已使用的单元格
     
419.         //m_ecRange.put_WrapText(_variant_t((long)1));//设置单元格内的文本为自动换行
     
420.         //m_ecRange.put_HorizontalAlignment(_variant_t((long)-4108));//水平居中
     
421.         //m_ecRange.put_VerticalAlignment(_variant_t((long)-4108));//垂直居中
     
422. }
     
423. 
     
424. void ExcelOperate::SetRangeAndValue(const long& row, const long& column, const int& value)
     
425. {
     
426.         if (!m_ecSheet.m_lpDispatch)
     
427.         {
     
428.                 AfxMessageBox(_T("Sheet获取失败!"), MB_OK | MB_ICONWARNING);
     
429.                 return;
     
430.         }
     
431.         m_ecRange = m_ecSheet.get_Cells();
     
432.         if (!m_ecRange.m_lpDispatch)
     
433.         {
     
434.                 AfxMessageBox(_T("Range获取失败!"), MB_OK | MB_ICONWARNING);
     
435.                 return;
     
436.         }
     
437.         m_ecRange.put_Item(COleVariant(row), COleVariant(column), _variant_t(value));
     
438. }
     
439. 
     
440. BOOL ExcelOperate::GetRangeAndValue(const CString& begin, const CString& end)
     
441. {
     
442.         if (!m_ecSheet.m_lpDispatch)
     
443.         {
     
444.                 AfxMessageBox(_T("Sheet获取失败!"), MB_OK | MB_ICONWARNING);
     
445.                 return FALSE;
     
446.         }
     
447.         m_ecRange = m_ecSheet.get_Range(COleVariant(begin), COleVariant(end));
     
448.         if (!m_ecRange.m_lpDispatch)
     
449.         {
     
450.                 AfxMessageBox(_T("Range获取失败!"), MB_OK | MB_ICONWARNING);
     
451.                 return FALSE;
     
452.         }
     
453.         ret = m_ecRange.get_Value2();//得到表格中的值  
     
454.         return TRUE;
     
455. }
     
456. 
     
457. BOOL ExcelOperate::GetRangeAndValue(const long& row, const long& column)
     
458. {
     
459.         if (!m_ecSheet.m_lpDispatch)
     
460.         {
     
461.                 AfxMessageBox(_T("Sheet获取失败!"), MB_OK | MB_ICONWARNING);
     
462.                 return FALSE;
     
463.         }
     
464.         m_ecRange = m_ecSheet.get_Cells();
     
465.         if (!m_ecRange.m_lpDispatch)
     
466.         {
     
467.                 AfxMessageBox(_T("Range获取失败!"), MB_OK | MB_ICONWARNING);
     
468.                 return false;
     
469.         }
     
470.         //CRange range;
     
471.         //range.AttachDispatch(m_ecRange.get_Item(COleVariant(row), COleVariant(column)).pdispVal, true);
     
472.         m_ecRange.AttachDispatch(m_ecRange.get_Item(COleVariant(row), COleVariant(column)).pdispVal, true);
     
473.         ret = m_ecRange.get_Value2();//得到表格中的值        
     
474.         return TRUE;
     
475. }
     
476. 
     
477. void ExcelOperate::GetRowsAndCols(long& rows, long& cols)
     
478. {
     
479.         COleSafeArray sa(ret);
     
480.         sa.GetUBound(1, &rows);
     
481.         sa.GetUBound(2, &cols);
     
482. }
     
483. 
     
484. BOOL ExcelOperate::GetTheValue(const int& rows, const int& cols, CString& dest)
     
485. {
     
486.         /*long rRows, rCols;
     
487.         long index[2];
     
488.         VARIANT val;
     
489.         COleSafeArray sa(ret);
     
490.         sa.GetUBound(1, &rRows);
     
491.         sa.GetUBound(2, &rCols);
     
492.         if (rows < 1 || cols < 1 || rRows < rows || rCols < cols)
     
493.         {
     
494.                 AfxMessageBox(_T("行列不在范围"));
     
495.                 return FALSE;
     
496.         }
     
497.         index[0] = rows;
     
498.         index[1] = cols;
     
499.         sa.GetElement(index, &val);
     
500.         if (val.vt != VT_BSTR)
     
501.         {
     
502.                 CString str;
     
503.                 str.Format(_T("出错点2, %d"), val.vt);
     
504.                 AfxMessageBox(str);
     
505.                 return FALSE;
     
506.         }
     
507.         dest = val.bstrVal;
     
508.         return TRUE;*/
     
509.         if (!m_ecSheet.m_lpDispatch)
     
510.         {
     
511.                 AfxMessageBox(_T("Sheet获取失败!"), MB_OK | MB_ICONWARNING);
     
512.                 return FALSE;
     
513.         }
     
514.         m_ecRange = m_ecSheet.get_Cells();
     
515.         if (!m_ecRange.m_lpDispatch)
     
516.         {
     
517.                 AfxMessageBox(_T("Range获取失败!"), MB_OK | MB_ICONWARNING);
     
518.                 return false;
     
519.         }
     
520.         CRange range;
     
521.         range.AttachDispatch(m_ecRange.get_Item(COleVariant((long)rows), COleVariant((long)cols)).pdispVal, true);
     
522.         ret = range.get_Value2();
     
523. 
     
524.         range.ReleaseDispatch();
     
525.         if (ret.vt == VT_BSTR)
     
526.         {
     
527.                 dest = ret.bstrVal;
     
528.         }
     
529.         //整数
     
530.         else if (ret.vt == VT_INT)
     
531.         {
     
532.                 dest.Format(_T("%d"), ret.pintVal);
     
533.         }
     
534.         //8字节的数字
     
535.         else if (ret.vt == VT_R8)
     
536.         {
     
537.                 dest.Format(_T("%.2lf"), ret.dblVal);
     
538.         }
     
539.         //时间格式
     
540.         else if (ret.vt == VT_DATE)
     
541.         {
     
542.                 SYSTEMTIME st;
     
543.                 VariantTimeToSystemTime(ret.date, &st);
     
544.                 CTime tm(st);
     
545.                 dest = tm.Format(_T("%Y-%m-%d"));
     
546. 
     
547.         }
     
548.         //单元格空的
     
549.         else if (ret.vt == VT_EMPTY)
     
550.         {
     
551.                 dest = "";
     
552.         }
     
553.         return TRUE;
     
554. }
     
555. 
     
556. BOOL ExcelOperate::SetTextFormat(const CString& beginS, const CString& endS)
     
557. {
     
558.         if (GetRangeAndValue(beginS, endS))
     
559.         {
     
560.                 m_ecRange.Select();
     
561.                 m_ecRange.put_NumberFormatLocal(COleVariant(_T("@")));
     
562.                 return TRUE;
     
563.         }
     
564.         return FALSE;
     
565. }
     
566. 
     
567. BOOL ExcelOperate::SetTextFormat(long& row, long& column)
     
568. {
     
569.         if (GetRangeAndValue(row, column))
     
570.         {
     
571.                 m_ecRange.Select();
     
572.                 m_ecRange.put_NumberFormatLocal(COleVariant(_T("@")));
     
573.                 return TRUE;
     
574.         }
     
575.         return FALSE;
     
576. }
     
577. 
     
578. BOOL ExcelOperate::SetRowToTextFormat(const CString& beginS, const CString& endS)
     
579. {
     
580.         if (GetRangeAndValue(beginS, endS))
     
581.         {
     
582.                 m_ecRange.Select();
     
583.                 CRange m_tempRange = m_ecSheet.get_Range(COleVariant(beginS), COleVariant(beginS));
     
584.                 if (!m_tempRange.m_lpDispatch) return FALSE;
     
585.                 COleVariant vTrue((short)TRUE),
     
586.                         vFalse((short)FALSE);
     
587.                 //int tempArray[2] = {1, 2};  
     
588.                 COleSafeArray saRet;
     
589.                 DWORD numElements = { 2 };
     
590.                 saRet.Create(VT_I4, 1, &numElements);
     
591.                 long index = 0;
     
592.                 int val = 1;
     
593.                 saRet.PutElement(&index, &val);
     
594.                 index++;
     
595.                 val = 2;
     
596.                 saRet.PutElement(&index, &val);
     
597.                 //m_tempRange.GetItem(COleVariant((short)5),COleVariant("A"));  
     
598.                 m_ecRange.TextToColumns(m_tempRange.get_Item(COleVariant((short)1), COleVariant((short)1)), 1, 1, vFalse, vTrue, vFalse, vFalse, vFalse, vFalse, vFalse, saRet, vFalse, vFalse, vTrue);
     
599.                 m_tempRange.ReleaseDispatch();
     
600.                 return TRUE;
     
601.         }
     
602.         return FALSE;
     
603. }
     
604. 
     

复制代码

1. #pragma once
   
2. #include "msexcel/CApplication0.h"
   
3. #include "msexcel/CWorkbook.h"
   
4. #include "msexcel/CWorkbooks.h"
   
5. #include "msexcel/CWorksheet.h"
   
6. #include "msexcel/CWorksheets.h"
   
7. #include "msexcel/CRange.h"
   
8. #include "msexcel/CFont1.h"
   
9. #include "msexcel/Cnterior0.h"
   
10. 
    
11. class ExcelOperate
    
12. {
    
13. public:
    
14.         ExcelOperate();
    
15. 
    
16.         ~ExcelOperate();
    
17. 
    
18.         //创建一个新的EXCEL应用程序
    
19.         BOOL CreateApp();
    
20. 
    
21.         //创建一个新的EXCEL工作簿集合
    
22.         BOOL CreateWorkbooks();   
    
23. 
    
24.         //创建一个新的EXCEL工作簿
    
25.         BOOL CreateWorkbook();   
    
26. 
    
27.         //创建一个新的EXCEL工作表集合
    
28.         BOOL CreateWorksheets();  
    
29. 
    
30.         //创建一个新的EXCEL工作表
    
31.         BOOL CreateWorksheet(short index);  
    
32. 
    
33.         BOOL CreateSheet(short index);
    
34. 
    
35.         //创建新的EXCEL应用程序并创建一个新工作簿和工作表
    
36.         BOOL Create(short index = 1);     
    
37. 
    
38.         //得到Sheet的总数
    
39.         int GetSheetCount();
    
40. 
    
41.         //通过名称使用某个sheet，
    
42.         BOOL LoadSheet(const CString& sheet);
    
43. 
    
44.         //显示EXCEL文档
    
45.         void ShowApp();
    
46. 
    
47.         //隐藏EXCEL文档
    
48.         void HideApp();
    
49. 
    
50.         BOOL OpenWorkbook(const CString& fileName, short index = 1);
    
51. 
    
52.         //创建新的EXCEL应用程序并打开一个已经存在的文档。
    
53.         BOOL Open(const CString& fileName);         
    
54. 
    
55.         //设置当前激活的文档。
    
56.         BOOL SetActiveWorkbook(short& i);   
    
57. 
    
58.         //Excel是以打开形式，保存。
    
59.         BOOL SaveWorkbook();      
    
60. 
    
61.         //Excel以创建形式，保存。
    
62.         BOOL SaveWorkbookAs(const CString& fileName);  
    
63. 
    
64.         /// <summary>
    
65.         /// 关闭
    
66.         /// </summary>
    
67.         /// <returns></returns>
    
68.         BOOL CloseWorkbook();
    
69.         /// <summary>
    
70.         /// 退出
    
71.         /// </summary>
    
72.         void CloseApp();
    
73. 
    
74.         //合并单元格
    
75.         void MergeRange(const CString& begin, const CString& end);
    
76. 
    
77.         //插入行
    
78.         bool InsertRow(const long& row, const long& column);
    
79. 
    
80.         //设置值
    
81.         void SetRangeAndValue(const CString& begin, const CString& end, const CString& value);
    
82.         void SetRangeAndValue(const long& row, const long& column, const CString& value);
    
83.         void SetRangeAndValue(const long& row, const long& column, const int& value);
    
84. 
    
85.         //得到begin到end的Range并将之间的值设置到ret中
    
86.         BOOL GetRangeAndValue(const CString& begin, const CString& end);
    
87.         BOOL GetRangeAndValue(const long& row, const long& column);
    
88. 
    
89.         //得到ret的行，列数
    
90.         void GetRowsAndCols( long& rows,  long& cols);
    
91. 
    
92.         //返回第rows，cols列的值，注意只返回文本类型的，到dest中
    
93.         BOOL GetTheValue(const int& rows,const int& cols, CString& dest);
    
94. 
    
95.         //将beginS到endS设置为文本格式(数字的还要用下面的方法再转一次)
    
96.         BOOL SetTextFormat(const CString& beginS, const CString& endS);
    
97.         BOOL SetTextFormat(long& row, long& column);
    
98. 
    
99.         //将beginS到endS(包括数字类型)设置为文本格式
    
100.         BOOL SetRowToTextFormat(const CString& beginS, const CString& endS);
     
101. 
     
102. private:
     
103.         CApplication0 m_ExcelApp;
     
104.         CWorkbooks m_ecBooks;
     
105.         CWorkbook m_ecBook;
     
106.         CWorksheets m_ecSheets;
     
107.         CWorksheet m_ecSheet;
     
108.         CRange m_ecRange;
     
109.         CFont1 ft;  //定义字体变量
     
110.         Cnterior it; //定义背景色变量
     
111.         VARIANT ret;//保存单元格的值
     
112.         LPDISPATCH lpDisp;
     
113. };
     

复制代码