c語言坑之printf緩沖區

阿新 • • 發佈：2017-05-06

tail multiply out ack splay 一次 fin eof lan

 1 #include <stdio.h>
 2 #include <pthread.h>
 3 #include <semaphore.h>
 4 #include <unistd.h>
 5 #define MAXSTACK 100
 6 int stack[MAXSTACK][2];
 7 int size = 0;
 8 sem_t sem;
 9 /* 從文件1.dat讀取數據，每讀一次，信號量加一*/
10 void* ReadData1(void*)
11 {
12     FILE *fp = fopen("1.dat", "r");
13 
     if (fp == NULL) 
14     {
15         printf("open 1.dat failed!");
16         return NULL;
17     }
18     while (!feof(fp))
19     {
20         fscanf(fp, "%d%d", &stack[size][0], &stack[size][1]);
21         sem_post(&sem);
22         ++size;
23     }
24     fclose(fp);
25 }
26 /*從文件2.dat讀取數據 
*/
27 void* ReadData2(void*)
28 {
29     FILE *fp = fopen("2.dat", "r");
30     if (fp == NULL) 
31     {
32         printf("open 2.dat failed!");
33         return NULL;
34     }
35     while (!feof(fp))
36     {
37         fscanf(fp, "%d%d", &stack[size][0], &stack[size][1]);
38         sem_post(&sem);
 
39         ++size;
40     }
41     fclose(fp);
42 }
43 /*阻塞等待緩沖區有數據，讀取數據後，釋放空間，繼續等待*/
44 void *HandleData1(void *)
45 {
46     while (1)
47     {
48         if (sem_trywait(&sem)<0) continue;
49         printf("Plus:%d+%d=%dn", stack[size][0], stack[size][1],stack[size][0] + stack[size][1]);
50         --size;
51     }
52 }
53 
54 void *HandleData2(void*)
55 {
56     while (1)
57     {
58         sem_wait(&sem);
59         printf("Multiply:%d*%d=%dn", stack[size][0], stack[size][1],stack[size][0] * stack[size][1]);
60         --size;
61     }
62 }
63 int main(void)
64 {
65     pthread_t t1, t2, t3, t4;
66     sem_init(&sem, 0, 0);
67     pthread_create(&t1, NULL, HandleData1, NULL);
68     pthread_create(&t2, NULL, HandleData2, NULL);
69     pthread_create(&t3, NULL, ReadData1, NULL);
70     pthread_create(&t4, NULL, ReadData2, NULL);
71     //usleep(1000);
72     //fflush(stdout);
73     /* 防止程序過早退出，讓它在此無限期等待*/
74     pthread_join(t1, NULL);
75 }

printf沒輸出

 1 #include <stdio.h>
 2 #include <pthread.h>
 3 #include <semaphore.h>
 4 #include <unistd.h>
 5 #define MAXSTACK 100
 6 int stack[MAXSTACK][2];
 7 int size = 0;
 8 sem_t sem;
 9 /* 從文件1.dat讀取數據，每讀一次，信號量加一*/
10 void* ReadData1(void*)
11 {
12     FILE *fp = fopen("1.dat", "r");
13     if (fp == NULL) 
14     {
15         printf("open 1.dat failed!");
16         return NULL;
17     }
18     while (!feof(fp))
19     {
20         fscanf(fp, "%d%d", &stack[size][0], &stack[size][1]);
21         sem_post(&sem);
22         ++size;
23     }
24     fclose(fp);
25 }
26 /*從文件2.dat讀取數據*/
27 void* ReadData2(void*)
28 {
29     FILE *fp = fopen("2.dat", "r");
30     if (fp == NULL) 
31     {
32         printf("open 2.dat failed!");
33         return NULL;
34     }
35     while (!feof(fp))
36     {
37         fscanf(fp, "%d%d", &stack[size][0], &stack[size][1]);
38         sem_post(&sem);
39         ++size;
40     }
41     fclose(fp);
42 }
43 /*阻塞等待緩沖區有數據，讀取數據後，釋放空間，繼續等待*/
44 void *HandleData1(void *)
45 {
46     while (1)
47     {
48         //if (sem_trywait(&sem)<0) continue;
49         sem_wait(&sem);
50         printf("Plus:%d+%d=%d\n", stack[size][0], stack[size][1],stack[size][0] + stack[size][1]);
51         --size;
52     }
53 }
54 
55 void *HandleData2(void*)
56 {
57     while (1)
58     {
59         sem_wait(&sem);
60         printf("Multiply:%d*%d=%d\n", stack[size][0], stack[size][1],stack[size][0] * stack[size][1]);
61         --size;
62     }
63 }
64 int main(void)
65 {
66     pthread_t t1, t2, t3, t4;
67     sem_init(&sem, 0, 0);
68     pthread_create(&t1, NULL, HandleData1, NULL);
69     pthread_create(&t2, NULL, HandleData2, NULL);
70     pthread_create(&t3, NULL, ReadData1, NULL);
71     pthread_create(&t4, NULL, ReadData2, NULL);
72     //usleep(1000);
73     //fflush(stdout);
74     /* 防止程序過早退出，讓它在此無限期等待*/
75     pthread_join(t1, NULL);
76 }

