نکات توابع سی و بعضی مهارتها

[saalek110]

بعد از مقداری پرداختن به توابع سی
در اینجا می خواهیم به خواندن و نوشتن در فایل بپردازیم:
نوشتن با fprintf و fputs
و در پست مربوطه خواندن با fscanf و fgets
منبع

#include <stdio.h>

main() {
   FILE *fp;

   fp = fopen("test.txt", "w+");
   fprintf(fp, "This is testing for fprintf...\n");
   fputs("This is testing for fputs...\n", fp);
   fclose(fp);
}

و در فایل در خط اول و دوم چنین می یابیم:

This is testing for fprintf...
This is testing for fputs...

 

[saalek110]

به این خط برنامه پست قبل نگاه کنید:

 fp = fopen("/tmp/test.txt", "w+");

حرف w به معنی نوشتن است.
نمادها را در زیر می بینیم:


منبع

 

[saalek110]

خواندن همان فایل
با fscanf و fgets

#include <stdio.h>

main() {

   FILE *fp;
   char buff[255];

   fp = fopen("test.txt", "r");
   fscanf(fp, "%s", buff);
   printf("1 : %s\n", buff );

   fgets(buff, 255, (FILE*)fp);
   printf("2: %s\n", buff );

   fgets(buff, 255, (FILE*)fp);
   printf("3: %s\n", buff );
   fclose(fp);

}

منبع

فایل این بود:

 

[saalek110]

خواندن همان فایل به روشی دیگر:

#include <stdio.h>
int main()
{
     /* Pointer to the file */
     FILE *fp1;
     /* Character variable to read the content of file */
     char c;

     /* Opening a file in r mode*/
     fp1= fopen ("test.txt", "r");

     /* Infinite loop –I have used break to come out of the loop*/
     while(1)
     {
        c = fgetc(fp1);
        if(c==EOF)
            break;
        else
            printf("%c", c);
     }
     fclose(fp1);
     return 0;
}

منبع
در همین تاپیک قبلا با getc کار کرده بودیم و اینجا fgetc است که خاص فایل است.
در حلقه ای بی انتها به شرط رویت نشدن EOF فایل را می خواند. EOF نشانه پایان فایل است.

 

[saalek110]

مراقبت از باز شدن درست فایل:
منبع

FILE fpr;
fpr = fopen("C:\\myfiles\\newfile.txt", "r");
if (fpr == NULL)
{
    puts("Error while opening file");
    exit();
}

در کد بالا در صورت وجود اشکال پیامی می دهد و برنامه را خاتمه می دهد.

 

[saalek110]

منبع
نوشتن یک فایل باینری:
یک استراکت را در فایل باینری می نویسیم. اول شرح استراکت در عکس.

#include <stdio.h>
    /* Our structure */
    struct rec
    {
        int x,y,z;
    };
int main( ) {

        FILE *ptr_myfile;
        struct rec my_record;
        my_record.x=3; my_record.y=55; my_record.z=168;

        ptr_myfile=fopen("test.bin","wb");
        if (!ptr_myfile)
        {
            printf("Unable to open file!");
            return 1;
        }

            fwrite(&my_record, sizeof(struct rec), 1, ptr_myfile);

        fclose(ptr_myfile);


   return 0;
}

خواندن همان فایل باینری:

#include <stdio.h>
    /* Our structure */
    struct rec
    {
        int x,y,z;
    };
int main( ) {

        FILE *ptr_myfile;
        struct rec my_record;

        ptr_myfile=fopen("test.bin","rb");
        if (!ptr_myfile)
        {
            printf("Unable to open file!");
            return 1;
        }

            fread(&my_record,sizeof(struct rec),1,ptr_myfile);

        fclose(ptr_myfile);
            printf("%d\n",my_record.x);
            printf("%d\n",my_record.y);
            printf("%d\n",my_record.z);


   return 0;
}

شرح برنامه:
هدف نوشتن یک استراکت در فایل باینری است. حرف b در wb در

        ptr_myfile=fopen("test.bin","wb");

نشانه یاینری است. ( و همچنین حرف b در rb در برنامه خواندن فایل)
استراکت ما 3 عضو عددی دارد. در فایل اول این 3 عضو را مقدار دهی کرده ایم و سپس استراکت را در فایل نوشته ایم.
در فایل خواندن هم استراکت را خوانده ایم.

 

[saalek110]

ساخت یک فایلbmp:
منبع
کل کد این صفحه را کپی کنید.
یا از پست بعدی کد را بگیرید.
اجرا شد. نتیجه اجرا:


