By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
459,497 Members | 1,287 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 459,497 IT Pros & Developers. It's quick & easy.

How to create an excel file through a C program

P: n/a
I need to create an excel file through a C program and then to populate
it.How can it be done?

Apr 28 '06 #1
Share this Question
Share on Google+
27 Replies


P: n/a
jeniffer wrote:
I need to create an excel file through a C program and then to populate
it.How can it be done?

Ask microsoft for the file format, then write the code to produce the file.

--
Ian Collins.
Apr 28 '06 #2

P: n/a
jeniffer opined:
I need to create an excel file through a C program and then to
populate it.How can it be done?


By learning about Excel file format (if M$ lets you), which is
off-topic here. Once you do, and you have some C code that gives you
troubles, feel free to come back here for help.

On the most basic level, you'd need `fopen()`, `fwrite()`, and friends
from <stdio.h>.

--
Under every stone lurks a politician.
-- Aristophanes

<http://clc-wiki.net/wiki/Introduction_to_comp.lang.c>

Apr 28 '06 #3

P: n/a
In article <11**********************@u72g2000cwu.googlegroups .com>,
jeniffer <ze******************@gmail.com> wrote:
I need to create an excel file through a C program and then to populate
it.How can it be done?


fopen() the file with "wb" (write binary) mode, and
then fwrite() or fprintf() or putc() or fputc() whatever you need to.