printf有輸出(\n) 技術分享

 1 #include <stdio.h>
 2 #include <pthread.h>
 3 #include <semaphore.h>
 4 #include <unistd.h>
 5 #define MAXSTACK 100
 6 int stack[MAXSTACK][2];
 7 int size = 0;
 8 sem_t sem;
 9 /* 從文件1.dat讀取數據，每讀一次，信號量加一*/
10 void* ReadData1(void*)
11 {
12     FILE *fp = fopen("1.dat", "r");
13     if (fp == NULL) 
14     {
15         printf("open 1.dat failed!");
16         return NULL;
17     }
18     while (!feof(fp))
19     {
20         fscanf(fp, "%d%d", &stack[size][0], &stack[size][1]);
21         sem_post(&sem);
22         ++size;
23     }
24     fclose(fp);
25 }
26 /*從文件2.dat讀取數據*/
27 void* ReadData2(void*)
28 {
29     FILE *fp = fopen("2.dat", "r");
30     if (fp == NULL) 
31     {
32         printf("open 2.dat failed!");
33         return NULL;
34     }
35     while (!feof(fp))
36     {
37         fscanf(fp, "%d%d", &stack[size][0], &stack[size][1]);
38         sem_post(&sem);
39         ++size;
40     }
41     fclose(fp);
42 }
43 /*阻塞等待緩沖區有數據，讀取數據後，釋放空間，繼續等待*/
44 void *HandleData1(void *)
45 {
46     while (1)
47     {
48         //if (sem_trywait(&sem)<0) continue;
49         sem_wait(&sem);
50         printf("Plus:%d+%d=%d\n", stack[size][0], stack[size][1],stack[size][0] + stack[size][1]);
51         --size;
52     }
53 }
54 
55 void *HandleData2(void*)
56 {
57     while (1)
58     {
59         sem_wait(&sem);
60         printf("Multiply:%d*%d=%d\n", stack[size][0], stack[size][1],stack[size][0] * stack[size][1]);
61         --size;
62     }
63 }
64 int main(void)
65 {
66     pthread_t t1, t2, t3, t4;
67     sem_init(&sem, 0, 0);
68     pthread_create(&t1, NULL, HandleData1, NULL);
69     pthread_create(&t2, NULL, HandleData2, NULL);
70     pthread_create(&t3, NULL, ReadData1, NULL);
71     pthread_create(&t4, NULL, ReadData2, NULL);
72     //usleep(1000);
73     //fflush(stdout);
74     /* 防止程序過早退出，讓它在此無限期等待*/
75     pthread_join(t1, NULL);
76 }

printf有輸出(main正常結束) 技術分享

 1 #include <stdio.h>
 2 #include <pthread.h>
 3 #include <semaphore.h>
 4 #include <unistd.h>
 5 #define MAXSTACK 100
 6 int stack[MAXSTACK][2];
 7 int size = 0;
 8 sem_t sem;
 9 /* 從文件1.dat讀取數據，每讀一次，信號量加一*/