این برنامه آموزشی نیست. آنتراکت بود. برنامه های ساده تری وجود دارد.

 

[saalek110]

کد پست قبل:
کد زیاد بود فروم قبول نمی کرد
مقداری از کامنت ها را حذف کردم تا فروم قبول کند.
برای کد کامل به سایت اصلی مراجعه کنید.

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define OUTFILE "buddhabrot"

#define WIDTH 1024
#define HEIGHT 768

#define CENTRE_X -0.451                
#define CENTRE_Y 0
#define ZOOM 310                    // Try 310

#define SOURCE_COLUMNS (WIDTH * 10)        
#define SOURCE_ROWS (HEIGHT * 10)        

#define UPDATETICK 100                

#define RED_MULTIPLIER 0.09            
#define GREEN_MULTIPLIER 0.11            
#define BLUE_MULTIPLIER 0.18            

#define COLOUR_OFFSET -230            
                        
#define RED_ITERATIONS_LOWER 0
#define RED_ITERATIONS_UPPER 1000
#define GREEN_ITERATIONS_LOWER 0
#define GREEN_ITERATIONS_UPPER 1000
#define BLUE_ITERATIONS_LOWER 0
#define BLUE_ITERATIONS_UPPER 1000

#define SOURCE_LEFT_X -2.102613
#define SOURCE_RIGHT_X 1.200613
#define SOURCE_TOP_Y -1.237710
#define SOURCE_BOTTOM_Y 1.239710

#undef RANDOM_SOURCE

#define OPTIMISE    

#define reduce(foo) (foo)

////////////////////////////////////////////////////////////////////////////////////

void drawpath(double x, double y, double target_startx, double target_starty, double pixel_width);
double rnd (void);
void drawbmp (char * filename);

////////////////////////////////////////////////////////////////////////////////////

long long redcount[WIDTH][HEIGHT];
long long greencount[WIDTH][HEIGHT];
long long bluecount[WIDTH][HEIGHT];

int iterations;

double red_multiplier = RED_MULTIPLIER;
double green_multiplier = GREEN_MULTIPLIER;
double blue_multiplier = BLUE_MULTIPLIER;

////////////////////////////////////////////////////////////////////////////////////

int main (int argc, char * argv[]) {

    int i, j, n;            
    double x, y;            
    int source_column, source_row;    
    double r, s, nextr, nexts;    
    double x_jump, y_jump;        
    double target_startx, target_starty;
    double target_endx, target_endy;
    double pixel_width;        

    char filename[200];


    for (i = 0; i < WIDTH; i++)
    {
        for (j = 0; j < HEIGHT; j++)
        {
            redcount[i][j] = 0;
            greencount[i][j] = 0;
            bluecount[i][j] = 0;
        }
    }

    target_startx = CENTRE_X - ((double) WIDTH / (ZOOM * 2));
    target_endx = CENTRE_X + ((double) WIDTH / (ZOOM * 2));

    target_starty = CENTRE_Y - ((double) HEIGHT / (ZOOM * 2));
    target_endy = CENTRE_Y + ((double) HEIGHT / (ZOOM * 2));

    pixel_width = (target_endx - target_startx) / WIDTH;

    x_jump = ((double) SOURCE_RIGHT_X - SOURCE_LEFT_X) / SOURCE_COLUMNS;
    y_jump = ((double) SOURCE_BOTTOM_Y - SOURCE_TOP_Y) / SOURCE_ROWS;

    iterations = RED_ITERATIONS_UPPER;
    if (GREEN_ITERATIONS_UPPER > iterations) iterations = GREEN_ITERATIONS_UPPER;
    if (BLUE_ITERATIONS_UPPER > iterations) iterations = BLUE_ITERATIONS_UPPER;

    // Main bit...

    x = SOURCE_LEFT_X;
    for (source_column = 0; source_column < SOURCE_COLUMNS; source_column++, x += x_jump)
    {
        y = SOURCE_TOP_Y;
        for (source_row = 0; source_row < SOURCE_ROWS; source_row++, y += y_jump)
        {

#ifdef OPTIMISE
            if
            (
               (x >  -1.2 && x <=  -1.1 && y >  -0.1 && y < 0.1)
            || (x >  -1.1 && x <=  -0.9 && y >  -0.2 && y < 0.2)
            || (x >  -0.9 && x <=  -0.8 && y >  -0.1 && y < 0.1)
            || (x > -0.69 && x <= -0.61 && y >  -0.2 && y < 0.2)
            || (x > -0.61 && x <=  -0.5 && y > -0.37 && y < 0.37)
            || (x >  -0.5 && x <= -0.39 && y > -0.48 && y < 0.48)
            || (x > -0.39 && x <=  0.14 && y > -0.55 && y < 0.55)
            || (x >  0.14 && x <   0.29 && y > -0.42 && y < -0.07)
            || (x >  0.14 && x <   0.29 && y >  0.07 && y < 0.42)
            ) continue;
#endif
            r = 0; s = 0;
            for (n = 0; n <= iterations; n++)
            {
                nextr = ((r * r) - (s * s)) + x;
                 nexts = (2 * r * s) + y;
                r = nextr;
                s = nexts;
                if (n == iterations)
                {
                    // drawpath(x, y, target_startx, target_starty, pixel_width);
                    break;
                } else if ((r * r) + (s * s) > 4) {
                    drawpath(x, y, target_startx, target_starty, pixel_width);
                    break;
                }
            }
    
        }

        if (source_column % UPDATETICK == 0)
        {
            printf("Reached source column: %d of %d\n", source_column, SOURCE_COLUMNS);
        }

    }

    sprintf(filename, "%s r %d g %d b %d spp %d.bmp", OUTFILE, RED_ITERATIONS_UPPER, GREEN_ITERATIONS_UPPER, BLUE_ITERATIONS_UPPER, (SOURCE_COLUMNS / WIDTH) * (SOURCE_ROWS / HEIGHT));
    drawbmp(filename);

    printf("Done.\n");
    return 0;
}