You should probably avoid putw() and fputs(), though:
putw() works in terms of the type "int", which is not the same
size on all systems; and fputs() includes a terminating newline,
which is not the same character(s) on all systems.
What you need now is to know what the structure is of an excel file.
That's a topic beyond the scope of standard C, and is
subject to change without notice from Microsoft ("Documenting
a file structure hurts our ability to innovate!!") Inc.

You can find a long paper on the file format by googling for
excel file structure
for example, http://sc.openoffice.org/excelfileformat.pdf
has OpenOffice's documentation up to Excel 2003. You will likely
find the mass of information there rather daunting, and chances
are extremely high that if you were to attempt to implement the
full range yourself that you (or anyone) would make mistakes.
I would therefor suggest to you that you should either attempt to
find a pre-written Excel library (perhaps OpenOffice offers one),
or else that you take a big portability hit by confining yourself
to Windows and using one of Microsoft's development APIs.
Microsoft's APIs are discussed in microsoft-specific newsgroups.
--
If you lie to the compiler, it will get its revenge. -- Henry Spencer
Apr 28 '06 #4

P: n/a

jeniffer schrieb:
I need to create an excel file through a C program and then to populate
it.How can it be done?


Better you use in this case Visual Basic! Much easier and comfortable.

Apr 28 '06 #5

P: n/a
Zero opined:

jeniffer schrieb:
I need to create an excel file through a C program and then to
populate it.How can it be done?


Better you use in this case Visual Basic! Much easier and
comfortable.


Another possibility: use CSV format (comma separated values).

--
Beware of the Turing Tar-pit in which everything is possible but
nothing of interest is easy.

<http://clc-wiki.net/wiki/Introduction_to_comp.lang.c>

Apr 28 '06 #6

P: n/a
On 2006-04-28, jeniffer <ze******************@gmail.com> wrote:
I need to create an excel file through a C program and then to populate
it.How can it be done?


Probably create a .csv file (which you can do with normal fprintf and
string processing in C), and use Excel to import that.

Otherwise there is possibly a library, or some way to use Excel as a
co-process, you'd have to find out about Office and Microsoft
architecture.
Apr 28 '06 #7

P: n/a
Zero wrote:
jeniffer schrieb:
I need to create an excel file through a C program and then to populate
it.How can it be done?


Better you use in this case Visual Basic! Much easier and comfortable.

You scum. VB isn't a language. "Languages" work in more than one
environment.

My friend made a one-window app with two prompts and nothing else, and
it took up 3 megs of RAM. I made the same thing in C (with curses), and
it used about 50K, which seemed like a lot to me at the time...

--
"Every prime number in a series as a joke
Made all the patterns clear when I took that final toke"
- - Andrew Poelstra <http://www.wpsoftware.net/blog>
Apr 28 '06 #8

P: n/a
jeniffer wrote:

I need to create an excel file through a C program and then to
populate it. How can it be done?


FILE *excelfile;

if (NULL == (excelfile = fopen("filename", "w")))
exit(EXIT_FAILURE);
else {
while (suitableconditions) fwrite(excelfile, data);
}
fclose(excelfile);

You will have to define filename, suitableconditions, and data for
yourself.

--
"If you want to post a followup via groups.google.com, don't use
the broken "Reply" link at the bottom of the article. Click on
"show options" at the top of the article, then click on the
"Reply" at the bottom of the article headers." - Keith Thompson
More details at: <http://cfaj.freeshell.org/google/>
Also see <http://www.safalra.com/special/googlegroupsreply/>
Apr 28 '06 #9

P: n/a
In article <44***************@yahoo.com>,
CBFalconer <cb********@maineline.net> wrote:
jeniffer wrote:
I need to create an excel file through a C program and then to
populate it. How can it be done?

FILE *excelfile; if (NULL == (excelfile = fopen("filename", "w")))
exit(EXIT_FAILURE);


excel files are binary, and are most commonly used on platforms
where the distinction between binary and text is meaningful.
The OP would therefore be advised to use "wb" instead of "w".
--
If you lie to the compiler, it will get its revenge. -- Henry Spencer
Apr 28 '06 #10

P: n/a
Andrew Poelstra wrote:
Zero wrote:
jeniffer schrieb:
I need to create an excel file through a C program and then to populate
it.How can it be done?


Better you use in this case Visual Basic! Much easier and comfortable.

You scum. VB isn't a language. "Languages" work in more than one
environment.

Well, the requirements include an application that is basically only
available on one platform. In this case VB (or one of the embedded
VB-like thingies in Office) would be a decent choice.

If your design deliberately limits you to one platform then there is
small value in trying to be portable, especially for version 1. At my
shop we have the other problem; trying to make reasonably portable
extensions that can also talk to the madness that is Office.

Good, fast or cheap. Choose any two.
Apr 28 '06 #11

P: n/a
jeniffer wrote:
I need to create an excel file through a C program and then to populate
it.How can it be done?
This is not really on topic here but...

#include <windows.h>
#include <shellapi.h>
#include <stdio.h>
int main(void)
{
FILE *ExcelFile = fopen("testdata.csv","w");
if (ExcelFile == NULL)
return -1;
fprintf(ExcelFile,"Column1,Column2,Column3\n1,2,3\ n");
fclose(ExcelFile);
ShellExecute((HWND)0,"open","testdata.csv",NULL,NU LL,SW_SHOW);
}

Compiled with lcc-win32
http://www.cs.virginia.edu/~lcc-win32
Apr 28 '06 #12

P: n/a
In 100% standard C you can do it with

#include <stdio.h>
#include <stdlib.h>
int main(void)
{
FILE *ExcelFile = fopen("testdata.csv","w");
if (ExcelFile == NULL)
return -1;
fprintf(ExcelFile,"Column1,Column2,Column3\n1,2,3\ n");
fclose(ExcelFile);
system("D:\\Program Files\\Microsoft Office\\Office\\excel.exe
testdata.csv");
return 0;
}
Apr 28 '06 #13

P: n/a
In article <44***********************@news.wanadoo.fr>,
jacob navia <ja***@jacob.remcomp.fr> wrote, without quoting the
original text:
In 100% standard C you can do it with
"it" refered to "create an excel file and populate it".

#include <stdio.h>
#include <stdlib.h>
int main(void)
{
FILE *ExcelFile = fopen("testdata.csv","w");
if (ExcelFile == NULL)
return -1;
fprintf(ExcelFile,"Column1,Column2,Column3\n1,2,3\ n");
fclose(ExcelFile);
system("D:\\Program Files\\Microsoft Office\\Office\\excel.exe
testdata.csv");
return 0;
}


That does not create an excel file: at most it creates a file that excel
is able to read.

Returning -1 from main() would have an implementation-defined effect.
As you are already including <stdlib.h>, why not use EXIT_FAILURE
instead?

The system() call is irrelevant to the original problem of creating
and populating an excel file, and makes the program much less portable.

There is another problem with the code that could arise especially
in Germany: comma might be the decimal delimeter (the equivilent
to the decimal point), and the field delimeter expected might be
the semi-colon. The 1,2 in the file might be interpreted as 1 + 2/10
(1.2) instead of as indicating the boundary between two cells.
--
If you lie to the compiler, it will get its revenge. -- Henry Spencer
Apr 28 '06 #14

P: n/a
jacob navia wrote:
jeniffer wrote:
I need to create an excel file through a C program and then to populate
it.How can it be done?
This is not really on topic here but...


Then why post it here?
#include <windows.h>
#include <shellapi.h>
#include <stdio.h>
int main(void)
{
FILE *ExcelFile = fopen("testdata.csv","w");
if (ExcelFile == NULL)
return -1;
fprintf(ExcelFile,"Column1,Column2,Column3\n1,2,3\ n");
fclose(ExcelFile);
ShellExecute((HWND)0,"open","testdata.csv",NULL,NU LL,SW_SHOW);
}

Compiled with lcc-win32
http://www.cs.virginia.edu/~lcc-win32


Of course, if you had used the system call provided by the standard you
would not have needed the non-standard headers and it would have
compiled and worked with many more compilers. Such as the gcc
implementation that is part of Cygwin.
--
Flash Gordon, living in interesting times.
Web site - http://home.flash-gordon.me.uk/
comp.lang.c posting guidelines and intro:
http://clc-wiki.net/wiki/Intro_to_clc
Apr 28 '06 #15

P: n/a
jacob navia <ja***@jacob.remcomp.fr> writes:
In 100% standard C you can do it with

#include <stdio.h>
#include <stdlib.h>
int main(void)
{
FILE *ExcelFile = fopen("testdata.csv","w");
if (ExcelFile == NULL)
return -1;
fprintf(ExcelFile,"Column1,Column2,Column3\n1,2,3\ n");
fclose(ExcelFile);
system("D:\\Program Files\\Microsoft Office\\Office\\excel.exe
testdata.csv");
return 0;
}


That's 100% standard and 0% portable -- and it doesn't satisfy the
original requirements.

Apart from the other non-portabilities that have already been
mentioned, I do have MS Excel on my computer, but it's not on my DVD
drive (D:).

If your program is inherently non-portable, there's little point in
avoiding the use of non-standard extensions that will do the job
better than system() can. Of course, the use of such extensions would
make the program off-topic in this newsgroup -- which merely means
that it should be discussed in a *different* newsgroup, possibly one
full of experts who might know better ways of creating Excel files.

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.
Apr 28 '06 #16

P: n/a
Flash Gordon wrote:
Of course, if you had used the system call provided by the standard you
would not have needed the non-standard headers and it would have
compiled and worked with many more compilers. Such as the gcc
implementation that is part of Cygwin.


I did exactly that, see my other post
Apr 28 '06 #17

P: n/a
Keith Thompson wrote:
jacob navia <ja***@jacob.remcomp.fr> writes:
In 100% standard C you can do it with

#include <stdio.h>
#include <stdlib.h>
int main(void)
{
FILE *ExcelFile = fopen("testdata.csv","w");
if (ExcelFile == NULL)
return -1;
fprintf(ExcelFile,"Column1,Column2,Column3\n1,2,3\ n");
fclose(ExcelFile);
system("D:\\Program Files\\Microsoft Office\\Office\\excel.exe
testdata.csv");
return 0;
}

That's 100% standard and 0% portable -- and it doesn't satisfy the
original requirements.

Apart from the other non-portabilities that have already been
mentioned, I do have MS Excel on my computer, but it's not on my DVD
drive (D:).

If your program is inherently non-portable, there's little point in
avoiding the use of non-standard extensions that will do the job
better than system() can. Of course, the use of such extensions would
make the program off-topic in this newsgroup -- which merely means
that it should be discussed in a *different* newsgroup, possibly one
full of experts who might know better ways of creating Excel files.


The ShellExecute makes possible to ignore the path of the excel
executable. system() is not that clever, and the path is in this case
hardwired. The program is thus non-portable, but can be made to work in
any machine with Excel with very little effort :-)

Of course, lcc-win32 offers the possibility of using the dispatch
interface of Excel and dynamically populating the cells, making excel
display a graphic of the data, whatever. But if I would have posted that
it would have been a 1500 line program full of windowish code... shudder.

Let's keep it at that. If the original posted is interested, we can
discuss that in the lcc group.

jacob
Apr 28 '06 #18

P: n/a
Walter Roberson a écrit :
In article <44***********************@news.wanadoo.fr>,
jacob navia <ja***@jacob.remcomp.fr> wrote, without quoting the
original text:

In 100% standard C you can do it with

"it" refered to "create an excel file and populate it".
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
FILE *ExcelFile = fopen("testdata.csv","w");
if (ExcelFile == NULL)
return -1;
fprintf(ExcelFile,"Column1,Column2,Column3\n1,2,3\ n");
fclose(ExcelFile);
system("D:\\Program Files\\Microsoft Office\\Office\\excel.exe
testdata.csv");
return 0;
}

That does not create an excel file: at most it creates a file that excel
is able to read.


Well, an "excel file" is a file excel can read, I suppose :-)

Returning -1 from main() would have an implementation-defined effect.
As you are already including <stdlib.h>, why not use EXIT_FAILURE
instead?

This is true. That would be better.

The system() call is irrelevant to the original problem of creating
and populating an excel file, and makes the program much less portable.

There is another problem with the code that could arise especially
in Germany: comma might be the decimal delimeter (the equivilent
to the decimal point), and the field delimeter expected might be
the semi-colon. The 1,2 in the file might be interpreted as 1 + 2/10
(1.2) instead of as indicating the boundary between two cells.


That could be fixed with LC_LOCALE and seeing what the german version of
excel does...
Apr 28 '06 #19

P: n/a
jacob navia <ja***@jacob.remcomp.fr> writes:
Keith Thompson wrote:
jacob navia <ja***@jacob.remcomp.fr> writes:
[snip] Of course, lcc-win32 offers the possibility of using the dispatch
interface of Excel and dynamically populating the cells, making excel
display a graphic of the data, whatever. But if I would have posted
that it would have been a 1500 line program full of windowish
code... shudder.
It would also probably have been closer to what the OP was actually
looking (in the wrong place) for.

Trying to generate a valid ".xls" file using only standard C would be
silly. The only reason I can think of to do so is if you have a
requirement to generate such a file on non-Windows systems, or perhaps
on Windows systems on which Excel isn't installed (something that the
original poster didn't explicitly ask for). Microsoft, which controls
the ".xls" format, is unlikely to be very helpful in meeting such a
requirement.

Excel files use a system-specific format, requiring system-specific
code to deal with them. There is nothing wrong with writing
system-specific code when it's appropriate (any fools who think I'm a
"religious fanatic" on this point please take note); this just isn't
the place to discuss the details.
Let's keep it at that. If the original posted is interested, we can
discuss that in the lcc group.


Bravo! I hope this becomes a habit.

(If this can be done with features that are specific to Windows but
not to lcc-win32, perhaps an MS Windows programming group would be
more appropriate. Since I really don't know much about those details,
I'm only guessing here.)

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.
Apr 28 '06 #20

P: n/a
jacob navia wrote:
In 100% standard C you can do it with

#include <stdio.h>
#include <stdlib.h>
int main(void)
{
FILE *ExcelFile = fopen("testdata.csv","w");
if (ExcelFile == NULL)
return -1;
fprintf(ExcelFile,"Column1,Column2,Column3\n1,2,3\ n");
fclose(ExcelFile);
system("D:\\Program Files\\Microsoft Office\\Office\\excel.exe
testdata.csv");
return 0;
}

/Please/ quote you context.

And I love how you used the word "standard" and avoided entirely the
word "portable". The point of having standards is that you have a decent
level of portability.

--
"Every prime number in a series as a joke
Made all the patterns clear when I took that final toke"
- - Andrew Poelstra <http://www.wpsoftware.net/blog>
Apr 28 '06 #21

P: n/a
Walter Roberson wrote:
CBFalconer <cb********@maineline.net> wrote:
jeniffer wrote:

I need to create an excel file through a C program and then to
populate it. How can it be done?

FILE *excelfile;

if (NULL == (excelfile = fopen("filename", "w")))
exit(EXIT_FAILURE);


excel files are binary, and are most commonly used on platforms
where the distinction between binary and text is meaningful.
The OP would therefore be advised to use "wb" instead of "w".


The OP specified "excel file". What that consists of is not
specified in any C standard, so lacking specific other
specification, I stand by my solution. I think it was the Red
Queen that said "excel file means exactly what I intend it to
mean".

However it could well turn out that the "wb" is better suited.

--
"The power of the Executive to cast a man into prison without
formulating any charge known to the law, and particularly to
deny him the judgement of his peers, is in the highest degree
odious and is the foundation of all totalitarian government
whether Nazi or Communist." -- W. Churchill, Nov 21, 1943
Apr 29 '06 #22

P: n/a
jacob navia wrote:
Keith Thompson wrote:
jacob navia <ja***@jacob.remcomp.fr> writes:
In 100% standard C you can do it with

#include <stdio.h>
#include <stdlib.h>
int main(void)
{
FILE *ExcelFile = fopen("testdata.csv","w");
if (ExcelFile == NULL)
return -1;
fprintf(ExcelFile,"Column1,Column2,Column3\n1,2,3\ n");
fclose(ExcelFile);
system("D:\\Program Files\\Microsoft Office\\Office\\excel.exe
testdata.csv");
return 0;
}
That's 100% standard and 0% portable -- and it doesn't satisfy the
original requirements.

Apart from the other non-portabilities that have already been
mentioned, I do have MS Excel on my computer, but it's not on my DVD
drive (D:).

If your program is inherently non-portable, there's little point in
avoiding the use of non-standard extensions that will do the job
better than system() can. Of course, the use of such extensions would
make the program off-topic in this newsgroup -- which merely means
that it should be discussed in a *different* newsgroup, possibly one
full of experts who might know better ways of creating Excel files.


The ShellExecute makes possible to ignore the path of the excel
executable. system() is not that clever, and the path is in this case
hardwired. The program is thus non-portable, but can be made to work in
any machine with Excel with very little effort :-)


Actually, in Windows, there are commands you could have used that would
not have relied on knowing where excel is or even knowing what
application to use. However, how to do that is off topic here.
Of course, lcc-win32 offers the possibility of using the dispatch
interface of Excel and dynamically populating the cells, making excel
display a graphic of the data, whatever. But if I would have posted that
it would have been a 1500 line program full of windowish code... shudder.

Let's keep it at that. If the original posted is interested, we can
discuss that in the lcc group.


That is an appropriate redirect. Other Windows groups may have other
solutions available as well.
--
Flash Gordon, living in interesting times.
Web site - http://home.flash-gordon.me.uk/
comp.lang.c posting guidelines and intro:
http://clc-wiki.net/wiki/Intro_to_clc
Apr 29 '06 #23

P: n/a
Walter Roberson wrote:
In article <11**********************@u72g2000cwu.googlegroups .com>,
jeniffer <ze******************@gmail.com> wrote:
I need to create an excel file through a C program and then to populate
it.How can it be done?


fopen() the file with "wb" (write binary) mode, and
then fwrite() or fprintf() or putc() or fputc() whatever you need to.

You should probably avoid putw() and fputs(), though:
putw() works in terms of the type "int", which is not the same
size on all systems; and fputs() includes a terminating newline,
which is not the same character(s) on all systems.
What you need now is to know what the structure is of an excel file.
That's a topic beyond the scope of standard C, and is
subject to change without notice from Microsoft ("Documenting
a file structure hurts our ability to innovate!!") Inc.

You can find a long paper on the file format by googling for
excel file structure
for example, http://sc.openoffice.org/excelfileformat.pdf
has OpenOffice's documentation up to Excel 2003. You will likely
find the mass of information there rather daunting, and chances
are extremely high that if you were to attempt to implement the
full range yourself that you (or anyone) would make mistakes.
I would therefor suggest to you that you should either attempt to
find a pre-written Excel library (perhaps OpenOffice offers one),
or else that you take a big portability hit by confining yourself
to Windows and using one of Microsoft's development APIs.
Microsoft's APIs are discussed in microsoft-specific newsgroups.


fgets() will read a line including the trailing newline and terminate it
with '\0' as a string in memory.

fputs() will write the string including the newline, if it's there, and
not the terminating '\0'. Actually fputs() will write any string without
regard to newline.
--
Joe Wright
"Everything should be made as simple as possible, but not simpler."
--- Albert Einstein ---
Apr 29 '06 #24

P: n/a
Vladimir Oka wrote:
Zero opined:
jeniffer schrieb:
I need to create an excel file through a C program and then to
populate it.How can it be done?

Better you use in this case Visual Basic! Much easier and
comfortable.


Another possibility: use CSV format (comma separated values).

Yes, CSV is much easier to do in C but be warned that Excel does a poor
job of reading the .csv file. The Excel user generally has to reformat
various columns.

--
Joe Wright
"Everything should be made as simple as possible, but not simpler."
--- Albert Einstein ---
Apr 29 '06 #25

P: n/a
ro******@ibd.nrc-cnrc.gc.ca (Walter Roberson) wrote:
In article <44***********************@news.wanadoo.fr>,
jacob navia <ja***@jacob.remcomp.fr> wrote, without quoting the
original text:
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
FILE *ExcelFile = fopen("testdata.csv","w");
if (ExcelFile == NULL)
return -1;
fprintf(ExcelFile,"Column1,Column2,Column3\n1,2,3\ n");
fclose(ExcelFile);
system("D:\\Program Files\\Microsoft Office\\Office\\excel.exe
testdata.csv");
return 0;
}
That does not create an excel file: at most it creates a file that excel
is able to read.


And write, to a point.
There is another problem with the code that could arise especially
in Germany: comma might be the decimal delimeter (the equivilent
to the decimal point), and the field delimeter expected might be
the semi-colon. The 1,2 in the file might be interpreted as 1 + 2/10
(1.2) instead of as indicating the boundary between two cells.


Amazingly, Excel appears able to read real C(!)SV files even when
Windows is set to non-USAnian setting (at least, to Dutch ones); though
I have yet to find the option to make it write one.

At least CSV files can be written with proper C code, without having to
resort to MS-specific libraries. Normal Excel files can only be
approximated.

Richard
May 1 '06 #26

P: n/a
"void * clvrmnky()" <cl**************@hotmail.com.invalid> wrote:
Andrew Poelstra wrote:
Zero wrote:
jeniffer schrieb:

I need to create an excel file through a C program and then to populate
it.How can it be done?

Better you use in this case Visual Basic! Much easier and comfortable.
You scum. VB isn't a language. "Languages" work in more than one
environment.

Well, the requirements include an application that is basically only
available on one platform.


No, the requirements include writing a file for that application. This
can be done on a platform on which said application does not run itself.
In this case VB (or one of the embedded
VB-like thingies in Office) would be a decent choice.


It rarely if ever is.

Richard
May 1 '06 #27

P: n/a
"jeniffer" <ze******************@gmail.com> writes:
I need to create an excel file through a C program and then to populate
it.How can it be done?


What type of excel file? Excel supports many type formats for
import/export.

If it is the real "xls" file format then you need to familiarise
youeself with writing to and reading from binary files in C. Google will
show you how. Reading and writing binary files has its own issues over
doing it in normal ascii text mode : there can be platform specific
issues too.

Here is the excel file format explained : I can not comment on the
accuracy. There are many many complications to consider : byte ordering,
structure padding to name but 2.

http://sc.openoffice.org/excelfileformat.pdf

However, maybe you just need to write a text CSV file.

Good luck!
May 2 '06 #28

This discussion thread is closed

Replies have been disabled for this discussion.