system()

system("a.exe -c i -g j");
i j i j
system() a.exe i j -c -g

system
char cmdstr[100];
int i,j;
i=6;
j=6;
sprintf(cmdstr,"a.exe -c %d -g %d",i,j);
system(cmdstr);

tmpfile
1
0

gdb tmpfile()
/tmp API

linux-0gt0:~ # cat 1.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main()
{
pid_t pid;
char s[100];
FILE* f;
f=tmpfile();
pid=getpid();
sprintf(s,"ls -l /proc/%d/fd",pid);
system(s);
return 0;
}
linux-0gt0:~ # gcc 1.c && ./a.out
total 4
lrwx------ 1 root root 64 Aug 30 04:55 0 -> /dev/pts/0
lrwx------ 1 root root 64 Aug 30 04:55 1 -> /dev/pts/0
lrwx------ 1 root root 64 Aug 30 04:55 2 -> /dev/pts/0
lrwx------ 1 root root 64 Aug 30 04:55 3 -> /tmp/tmpfdSnQSE (deleted)
tmpfile /tmp open
unlink close

unlink() unlink fclose() system()

fclose()(deleted)

deleted unlink

linux-0gt0:/tmp # cat 1.c

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main()
{
int fd;
char s[100];
pid_t pid;
pid=getpid();
sprintf(s,"ls -l /proc/%d/fd",pid);
fd=open("/tmp/mytestfile",O_CREAT,O_WRONLY,0600);
unlink("/tmp/mytestfile");
printf("ls -l /tmp/mytestfile\n");
system("ls -l /tmp/mytestfile");
printf("\n=============================\n");
printf("%s\n",s);
system(s);
close(fd);
printf("\n=============================\n");
printf("%s\n",s);
system(s);
printf("\n=============================\n");
printf("ls -l /tmp/mytestfile\n");
system("ls -l /tmp/mytestfile");
return 0;
}
linux-0gt0:/tmp # gcc 1.c && ./a.out
ls -l /tmp/mytestfile
ls: /tmp/mytestfile: No such file or directory

=============================
ls -l /proc/15843/fd
total 4
lrwx------ 1 root root 64 Aug 30 08:13 0 -> /dev/pts/0
lrwx------ 1 root root 64 Aug 30 08:13 1 -> /dev/pts/0
lrwx------ 1 root root 64 Aug 30 08:13 2 -> /dev/pts/0
lr-x------ 1 root root 64 Aug 30 08:13 3 -> /tmp/mytestfile (deleted)

=============================
ls -l /proc/15843/fd
total 3
lrwx------ 1 root root 64 Aug 30 08:13 0 -> /dev/pts/0
lrwx------ 1 root root 64 Aug 30 08:13 1 -> /dev/pts/0
lrwx------ 1 root root 64 Aug 30 08:13 2 -> /dev/pts/0

=============================
ls -l /tmp/mytestfile
ls: /tmp/mytestfile: No such file or directory

This function removes the directory entry and decrements the link count of the file referenced by
pathname. If there are other links to the file, the data in the file is still accessible through the other
links. The file is not changed if an error occurs.

Only when the link count reaches 0 can the contents of the file be deleted. One other condition
prevents the contents of a file from being deleted: as long as some process has the file open, its
contents will not be deleted. When a file is closed, the kernel first checks the count of the number
of processes that have the file open. If this count has reached 0, the kernel then checks the link
count; if it is 0, the file's contents are deleted.

This property of unlink is often used by a program to ensure that a temporary file it creates won't
be left around in case the program crashes. The process creates a file using either open or creat and
then immediately calls unlink. The file is not deleted, however, because it is still open. Only when
the process either closes the file or terminates, which causes the kernel to close all its open files, is
the file deleted.

I / O tmpnam
#include <stdio.h>
char *tmpnam(char *s);
tmpnam()
TMP_MAX

tmpnam() s NULL s NULL

L_tmpnam

tmpnam

#include <stdio.h>
#define N 128
int main() {
char s[N] = {0}, *p;
if ((p = tmpnam(s)) == NULL) {
perror("tmpnam");
return -1;
}
printf("s=%s p=%s\n", s, p);
return 0;
}

