About Ios::sync_with_stdio (false); and Cin.tie (0) accelerating C + + input and output streams

Original address: http://www.hankcs.com/program/cpp/cin-tie-with-sync_with_stdio-acceleration-input-and-output.html

Http://www.clanfei.com/2012/03/235.html

When I look at someone's ACM code on the Internet, I find others input and output statements are always scanf and printf, a little puzzled, think they use C language, rather than C + +, but do a question today (Sort):

Found with other online experts using the exact same method, using scanf and printf code submitted after accepted, while using CIN and cout time Limit exceeded, the code is as follows:

Code One (Accepted):

2. #include<iostream>
4. Using namespace std;
6. BOOL a[1000001];
8. int main()
10. {
12. int n, m, num, count;
14. While(scanf("%d%d",&n,&m)! =EOF) {
16. Memset(a, 0, sizeof(a));
18. For(int i=0; i<n; i+ +) {
20. scanf("%d",&num);
22. A[num + 500000] = 1;
24. }
26. Count = 0;
28. For(int J = 1000000; J >= 0; --J) {
30. If(a[J]) {
32. If(count = = m - 1) {
34. printf("%d\n",J-500000);
36. Break;
38. }
40. printf("%d",J-500000);
42. Count+ +;
44. }
46. }
48. }
50. Return 0;
52. }

Code two (time Limit exceeded):

2. #include<iostream>
4. Using namespace std;
6. BOOL a[1000001];
8. int main()
10. {
12. int n, m, num, count;
14. While(cin >> n >> m) {
16. Memset(a, 0, sizeof(a));
18. For(int i=0; i<n; i+ +) {
20. CIN >> num;
22. A[num + 500000] = 1;
24. }
26. Count = 0;
28. For(int J = 1000000; J >= 0; --J) {
30. If(a[J]) {
32. If(count = = m - 1) {
34. cout << J - 500000 << endl;
36. Break;
38. }
40. cout << J - 500000 << "";
42. Count+ +;
44. }
46. }
48. }
50. Return 0;
52. }

It can be seen that the code idea is exactly the same, but the input and output methods are different, asked the teacher, plus this code after the use of CIN and cout can also be accepted:

1. STD::ios::sync_with_stdio(false);

Baidu a bit, the original and cin,cout the reason is low efficiency, because the first thing to output to buffer, and then output, resulting in reduced efficiency, and this paragraph can be to eliminate iostream input and output cache, can save a lot of time, so that efficiency and scanf and printf, It should also be noted that the header files used by scanf and printf should be stdio.h instead of iostream.

I do not know this pair of functions to live today, before encountering Cin Tle always foolishly changed to scanf, and even believe that C + + in the IO aspect of inefficient nonsense, but this is only C + + to be compatible with C and take the conservative measures.

Tie

The tie is a function that binds two stream, and the null argument returns the current output stream pointer.

2. #include <iostream>
4. #include <fstream>
8. submain//////////////////////////////////
10. int main(int argc, char *argv[])
12. {
14. STD::ostream *prevstr;
16. STD::ofstream ofs;
18. OFS. Open("test.txt");
22. STD::cout << "Tie example:\n"; //Direct output to screen
26. *std::cin.  Tie() << "This was inserted into cout\n"; the//NULL parameter call returns the default output stream, which is cout
28. Prevstr = std::cin.  Tie(&ofs); //CIN binds OFS, returns the original output stream
30. *std::cin.  Tie() << "This was inserted into the file\n"; //OFS, output to file
32. STD::cin.  Tie(prevstr); //Recovery
36. OFS. Close();
38. System("pause");
40. Return 0;
42. }
44. End sub//////////////////////////////////

Output:

1. Tie Example:
2. This was inserted into cout
3. Please press any key to continue.  . .

Test.txt output at the same time in the current directory:

1. This was inserted into the file

Sync_with_stdio

This function is a "compatibility stdio" switch, C + + in order to be compatible with C, to ensure that the program in use of std::p rintf and std::cout without confusion, the output stream is tied together.

Application

In ACM, there is often a large data set that causes CIN tle. At this time most people (including the original I also) think this is CIN's inefficient scanf error, and even rise to the C language and C + + language implementation efficiency level of the boring debate. In fact, as stated above, this is only a conservative approach to C + + for compatibility. We can unbind stdio before IO, so be careful not to mix cout and printf at the same time.

By default, CIN binds to cout, and flush is called each time the << operator is executed, which increases the IO burden. The tie (0) (0 for null) can be used to unbind the CIN from the cout, further speeding up the execution efficiency.

As shown below:

2. #include <iostream>
4. int main()
6. {
8. STD::ios::sync_with_stdio(false);
10. STD::cin. Tie(0);
12. //IO
14. }

About Ios::sync_with_stdio (false); and Cin.tie (0) accelerating C + + input and output streams