10 void* ReadData1(void*)
11 {
12     FILE *fp = fopen("1.dat", "r");
13     if (fp == NULL) 
14     {
15         printf("open 1.dat failed!");
16         return NULL;
17     }
18     while (!feof(fp))
19     {
20         fscanf(fp, "%d%d", &stack[size][0], &stack[size][1]);
21         sem_post(&sem);
22         ++size;
23     }
24     fclose(fp);
25 }
26 /*從文件2.dat讀取數據*/
27 void* ReadData2(void*)
28 {
29     FILE *fp = fopen("2.dat", "r");
30     if (fp == NULL) 
31     {
32         printf("open 2.dat failed!");
33         return NULL;
34     }
35     while (!feof(fp))
36     {
37         fscanf(fp, "%d%d", &stack[size][0], &stack[size][1]);
38         sem_post(&sem);
39         ++size;
40     }
41     fclose(fp);
42 }
43 /*阻塞等待緩沖區有數據，讀取數據後，釋放空間，繼續等待*/
44 void *HandleData1(void *)
45 {
46     while (1)
47     {
48         //if (sem_trywait(&sem)<0) continue;
49         sem_wait(&sem);
50         printf("Plus:%d+%d=%dn", stack[size][0], stack[size][1],stack[size][0] + stack[size][1]);
51         --size;
52     }
53 }
54 
55 void *HandleData2(void*)
56 {
57     while (1)
58     {
59         sem_wait(&sem);
60         printf("Multiply:%d*%d=%dn", stack[size][0], stack[size][1],stack[size][0] * stack[size][1]);
61         --size;
62     }
63 }
64 int main(void)
65 {
66     pthread_t t1, t2, t3, t4;
67     sem_init(&sem, 0, 0);
68     pthread_create(&t1, NULL, HandleData1, NULL);
69     pthread_create(&t2, NULL, HandleData2, NULL);
70     pthread_create(&t3, NULL, ReadData1, NULL);
71     pthread_create(&t4, NULL, ReadData2, NULL);
72     usleep(1000);
73     fflush(stdout);
74     /* 防止程序過早退出，讓它在此無限期等待*/
75     pthread_join(t1, NULL);
76 }

printf有輸出(fflush)

printf行緩沖區的分析總結

c語言坑之printf緩沖區

tail multiply out ack splay 一次 fin eof lan 1 #include <stdio.h> 2 #include <pthread.h> 3 #include <semaphore.h> 4

(原創)攻擊方式學習之(3) - 緩沖區溢出(Buffer Overflow)

信息進行 adding 操作 return 錯誤 com 兩個 it! 堆棧溢出堆棧溢出通常是所有的緩沖區溢出中最容易進行利用的。了解堆棧溢出之前，先了解以下幾個概念：緩沖區簡單說來是一塊連續的計算機內存區域，可以保存相同數據類型的多個實例。堆棧

字符流緩沖區原理之裝飾模式

