In this article, I will discuss two approaches for getting the file size using the C programming language.
Approach 1
When we have to get the file size first approach that comes to our mind is to open the file, seek the cursor to the end of the file, and then get the position of the cursor which is nothing but the size of the file.
Let's understand how can we achieve this.
- First, open a file using
fopen
. The first argument is the file path and the second argument ismode
and it returns thefile descriptor
. Since we don't have to modify the file open it in read mode using"r"
. - Now move the cursor to the end of the file using
fseek
which takes the following arguments respectively.-
fd
file descriptor of the file opened. -
offset
how much to offset w.r.t the third argument position. -
whence
from where the cursor should consider moving from. We have three options for it,SEEK_SET
relative to the start of the file,SEEK_CUR
relative to the current position, andSEEK_END
relative to the end of the file.
-
Since we have to move to the end of the file we take relative to the end of the file and offset it as zero, as we have to move zero from the end. fseek
return -1
if it fails.
- Now use
ftell
to get the current position which takesfd
as an argument and returns the current position which is our file size. On failing it returns-1
.
NOTE: If the cursor move by 1 unit we consider it as 1 byte because the size of
char
is 1 byte andfopen
reads the file character by character only.
Code
#include <stdio.h>
// function get file size
long get_file_size(char *);
int main() {
char *filename = "a.out";
printf(
"Size of file `%s` is %ld\n",
filename,
get_file_size(filename)
);
return 0;
}
long get_file_size(char *filename) {
FILE *fp = fopen(filename, "r");
if (fp==NULL)
return -1;
if (fseek(fp, 0, SEEK_END) < 0) {
fclose(fp);
return -1;
}
long size = ftell(fp);
// release the resources when not required
fclose(fp);
return size;
}
Output
Size of file `a.out` is 51880 bytes
Approach 2
In this approach, we use stat
API to get the file information which also includes file size.
For this, we simply call the stat
function which takes a file path as the first argument and pointer to the stat struct variable as the second argument and returns -1
on failure.
To get the file size we can simply use the st_size
attribute.
Code
#include <sys/stat.h> // stat
// inherit the above base code here
long get_file_size(char *filename) {
struct stat file_status;
if (stat(filename, &file_status) < 0) {
return -1;
}
return file_status.st_size;
}
Output
Size of file `a.out` is 51880 bytes
Using this we can get some other information about a file such as permission, creation time, user id, group id, etc. Also, there are some other functions defined that can be used based on requirements. Check out its man page for more info.
Which one should be used?
The second approach is more recommended because of the following reason.
- It's fast as we don't have to open a file which in the first approach has to be done. Some compilers may buffer a file on opening which makes the first approach slower.
- The code is more clear to other developers that we are trying to get file info.
But this code is not portable. As other APIs are developed on OS like windows to get file info.
Whereas the first approach code is portable. As same code works normally without any problem.
So, in conclusion, which strategy we should take is entirely dependent on our requirements.
This article is highly inspired by the content provided by Jacob Sorber on his youtube channel.
β€οΈThank you so much for reading this article. I'm a passionate engineering student learning new things so If you find any mistakes or have any suggestions please let me know in the comments.
Also, consider sharing and giving a thumbs up If this post helps you in any way.
Top comments (0)