StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PO
primarykey
Id
19065567
data
AcceptedAnswerId
0
AnswerCount
0
ClosedDate
CommentCount
2
CommunityOwnedDate
CreationDate
2013-09-28T09:47:20.750
FavoriteCount
0
LastActivityDate
2013-09-28T09:47:20.750
LastEditDate
LastEditorUserId
0
OwnerUserId
956880
ParentId
19048667
PostTypeId
2
Score
0
ViewCount
0
LastEditorDisplayName
text
Body
Here we face 2 blocks of code. <ul> <li>A large block of code that is designed to take an array and work through it. </li> <li>A piece of code which uses previous block of code with some data.</li> </ul> Structure your code. The large block of code should be a function possibly divided in several subfunctions. The other piece of code will call to this function. Parameters of the function. Array or single char. <pre><code> (a) void work( char c ); (b) void work( char& c ); (c) void work( const char v[], size_t size); (d) void work( char v[], size_t size); </code></pre> Options (a) and (b) should be used if the kind of work makes no sense for an array. Which is not the case. Options (c) and (d) should be used if work makes sense for an array. So use an array. Variable which holds the data. Array or single char. If you only need to hold a single char then use a single non-array char. You can still call the array function. <pre><code>char c; c = 'b'; work( &c, 1 ); ////// char a[1]; a[0] = 'b'; work( a, 1 ); </code></pre> The work function sees the single variable and the array as an array of size 1. Code will work fine in both cases and with no efficiency concerns. Testing Let's see if real code holds my previous statements. <pre><code>#include <iostream> #include <ctime> #include <vector> #include <cstddef> #include <chrono> using namespace std; unsigned long miliTime() { return std::chrono::system_clock::now().time_since_epoch() / std::chrono::milliseconds(1); } // An hypotetical work function with arrays void workArray( char v[], size_t size ) { for ( size_t n=0; n<size; ++n ) { // large block of code for ( int i=0; i<1000; ++i ) { v[n] += 3 + i; if (v[n] == '3' ) v[n] = 'J' - v[n]; v[n] = toupper( v[n] ) + '-'; } } } // Same function just for a single character void workSingle( char& c ) { // large block of code for ( int i=0; i<1000; ++i ) { c += 3 + i; if (c == '3' ) c = 'J' - c; c = toupper( c ) + '-'; } } int main(void) { const long int repeats =1000000; long int n; unsigned long start; double dif; start = miliTime(); char c; c = 'b'; for ( n=0; n<repeats; ++n) workArray( &c, 1 ); dif = miliTime() - start; cout << "Result = " << c << endl; cout << "Non-array var passed to array code = " << dif << " ms" << endl; start = miliTime(); char a[1]; a[0] = 'b'; for ( n=0; n<repeats; ++n) workArray( a, 1 ); dif = miliTime() - start; cout << "Result = " << a[0] << endl; cout << "Array var passed to array code = " << dif << "ms" << endl; start = miliTime(); char c2; c2 = 'b'; for ( n=0; n<repeats; ++n) workSingle( c2 ); dif = miliTime() - start; cout << "Result = " << c2 << endl; cout << "Non-array var passed to non-array code = " << dif << "ms" << endl; start = miliTime(); char a2[1]; a2[0] = 'b'; for ( n=0; n<repeats; ++n) workSingle( a2[0] ); dif = miliTime() - start; cout << "Result = " << a2[0] << endl; cout << "Array var passed to non-array code = " << dif << "ms" << endl; } </code></pre> When compiled under gcc-4.7 with this command line and executed in my computer : <pre><code>g++ -O2 -Wall -std=c++11 x.cpp -o x.out && ./x.out </code></pre> I get this output : Result = z Non-array var passed to array code = 5520 ms Result = z Array var passed to array code = 5515ms Result = z Non-array var passed to non-array code = 5203ms Result = z Array var passed to non-array code = 5203ms As expected the result is always the same. There is no significative difference in passing an array or a non-array variable to the work function for both implementations. workSingle is 6% faster than workArray. The execution of the outer loop (which does not exist in workSingle) is unlikely to be the cause since the inner loop executes 1000 times. The cause is probably due to access to v[n] being slower than access to c due to the indirection. Though if you change the 1000 in the inner loop for a global variable read from std::cin then workSingle actually gives slower times than workArray! Some kind of optimizations, cache misses or other low level stuff may be the cause. I would not sacrifice the reusability of workArray for the uncertain efficiency of workSingle unless time is so critical that you are willing to go to assembly level. Conclusion. Declare your variable as non-array since it only has to hold a single character. Implement your large section of code as a function that takes an array parameter. Possibly divided in several subsections if its so large.
Tags
Title
singulars
PostAcceptedAnswerId
1. This table or related slice is empty.
PostParentId
1. POWhat happens to array[1]
 singulars
 PostTypePostTypeId
 PTQuestion
PostTypePostTypeId
1. PTAnswer
UserLastEditorUserId
1. This table or related slice is empty.
UserOwnerUserId
1. USJose Antonio Dura Olmos
plurals
PostLinksPostIdRelatedPostId
1. This table or related slice is empty.
PostLinksRelatedPostIdPostId
1. This table or related slice is empty.
PostsAcceptedAnswerId
1. This table or related slice is empty.
PostsParentIdCreationDate
1. This table or related slice is empty.
VotesPostIdCreationDate
1. This table or related slice is empty.
CommentsPostId
1. COI would never, ever use option (b) because I don't expect `work(foo)` to modify foo. This is a landmine for readers not familiar with the inner workings of `work()`. If you want to modify an argument, say so and ask for a pointer with `void work(char* c);`; `work(&foo)` clearly tells the reader that he should expect foo to change.
 singulars
 PostPostId
 PO
 UserUserId
 UScmaster
2. CONo, work(&foo) does not tell the reader he should expect foo to change. You need to check the function declaration and documentation for that. Consider void( const char* foo). And pass by reference rather than by pointer is the common way to pass IN-OUT parameters in C++.
 singulars
 PostPostId
 PO
 UserUserId
 USJose Antonio Dura Olmos

Querying!

Guidance

A row detail

Detail views are divided into sections. All the information in the data section comes from columns in the selected row. The other sections display data from other, related rows.

Related data can be related in a to-one or a to-many fashion. Captions of data related in a to-many fashion link to a list view showing a filtered view of the table.

Try moving around until you find a non-empty to-many entry and click on the label to get to one. You can move back to the root by clicking on the database name in the header.