void drawpath (double x, double y, double target_startx, double target_starty, double pixel_width)
{
    double r, s, nextr, nexts;
    int n;
    int xpixel, ypixel;

    r = 0; s = 0;
    for (n = 0; n <= iterations; n++)
    {
        nextr = ((r * r) - (s * s)) + x;
        nexts = (2 * r * s) + y;
        r = nextr;
        s = nexts;

        if ((r * r) + (s * s) > 4) return;

        xpixel = (r - target_startx) / pixel_width;
        ypixel = (s - target_starty) / pixel_width;
        if (xpixel > 0 && xpixel < WIDTH && ypixel > 0 && ypixel < HEIGHT)
        {
            if (n >= RED_ITERATIONS_LOWER && n <= RED_ITERATIONS_UPPER)
            {
                redcount[xpixel][ypixel] += 1;
            }
            if (n >= GREEN_ITERATIONS_LOWER && n <= GREEN_ITERATIONS_UPPER)
            {
                greencount[xpixel][ypixel] += 1;
            }
            if (n >= BLUE_ITERATIONS_LOWER && n <= BLUE_ITERATIONS_UPPER)
            {
                bluecount[xpixel][ypixel] += 1;
            }
        }

    }
    return;
}


void drawbmp (char * filename) {

unsigned int headers[13];
FILE * outfile;
int extrabytes;
int paddedsize;
int x; int y; int n;
int red, green, blue;

extrabytes = 4 - ((WIDTH * 3) % 4);             
                                               
                                               
if (extrabytes == 4)
   extrabytes = 0;

paddedsize = ((WIDTH * 3) + extrabytes) * HEIGHT;

// Headers...
// Note that the "BM" identifier in bytes 0 and 1 is NOT included in these "headers".
                 
headers[0]  = paddedsize + 54;  
headers[1]  = 0;                
headers[2]  = 54;               
headers[3]  = 40;             
headers[4]  = WIDTH;
headers[5]  = HEIGHT;



headers[7]  = 0;                    // biCompression
headers[8]  = paddedsize;           // biSizeImage
headers[9]  = 0;                    // biXPelsPerMeter
headers[10] = 0;                    // biYPelsPerMeter
headers[11] = 0;                    // biClrUsed
headers[12] = 0;                    // biClrImportant

outfile = fopen(filename, "wb");



fprintf(outfile, "BM");

for (n = 0; n <= 5; n++)
{
   fprintf(outfile, "%c", headers[n] & 0x000000FF);
   fprintf(outfile, "%c", (headers[n] & 0x0000FF00) >> 8);
   fprintf(outfile, "%c", (headers[n] & 0x00FF0000) >> 16);
   fprintf(outfile, "%c", (headers[n] & (unsigned int) 0xFF000000) >> 24);
}

// These next 4 characters are for the biPlanes and biBitCount fields.

fprintf(outfile, "%c", 1);
fprintf(outfile, "%c", 0);
fprintf(outfile, "%c", 24);
fprintf(outfile, "%c", 0);

for (n = 7; n <= 12; n++)
{
   fprintf(outfile, "%c", headers[n] & 0x000000FF);
   fprintf(outfile, "%c", (headers[n] & 0x0000FF00) >> 8);
   fprintf(outfile, "%c", (headers[n] & 0x00FF0000) >> 16);
   fprintf(outfile, "%c", (headers[n] & (unsigned int) 0xFF000000) >> 24);
}



for (y = HEIGHT - 1; y >= 0; y--)     // BMP image format is written from bottom to top...
{
   for (x = 0; x <= WIDTH - 1; x++)
   {

      red = reduce(redcount[x][y] + COLOUR_OFFSET) * red_multiplier;
      green = reduce(greencount[x][y] + COLOUR_OFFSET) * green_multiplier;
      blue = reduce(bluecount[x][y] + COLOUR_OFFSET) * blue_multiplier;
  
      if (red > 255) red = 255; if (red < 0) red = 0;
      if (green > 255) green = 255; if (green < 0) green = 0;
      if (blue > 255) blue = 255; if (blue < 0) blue = 0;
  
      // Also, it's written in (b,g,r) format...

      fprintf(outfile, "%c", blue);
      fprintf(outfile, "%c", green);
      fprintf(outfile, "%c", red);
   }
   if (extrabytes)      // See above - BMP lines must be of lengths divisible by 4.
   {
      for (n = 1; n <= extrabytes; n++)
      {
         fprintf(outfile, "%c", 0);
      }
   }
}

fclose(outfile);
return;
}

 