tmpfile :
#include <stdio.h>
FILE *tmpfile(void);

#include <stdio.h>
#define N 128
int main() {
char s[N] = {0}, *p;
FILE * fp;
int ch = 0;
if ((p = tmpnam(s)) == NULL) {
perror("tmpnam");
return -1;
}
printf("s=%s p=%s\n", s, p);
printf("TMP_MAX=%d\n", TMP_MAX);
if ((fp = tmpfile()) == NULL) {
perror("tmpfile");
return -1;
}
if (fputc('a', fp) == EOF) {
perror("fputc");
return -1;
}
fseek(fp, 0, SEEK_SET);
ch = fgetc(fp);
printf("ch=%d\n",ch);
getchar();
puts("end main");
fclose(fp);
ch = fgetc(fp);
printf("ch=%d\n",ch);
return 0;
}

getchar
/tmp deleted /tmp
Linux 0
0

tmpfile()
tmpnam()
fopen()
unlink()
tmpfile()
C fgets(...) fputs(...)
ANSI C 3
1. standard input . stdin.
2 standard output. stdout
3. standard error. stderr.
FILE
fputs(...)
int fputs(char *s, FILE *stream);
s

example
FILE *fp=fopen("test.txt","w");
char s1[20]="hello world";
char *s2="hello C
fputs(s1,fp); //
fputs(s2,fp); //
fputs("hello",fp); //
C

0, 1.
EOF
fputs(char *s, FILE *stream)

fputs(...)
FILE stdout

fputs("hello world",stdout);
hello word.
fputs(...)
int fputs(char *s, FILE *stream)
{
int c;
while(c =*s++) //fputs
putc(c,stream);
return ferror(stream)? EOF:
}

FILE *tmpfile(void); Returns: file pointer if OK, NULL on error.

The tmpfile() function opens a unique temporary file in binary read/write (w+b) mode. The file
will be automatically deleted when it is closed or the program terminates.
int mkstemp(char *template); Returns: file descriptor if OK, 1 on error.
The mkstemp() function generates a unique temporary filename from template. The last six charac
ters of template must be XXXXXX and these are replaced with a string that makes the filename
unique. The file is then created with mode read/write and permissi ons 0666 (glibc 2.0.6 and earl
ier), 0600 (glibc 2.0.7 and later). Since it will be modified, template must not be a string const
ant, but should be declared as a character array. The file is opened with the open(2) O_EXCL flag,
guaranteeing that when mkstemp() returns successfully we are the only user.

tempfile mkstemp
unlink mkstemp unlink
mkstemp

The reason I ask is that I'd like to use tmpfile() to create a temporary file (because then it will be
automatically deleted should my script abruptly terminate.) Once I've written my data to this file, I
then need to pass the filename on to an external command, but I can't see any way to find out what
the temporary file is called.

I've tried using fstat(), but this returns everything except the filename.

You can't. But then the file will be deleted when you fclose() it and you should close a file you
have open for writing before passing it off to another program, anyway.

const char *name = tmpnam(NULL); // Get temp name

FILE *fp = fopen(name, "w"); // Create the file
// ...
fclose(fp);
remove(name);

#include<stdio.h>
#include<stdlib.h>
int main(void)
{
int fd;
char temp_file[]="tmp_XXXXXX";
/*Creat a temp file.*/
if((fd=mkstemp(temp_file))==-1)
{
printf("Creat temp file faile./n");
exit(1);
}
/*Unlink the temp file.*/
unlink(temp_file);
/*Then you can read or write the temp file.*/
//ADD YOUR CODE;
/*Close temp file, when exit this program, the temp file will be removed.*/
close(fd);
}

void writeFile() {
char s[] = "abc.txt";
//
int fd = open(s, O_RDWR | O_APPEND);
if(fd == -1) {
// errno
// strerror
printf("error is %s\n", strerror(errno));
return;
}

printf("sucess fd = %d\n", fd);

char buf[100];
memset(buf, 0, sizeof(buf));
int i = 10;
while(i-- > 0){
strcpy(buf, "hello world linux write file \n");
write(fd, buf, strlen(buf));
memset(buf, 0, sizeof(buf));
}

close(fd);