turn dem append ngs except new public lin ktr import java.io.FileReader;import java.io.IOException;import java.io.Reader; /** 模擬字符流緩沖區 r

字節流緩沖區BufferedInputStream原理之裝飾模式

問題 throws 方法思考字節 run extend main err import java.io.BufferedInputStream;import java.io.BufferedOutputStream;import java.io.FileInputStr

字符流緩沖區的增強類LineNumberReader之裝飾模式

stack per txt all auto tac 獲得 throw number import java.io.BufferedReader;import java.io.FileReader;import java.io.IOException;import java

C 標準庫IO緩沖區和內核緩沖區的區別

io緩沖區 lose 信息同一文件 upload 同步 load IT 覆蓋 1.C標準庫的I/O緩沖區 UNIX的傳統是Everything is a file,鍵盤、顯示器、串口、磁盤等設備在/dev 目錄下都有一個特殊的設備文件與之對應,這些設

windows下簡單的緩沖區溢出之slmail

經典問題 shell ever 圖片 ttl 0x0d orm 設置斷點緩沖區溢出是什麽？當緩沖區邊界限制不嚴格時，由於變量傳入畸形數據或程序運行錯誤，導致緩沖區被“撐暴”，從而覆蓋了相鄰內存區域的數據成功修改內存數據，可造成進程劫持，執行惡意代碼，獲取服務器控制權

Java NIO之緩沖區

打印機控制器 I/O limit 符號 mat write spa int() 簡介 IO概念緩沖區操作虛擬內存文件IO 流IO 緩沖區 Buffer屬性 Buffer數據填充、翻轉、釋放、壓縮、標記 Buffer比較 Buffer批量移

標準c庫函數與Linux下系統函數庫區別（即帶不帶緩沖區的學習）

實現使用調用 pre 庫函數緩沖區覆蓋發現 num 我們都知道，C語言在UNIX/Linux系統下有一套系統調用（系統函數），比如文件操作open()、close()、write()、read()等，而標準C語言的庫函數中也有一套對文件的操作函數fopen()、f

C++輸入流和輸出流、緩沖區

一個驅動器掌握輸入數據 tle 處理字符串輸出格式效率一、C++輸入流和輸出流輸入和輸出的概念是相對程序而言的。鍵盤輸入數據到程序叫標準輸入，程序數據輸出到顯示器叫標準輸出，標準輸入和標準輸出統稱為標準I/O，文件的輸入和輸出叫文件I/O。 co

#C語言學習感悟# printf( )函式中的回車‘\r’與回車換行'\n'之我見。

今天完成了初級階段的學習，其實以前在開發微控制器的時候用過C語言，但是沒有系統的學過，所以再次學習感覺能夠查缺補漏。C語言中的printf( )函式是一個很重要的函式。printf( )中的字元包含了三種：（1）以%開頭的格式控制字元（2）以 \ 開頭的轉義字元（3）普通字元

ORA-22835 緩沖區對於 CLOB 到 CHAR 轉換或 BLOB 到 RAW 轉換而言太小

eric func 註釋 turn 替換異常 bms .get erl 在使用Oralce時，直接取出 CLOB 到 CHAR 轉換或 BLOB 到 RAW 轉換時，會出現ORA-22835的異常，以下是個人的解決方案 1 create or replace Fun

內存緩沖區解析

sys com 錯誤信息 set while 通過數據 mode bsp 一.緩沖區顧名思義即為：內存中開辟的一片緩沖區域　　按類型分為：全緩沖，行緩沖，不帶緩沖　　可以通過標準庫函數setvbuf(_Inout_ FILE * _File, _Inout_updates

socket緩沖區以及阻塞模式

eof print sym 生成長度下一步獲取輸入緩沖 func 在《socket數據的接收和發送》一節中講到，可以使用 write()/send() 函數發送數據，使用 read()/recv() 函數接收數據，本節就來看看數據是如何傳遞的。 socket緩沖區

IO中關於自定義緩沖區和使用默認緩沖區哪個效率更高的對比

buffered code rtti rtt 測試 iso ndt end oid //自己測試了一個3.8G的文件，有興趣的可以自己試試看，初學java寫的不對的地方希望大家能指出，有疑問可以留言一起探討，謝謝！ 1 package cn.String.Day.IO;

緩沖區溢出

內存 system ron article 數據包解決動態分配語言 fan 原理：通過往程序的緩沖區寫超出其長度的內容，造成緩沖區的溢出，從而破壞程序的堆棧，造成程序崩潰或使程序轉而執行其它指令，以達到攻擊的目的。造成緩沖區溢出的原因是程序中沒有仔細檢查用戶輸入的參數

像素緩沖區對象PBO 記錄

blog fbo clas 另一個過程 unpack 所有 nbsp ubi 像素緩沖區對象PBO 記錄和所有的緩沖區對象一樣，它們都存儲在GPU內存中，我們可以訪問和填充PBO，方法和其他的緩沖區一樣。當一個PBO被綁定到GL_PIXEL_PACK_BUFFER

AE二次開發中幾個功能速成歸納（符號設計器、創建要素、圖形編輯、屬性表編輯、緩沖區分析）

文件夾路徑及其基本框架 option 開啟 rgs database ets remove /* * 實習課上講進階功能所用文檔，因為趕時間從網上抄抄改改，湊合能用，記錄一下以備個人後用。 * * --------------------------------

ob 緩沖區常用函數集錦

常用 res output all 需要 family iter ob_start -s ob_start(); //打開一個輸出緩沖區，所有的輸出信息不再直接發送到瀏覽器，而是保存在輸出緩沖區裏面。 ob_clean(); //

JavaNIO緩沖區

rewind() junit author sys 讀取是否不同標記存儲 package com.nio.test; import java.nio.ByteBuffer; import org.junit.Test; /** * * @author

c語言坑之printf緩沖區

相關推薦