[saalek110]

مرور تا اینجا :
در قسمت فایل تکست :
نوشتن با fprintf و fputs
و خواندن با fscanf و fgets
و همچنین در تمرین دیگر با fgetc فایل تکست را خواندیم.
--------------------------
در قسمت فایل باینری با fwrite و fread یک استراکت را در فایل نوشتیم و خواندیم.



این هم مدهای باز کردن فایل به حالت تکست و باینری.
با خط قرمز باینری ها را جدا کردم. همان طور که می بینید مدهای باینری همه یک حرف b بهشان اضافه شده.

منبع عکس بالا

 

[saalek110]

در مثالها من سعی کردم سی پلاس نباشد و سی باشد. اگر شما به سی پلاس علاقه مند باشید مثالهایی با جستجو خواهید یافت.
علت این کار من این بود که مدتی من یک پروژه شخصی سی کار کرده ام و متمایل به سی بودم. ثانیا احتمالا اگر سی باشد در سی پلاس هم مورد قبول است.
پس از هدرهای زیر استفاده نکردم.

#include <iostream>
#include <fstream>

و از cout استفاده نکردم:

 cout<<"Error in creating file!!!";

خلق فایل به روش سی پلاس:

//C++ program to create a file.

#include <iostream>
#include <fstream>
using namespace std;
int main()
{
   fstream file; //object of fstream class
  
   //opening file "sample.txt" in out(write) mode
   file.open("sample.txt",ios::out);
  
   if(!file)
   {
       cout<<"Error in creating file!!!";
       return 0;
   }
  
   cout<<"File created successfully.";
  
   //closing the file
   file.close();
  
   return 0;
}

منبع
و تعدادی برنامه دیگر از همین سایت اینجا:
https://www.includehelp.com/cpp-programs/file-handling-examples.aspx

 

[saalek110]

شاید اینجا جایش نباشد ولی اشاره ای می کنم.
ساخت تابع های شخصی خودمان:
اول اینکه اگر بخواهیم تابع ما محلش بعد main باشد قبلش یک معرفی از تابع می نویسیم. مثل شکل زیر.
داخل main باید اسم تابع را بیاوریم تا صدا زده شود. مثل تابع addNumbers در زیر.
اگر تابع خروجی دارد در متغیری مانند sum می ریزیم. جلوی تابع نوشته int پس خروجی int دارد.
داخل پرانتز بعد نام تابع ورودی های تابع را نام برده. که موقع صدا زدن تابع باید ورودی ها را برای تابع ارسال کنیم.
تابع خروجی اش را با return پس فرستاده.

 

[saalek110]

