Just throwing this out there, but the point of the exercise, coming near the beginning of the term as it does, is likely to see if the students understand and can use nested for loops.
In that context, Tweet's solution is probably the most appropriate since if the OP started using pointer arithmetic, when pointers have likely not been covered yet, would be a little suspect. Of course, he should have discussed the solution rather than just typing it in like that.
Equally of course, he should have used code tags...everyone knows this.
Pretty sure it wasn't in nested for loops, as they are totally unnecessary. I would say this was an assignment looking at array usage.
While I appreciate the comment, I don't recommend using any more time than I have trying to explain it was just a homework problem. Thanks though.
I especially like being called Tweet. Haha.
And on writing it out, yeah I agree. I felt for the guy, ever been in a similar situation? I'll just make sure not to do it again as per the mod lol.
Heh, sorry for the unintended tweaking (thank you, be here all week, tip your waitress) of you there...was too lazy to scroll and see what your username was.
Err, define "totally unnecessary".
And that could be, though by this time in the term I doubt they've covered enough control structures to do this another way than with a nested loop.
It isn't needed. You don't need any special control structure to handle the situation either. So long as you understand how an array works you can do this without using 2 for loops. (I sent a PM of the code that doesn't use a nested for loop to you.)
If it's the same code that declares and initializes a variable inside a for loop that you PM'ed me by mistake, don't worry, I'll still let you turn it in.
for (size_t i = 0; i < sizeof(stringToSearch); ++i)
{
// Convert the charactors to their uppercase equivelents.
char val = toupper(stringToSearch[i]);Just throwing this out there, but the point of the exercise, coming near the beginning of the term as it does, is likely to see if the students understand and can use nested for loops.
lol, you still can't say WHY that is bad. I've already given you a good explanation of why I use that function.
For those wondering, the code in question is this.
Code:for (size_t i = 0; i < sizeof(stringToSearch); ++i) { // Convert the charactors to their uppercase equivelents. char val = toupper(stringToSearch[i]);
Tweak doesn't like the fact that I use toupper. He thinks it is too costly and that just subtracting 32 from the character would have be much better.
It isn't needed. You don't need any special control structure to handle the situation either. So long as you understand how an array works you can do this without using 2 for loops. (I sent a PM of the code that doesn't use a nested for loop to you.)
Could also be to understand characters and their integer representation, which always gives beginners problems. In this case learning that (ch - 'a') gives values from 0 .. 25 and are an appropriate array index would be part of the lesson.
The typical double-nested loop homework is matrix math or various types of sorting. This one feels more like realizing that ASCII is just a number to a computer. Hard to tell without additional context,though.
Looks good, though the use of memset, size_t and sizeof() would likely rule it out for OP, you could do those less efficiently using things the OP probably *has* learned.
I was objecting to what sounded like a blanket statement that nested loops are totally unnecessary.
And the problem is with it being IN the for loop. You just declared a variable N times (length of the string) for no good reason. This takes up space.
No it doesn't. Any good compiler is going to keep the intermediate result in a register (if I'm guessing the rest of the function correctly).
What is wrong with using "another function". You still haven't explained why that is bad. Programming with functions is a fact of life.Actually I didn't have an issue with TOUPPER, again you don't understand what I'm saying. I told you I wouldn't have used toupper simply because its another function, not because its slow and retarded like all the code I write.
And the problem is with it being IN the for loop. You just declared a variable N times (length of the string) for no good reason. This takes up space. Put the declaration of val outside the for loop to avoid this wasted space.
Thanks.
EDIT:
Also you spelled "equivalents" and "characters" wrong, lol.
No it doesn't. Any good compiler is going to keep the intermediate result in a register (if I'm guessing the rest of the function correctly). Even if it has to spill the result it'll still just use 1 stack slot in either case. It's not like there's a 1 to 1 correlation that the running code creates memory every time it sees "char val" in the loop begin run. Even dumb compilers are way beyond that.
And the problem is with it being IN the for loop. You just declared a variable N times (length of the string) for no good reason. This takes up space. Put the declaration of val outside the for loop to avoid this wasted space.
for (int i = 0; i < 100; i++) {
int j = i;
}int j;
for (int i = 0; i < 100; i++) {
j = i;
}What is wrong with using "another function". You still haven't explained why that is bad. Programming with functions is a fact of life.
As for the using more memory, you really don't understand what happens the compiler, do you.
var being declared inside a loop doesn't mean that each time the loop restarts it is being smashed, on the contrary, that memory location is saved and reused each time the loop restarts By declaring it inside the loop, I have caused my program to use less memory, because when the loop exits that location in the stack is freed up. Declaring it outside the loop would have resulted in a higher memory usage because it couldn't be removed from the stack until the end of the function.
Even that in mind, the compiler is smart enough to see that this variable that is only used inside the loop is used frequently inside the loop, it doesn't allocate any memory and instead uses a GP register to store the results of the function. In other words, it doesn't even touch the stack. Had it been declared outside of the loop, however, I couldn't have guaranteed that that register wouldn't have eventually been stored in the stack after the loop finished.
As for the spelling issues, yep, I suck at spelling.
Of course it isn't a code problem, it's a compiler problem rofl.
int count_char(const char *stringToSearch, int letterCounts[26])
{
for (size_t i = 0; stringToSearch[i]; ++i)
{
// Convert the charactors to their uppercase equivelents.
int val = toupper(stringToSearch[i]);
letterCounts[val - 'A'] += 1;
}
return 0;
}_Z10count_charPKcPi:
.fnstart
.LFB12:
@ args = 0, pretend = 0, frame = 0
@ frame_needed = 0, uses_anonymous_args = 0
stmfd sp!, {r3, r4, r5, lr}
.save {r3, r4, r5, lr}
mov r5, r0
mov r4, r1
ldrb r0, [r0, #0] @ zero_extendqisi2
cmp r0, #0
beq .L2
.L3:
bl toupper
sub r0, r0, #65
ldr r3, [r4, r0, asl #2]
add r3, r3, #1
str r3, [r4, r0, asl #2]
ldrb r0, [r5, #1]! @ zero_extendqisi2
cmp r0, #0
bne .L3
.L2:
mov r0, #0
ldmfd sp!, {r3, r4, r5, pc}
.fnendIt's not a problem at all, except that what you think will happen doesn't actually exist.
Code:int count_char(const char *stringToSearch, int letterCounts[26]) { for (size_t i = 0; stringToSearch[i]; ++i) { // Convert the charactors to their uppercase equivelents. int val = toupper(stringToSearch[i]); letterCounts[val - 'A'] += 1; } return 0; }
With gcc -O :
Code:_Z10count_charPKcPi: .fnstart .LFB12: @ args = 0, pretend = 0, frame = 0 @ frame_needed = 0, uses_anonymous_args = 0 stmfd sp!, {r3, r4, r5, lr} .save {r3, r4, r5, lr} mov r5, r0 mov r4, r1 ldrb r0, [r0, #0] @ zero_extendqisi2 cmp r0, #0 beq .L2 .L3: bl toupper sub r0, r0, #65 ldr r3, [r4, r0, asl #2] add r3, r3, #1 str r3, [r4, r0, asl #2] ldrb r0, [r5, #1]! @ zero_extendqisi2 cmp r0, #0 bne .L3 .L2: mov r0, #0 ldmfd sp!, {r3, r4, r5, pc} .fnend
Show me where the code is adding extra space each time through the loop. Here's a hint : it isn't. It uses the same register to store the result of toupper each time. It pushes a few regs at the start of the function and doesn't touch the stack pointer until the end. Memory and register use is constant regardless of the size of the string - there's nothing changing there at all if the string is 1 or a million characters long.