این هم مثال عملی تر چون دیگه مثل قبلی ناقص نیست.
نگاه کنید متغیرها بالای صفحه تعریف شده اند. محل خاصی است. باید به دسترسی به متغیرها هم توجه کنید. در برنامه بالا می بینید تابع main متغیرهایی که در بالای برنامه تعریف شده را ارسال می کند به تابع product.


wikipedia
متغیرهای محلی (local)
متغیرهایی که در بدنه تابع معرفی می‌شوند، متغیرهای محلی هستند که فقط در همان تابعی که معرفی شده‌اند قابل استفاده هستند. پارامترهای تابع نیز که در عنوان تابع معرفی شده‌اند متغیرهای محلی هستند.

متغیرهای سراسری (global)
این متغیرها را می‌توان خارج از توابع مثلاً ابتدای برنامه قبل از تعریف تابع Main یا قبل از تعریف هر تابع دیگر معرفی کرد. متغیرهایی که خارج از توابع معرفی شوند، توسط کلیه توابعی که از آن به بعد تعریف شده‌اند، قابل استفاده‌اند.

پس از هر فراخوانی همین که اجرای تابع خاتمه یافت، متغیرهای محلی آن از بین می‌روند؛ ولی متغیرهای سراسری تا پایان اجرای تابع mainفعال و قابل استفاده‌اند.
سی (زبان برنامه‌نویسی) - ویکی‌پدیا، دانشنامهٔ آزاد

 

[saalek110]

این هم تابع مجذور. که حااصل ضرب عدد در خودش را پس می فرستد.
این برنامه ناقص است. چون معرفی تابع قبل main وجود ندارد.


-------------------------
یک مثال خیلی ساده:
معرفی تابع قبل main باید افزوده شود. و همچنین اینکلود کردن هدرهای مورد استفاده.

 

[saalek110]

وظیفه تابع آیا فقط ارسال خروجی است؟ نه. تابع می تواند خیلی خودسر باشد و خیلی چیزها را دستکاری کند. مثلا متغیرهای گلوبال پروژه را. یا مثلا با کاربر صحبت کند.یا خیلی کارهای دیگر.
ولی در بالا یک تابع روتین را از نظر ساختمانش بررسی کرده. تابعی که مداخله گر نیست و فقط به محاسبات و ارسال خروجی خود بسنده می کند.

 

[saalek110]

مسلما می توانیم توابع زیادی بسازیم. و main از همه آنها استفاده کند. در زیر دو تابع به main کمک می کنند.



توابع فوق void هستند و خروجی نمی فرستند. توابع بالا خودشان ماحصل کار خودشان را چاپ می کنند.
خوب این هم روشی است و گاهی مفید.
ولی تا می توانید از بی نظمی پروژه خود جلوگیری کنید. تا می توانید نظم ایجاد کنید و شرح بنویسید. راهنما برای خود و دیگران بنویسید.

 

[saalek110]

توابعی می سازید.
در فایلهای مختلفی قرار می دهید.
متغیرهای زیادی ممکن است داشته باشید.
اینها پروژه شما را تشکیل می دهد.

خوب است نقشه و دیاگرامی از پروژه خود داشته باشید. مثلا اتصالات توابع با هم نشان داده شود.

 

[saalek110]

Advantage of functions in C
There are the following advantages of C functions.

• By using functions, we can avoid rewriting same logic/code again and again in a program.
• We can call C functions any number of times in a program and from any place in a program.
• We can track a large C program easily when it is divided into multiple functions.
• Reusability is the main achievement of C functions.
• However, Function calling is always a overhead in a C program.

 

[saalek110]

ساختن هدر فایلهای خودمان:
How to write your own header file in C?
منبع
در فایلهای با پسوند h ما توابعی می سازیم و در در برنامه اصلی از آنها استفاده می کنیم.
کد زیر را در فایل با نام myhead.h ذخیره کنید.

void add(int a, int b)
{
    printf("Added value=%d\n", a + b);
}
void multiply(int a, int b)
{
    printf("Multiplied value=%d\n", a * b);
}

و برنامه اصلی:

#include <stdio.h>
#include "myhead.h"
int main()
{
    add(4, 6);

    /*This calls add function written in myhead.h
      and therefore no compilation error.*/
    multiply(5, 5);

    // Same for the multiply function in myhead.h
    printf("BYE!See you Soon");
    return 0;
}

گذاشتن نام هدر فایل myhead.h در دابل کوتیشن "" یعنی در همین فولدر دنبالش بگرد.

Output:

Added value:10
Multiplied value:25
BYE!See you Soon

 

[saalek110]

 

[saalek110]