Is there perhaps some other, better way to do it? Perhaps one with which clang doesn't give me "unused result" warnings?

MODS: If you deem it inappropriate for me to continuously ask for guidance here, please let me know. 😊

#include <stdio.h>  

void executechoice(int choice);		
void printsavedpins(int pin_storage[]);  
void promptnewpin(void);  
void checkpinlength(int pin);  
void checkpinmatch(int pin);  
void updatepinstorage(int pin);  

int pin = 0;  
int pin_storage[10] = {0};  
int storage_index = 0;  
const int storage_limit = 10;  

//Prompt user for action.  
int main() {  

	int choice = 0;  
	printf("What would you like to do? (V)iew your saved pins, (S)ave a new pin or (E)xit? "); 
	while ((choice = getchar()) != EOF) {  
		getchar(); //clang gives 'unused result' warning but '\n' needs to be removed.  
		if (choice == 'E' || choice == 'e') { break; }  
		else {  
			executechoice(choice);  
			getchar(); //clang gives 'unused result' warning but '\n' needs to be removed.  
			printf("What would you like to do next? (V)iew your saved pins, (S)ave a new pin or (E)xit? ");  
		}  
	}  
	printf("Goodbye!\n");  
	return 0;  
}  

//Function definitions  
void executechoice(int choice) {		
	if (choice == 'V' || choice == 'v') { printsavedpins(pin_storage); }  
	else if (choice == 'S' || choice == 's') { promptnewpin(); }  
	else { printf("Invalid choice! What would you like to do? (V)iew your saved pins, (S)ave a new pin or (E)xit? "); }  
}  

void printsavedpins(int pin_storage[]) {  
	for (int i = 0; i < storage_limit; i++) printf("Pin %d: %d\n", i + 1, pin_storage[i]);  
}  

void promptnewpin(void) {  
	
	printf("Enter new pin: ");  
	scanf("%d", &pin);  
	checkpinlength(pin);  
}  

void checkpinlength(int pin) {  
	
	if (pin < 1000*100) {  
		printf("Pin has to be at least six digits!\n");  
		promptnewpin();  
	}  
	else checkpinmatch(pin);  
}  

void checkpinmatch(int pin) {  

	int check = 0;  
	printf("Verify your new pin: ");  
	scanf("%d", &check);  
	if (check != pin) {  
		printf("Mismatch! ");  
		promptnewpin();  
	}  
	else updatepinstorage(pin);  
}  

void updatepinstorage(int pin) {  

	pin_storage[storage_index] = pin;  
	storage_index++;  
	if (storage_index >= storage_limit) { storage_index = 0; }  
	printf("New pin saved successfully!\n");  
}  

Good day! How are you this gloomy, rainy afternoon?

I just realized - through experimentation, naturally 😂 - that I can return whole printf()s into main. Mind blowing. Anyway, I would much appreciate any input on how to write my leapYear function more aesthetically pleasing. I tried slapping the printf statements at the end of leapYear or at the end of each if statement. Still feels repetitive...

Also, as it stands, I'm having leapYear return int as per the declaration and definition. But I am returning printf() statements. Why does this work? I know that, for instance, char is int under the hood, using the machine's underlying character table, for instance ASCII. Is the explanaition something similar to this?

Thank you in advance! 😊

#include <stdio.h>  
#include <string.h>  

int leapYear(int year);  

int main() {  

	int year = 0;  

	printf("Enter the year that you would like to check and press ENTER: ");  
	
	scanf("%d", &year);  
	leapYear(year);  
	
	return 0;  
}  

int leapYear(int year) {  

	char wasiswill[12] = "";  

    	if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {  
	    	if (year < 2026) strcpy(wasiswill,"was");  
	    	if (year == 2026) strcpy(wasiswill, "is");  
        	if (year > 2026) strcpy(wasiswill, "will be");  
  	        goto EXIT_LEAP;  
	}  
	else {  
		if (year < 2026) {  
			strcpy(wasiswill,"was");  
			goto EXIT_NLEAP1;  
		}  
		else if (year == 2026) {  
			strcpy(wasiswill, "is");  
			goto EXIT_NLEAP2;  
		}  
		else if (year > 2026) {  
			strcpy(wasiswill, "will not be");  
			goto EXIT_NLEAP3;  
		}  
	}  
EXIT_LEAP: return printf("%d %s a leap year.\n", year, wasiswill);  
EXIT_NLEAP1: return printf("%d %s not a leap year.\n", year, wasiswill);  
EXIT_NLEAP2: return printf("%d %s not a leap year.\n", year, wasiswill);  
EXIT_NLEAP3: return printf("%d %s a leap year.\n", year, wasiswill);  
}  

Thank you all for your kind, patient and educative responses when I obnoxiously post amateur questions! 💙 While I cannot make any promises because of how my brain works, I am almost ready to continue reading The C Programming Language, 2nd Edition. I just want to experiment a little bit with error handling, specifically how to handle wrong input (char VS. int, etc.) and also to learn to indentify code that runs the risk of overflow/underflow.

Question: what errors do you recommend checking for and handling?

Meanwhile, thank you all! 🥰

#include <stdio.h>  

//Function declarations  
int newPin();  
int checkPin(int i);  

//Program that prompts for, verifies and saves pins temporarily into an array  
int main() {  

	//New pin  
	int pin = 0;  

	//History  
	int history[10] = {0,0,0,0,0,0,0,0,0,0};  
	int history_limit = 10;  
	int history_index = 0;  

	printf("Hello there! What would you like to do? (V)iew your saved pins, (S)ave a new pin or (E)xit: ");  
	int choice = 0;  
	while ((choice = getchar()) != EOF) {  
		switch (choice) {  
			case ('V'): { //Display saved pins  
				printf("\nYour saved pins are:\n\n");  
				for (int i = 0; i < history_limit; i++) printf("%d\n", history[i]);  
				printf("\nWhat would you like to do next? (V)iew your saved pins, (S)ave a new pin or (E)xit: ");  
				break;  
			}  
			case('S'): { //Prompt for and verify newly entered pin  
				pin = newPin();  
				if (checkPin(pin) == pin) {  
					history[history_index] = pin;  
					history_index++;  
					if (history_index >= history_limit) history_index = 0;  
				}  
				break;  
			}  
			case ('E'): goto EXIT; //Terminate program  
		}  
	}  
EXIT:	printf("\nGoodbye!\n");  
	return 0;  
}  

//Function definitions  
//Prompt user to enter a new pin  
int newPin() {  
	
	int pin = 0;  
	
	printf("This enter your pin: ");  
	scanf("%d", &pin);  
	getchar();  

	return pin;  
}  

//Verify newly entered pin  
int checkPin (int i) {  

	int check = 0;  
	
	printf("Confirm your new pin: ");  
	while((scanf("%d", &check)) != EOF) {  
		if (check != i) printf("Mismatch! Confirm your new pin: ");  
		else if (check == i) { 
			printf("Success! Your new pin is %d. What would you like to do next? (V)iew your saved pins, (S)ave a new pin or (E)xit: ", i);  
			goto EXIT;  
		}  
	}  
EXIT:	return i;  
}  

//TODO  
//Error handling (overflow, input data type, other?)  

Hello there! I am playing around at random for now before continuing reading the litterature that I am using to learn C.

What is a less "ugly" way to break out the while loop at the last if-else statement than leaving else empty? I guess I could have avoided this if I knew how to terminate the program at the switch - case (E) other that break -ing out of it as I am now, in other words, not having to "climb" out of switch , then while and then reaching "Goodbye!".

#include <stdio.h>  
#include <string.h>  

//Save "pins" in an array with an upper limit of ten pins. "Saved pins" resets if the upper limit is reached.  
int main(void) {  

	int pin = 0;  
	int check = 0;  

	//Saved pins  
	int pin_history[10]={0,0,0,0,0,0,0,0,0,0};  
	int pin_history_index = 0;  
	int pin_history_limit = 10;  

	int choice = 0;  

	printf("Enter your new pin: ");  
	scanf("%d", &pin);  
	getchar();  
	printf("Confirm your new pin: ");  
	while ((scanf("%d", &check))) {  
		if (check != pin) {  
			getchar();  
			printf("\nMismatch! Confirm your new pin: ");  
		}  
		else if (check == pin) {  
			pin_history[pin_history_index] = pin;  
			pin_history_index = pin_history_index + 1;  
			if (pin_history_index >= pin_history_limit) pin_history_index = 0;  
			printf("\nYour new pin has been saved successfully!\n");  
			break;  
		}  
	}  

	printf("What would you like to do next?\n\n(V)iew your saved pins\n(S)ave another pin\n(E)xit\n");  
	while ((choice = getchar()) != EOF) {  
		switch (choice) {  
			case ('V'):  
				printf("\nYour saved pins are:\n");  
				for (int i = 0; i < pin_history_limit; ++i) {  
				printf("%d\n", pin_history[i]);  
				}  
				printf("\nWhat would you like to do next?\n(V)iew your saved pins\n(S)ave another pin\n(E)xit\n");  
				break;  
			case ('S'): {  
				printf("\nEnter your new pin: ");  
				scanf("%d", &pin);  
				getchar();  
				printf("Confirm your new pin: ");  
				while ((scanf("%d", &check))) {  
					if (check != pin) {  
						getchar();  
						printf("\nMismatch! Confirm your new pin: ");  
					}  
					else if (check == pin) {  
						getchar();  
						pin_history[pin_history_index] = pin;  
						pin_history_index = pin_history_index + 1;  
						if (pin_history_index >= pin_history_limit) pin_history_index = 0;  
						printf("\nYour new pin has been saved successfully!\n");  
						printf("What would you like to do next?\n\n(V)iew your saved pins\n(S)ave another pin\n(E)xit\n");  
						break;  
					}  
				}  
				break;  
			}  
			case ('E'): break;  
		}  
		if (choice == 'E') break;  
		else;  
	}  
	printf("\nGoodbye!\n");  
	return 0;  
}  

I was experimenting with while loops, testing what happens if I condition the loop with == 0/1/EOF versus != 0/1/EOF. Obviously, this shows, more than anything else, my lack of understanding of the logic behind these operations, but it also taught me that getchar() will return the ASCII value of chars and ints if I use the format specifier %d. Also, that scanf() isn't as "forgiving", causing infinite loops, among other things, if I under certain conditions enter a char.

Is there anything else that I could learn/take away here, or was this a waste of time? 😅

The various results are commented next to the respective loops.

#include <stdio.h>  

int main() {  

	int number = 0;  

	printf("Enter a number: ");  

/*  
	while((scanf("%d", &number)) != 1) { //Success with "== 1" or "!= 0/EOF", terminates after int input with "== 0/EOF" or "!= 1", terminates after char input with "== 1" or"!= 0", infinite loop after char input with "== 0" or "!= 1/EOF".  
		printf("You have entered number %d\n", number);  
		printf("Enter a new number: ");  
	}  
*/  

/*  
	while ((number = getchar()) == EOF) { //Success with "!= 0/1/EOF", terminates after input with "== 0/1/EOF".  
		getchar();  
		printf("You have entered number %d\n", number);  
		printf("Enter a new number: ");  
	}  
*/  

	return 0;  
}  

Good day! (Yes to all interpretations thereof.)

I am a beginner at C, studying on my own because it's fun and my goal is to "simply" gain a better understanding of how machines work under the hood. I just successfully wrote a bidirectional Celcius/Fahrenheit converter that also takes some user input. As a next step, I would like to save conversion history. Do I have to save to a file outside the program or can I temporarily save history in a variable or an array and give the user the choice to check history by displaying the contents of that variable/array? If the answer is saving to an outside file, then I digress, as this is next on my "curriculum" (still self studies). If the answer is that I can save previous input into variables or an array, how do I make a - for instance - for loop go through the elements of that array, assigning one user input (temperature conversion) in one element at a time?

Also, if this is more advanced than what I am make it sound like, please let me know, and I'll let it be for the time being.

#include <stdio.h>  

//Function declarations  
float toCelcius(float fahrenheit);  
float toFahrenheit(float celcius);  

//Bidirectional temperature converter  

int main() {  

	int f_value;  
	int c_value;  
	int choice;  

	printf("\nWelcome to this Fantasic Bidirectional Temperature Converter!\n");  
	printf("\nWhat would you like to do? Press f + enter to convert Fahrenheit to Celcius, c + enter to convert Celcius to Fahrenheit or ctrl + c to exit: ");  
			
	while ((choice = getchar()) != EOF) {  
		if (choice != 'f' && choice != 'c') {  
			printf("Goodbye!\n"); //ctrl + c does not allow for this to be displayed.  
		}	
		if (choice == 'f') {  
			printf("\nEnter the temperature in Fahrenheit: ");  
			scanf("%d", &f_value);  
			getchar();  
			printf("\n%d degrees Fahrenheit is %.1f degrees Celcius.\n", f_value, toCelcius(f_value));  
		}  
		if (choice == 'c') {  
			printf("\nEnter the temperature in Celcius: ");  
			scanf("%d", &c_value);  
			getchar();  
			printf("\n%d degrees Celcius is %.1f degrees Fahrenheit.\n", c_value, toFahrenheit(c_value));  
		}  
		printf("\nWhat would you like to do next? Press f + enter to convert Fahrenheit to Celcius, c + enter to convert Celcius to Fahrenheit or ctrl + c to exit: ");  
	}  
	return 0;  
}  

//Function definitions  
float toCelcius(float fahrenheit) {  
	return (5.0 / 9.0) * (fahrenheit - 32.0);  
}  

float toFahrenheit(float celcius) {  
	return (celcius * 1.8) + 32;  
}  

hello, i am a student coder and i am spending more time trying to handle the f...ing input than i spend on algorithmization of the problem. could someone recommend some good study source, please?

i would like both the explanatory part, as well as some set of practice exercises that would really cover all possible variations.

thank you.

Major new features:

• The ISO C23 free_sized, free_aligned_sized, memset_explicit, and memalignment functions have been added.

• As specified in ISO C23, the assert macro is defined to take variable arguments to support expressions with a comma inside a compound literal initializer not surrounded by parentheses.

• For ISO C23, the functions bsearch, memchr, strchr, strpbrk, strrchr, strstr, wcschr, wcspbrk, wcsrchr, wcsstr and wmemchr that return pointers into their input arrays now have definitions as macros that return a pointer to a const-qualified type when the input argument is a pointer to a const-qualified type.

• The ISO C23 typedef names long_double_t, _Float32_t, _Float64_t, and (on platforms supporting _Float128) _Float128_t, introduced in TS 18661-3:2015, have been added to <math.h>.

• The ISO C23 optional time bases TIME_MONOTONIC, TIME_ACTIVE, and TIME_THREAD_ACTIVE have been added.

• On Linux, the mseal function has been added. It allows for sealing memory mappings to prevent further changes during process execution, such as changes to protection permissions, unmapping, relocation to another location, or shrinking the size.

• Additional optimized and correctly rounded mathematical functions have been imported from the CORE-MATH project, in particular acosh, asinh, atanh, erf, erfc, lgamma, and tgamma.

• Optimized implementations for fma, fmaf, remainder, remaindef, frexpf, frexp, frexpl (binary128), and frexpl (intel96) have been added.

• The SVID handling for acosf, acoshf, asinhf, atan2f, atanhf, coshf, fmodf, lgammaf/lgammaf_r, log10f, remainderf, sinhf, sqrtf, tgammaf, y0/j0, y1/j1, and yn/jn was moved to compat symbols, allowing improvements in performance.

• Experimental support for building with clang has been added. It requires at least clang version 18, aarch64-linux-gnu or x86_64-linux-gnu targets, and a libgcc compatible runtime (including libgcc_s.so for pthread cancellation and backtrace runtime support).

• On Linux, the openat2 function has been added. It is an extension of openat and provides a superset of its functionality. It is supported only in LFS mode and is a cancellable entrypoint.

• On AArch64, support for 2MB transparent huge pages has been enabled by default in malloc (similar to setting glibc.malloc.hugetlb=1 tunable).

• On AArch64 Linux targets supporting the Scalable Matrix Extension (SME), the clone() system call wrapper will disable the ZA state of the SME.

• On AArch64 targets supporting the Branch Target Identification (BTI) extension, it is possible to enforce that all binaries in the process support BTI using the glibc.cpu.aarch64_bti tunable.

• On AArch64 Linux targets supporting at least one of the branch protection extensions (e.g. Branch Target Identification or Guarded Control Stack), it is possible to use LD_DEBUG=security to make the dynamic linker show warning messages about loaded binaries that do not support the corresponding security feature.

• On AArch64, vector variants of the new C23 exp2m1, exp10m1, log10p1, log2p1, and rsqrt routines have been added.

• On RISC-V, an RVV-optimized implementation of memset has been added.

• On x86, support for the Intel Nova Lake and Wildcat Lake processors has been added.

• The test suite has seen significant improvements in particular around the scanf, strerror, strsignal functions and multithreaded testing.

• Unicode support has been updated to Unicode 17.0.0.

• The manual has been updated and modernized, in particular also regarding many of its code examples.

For all the rightful criticisms that C gets, GLib does manage to alleviate at least some of it. If we can’t use a better language, we should at least make use of all the tools we have in C with GLib.

This post looks at the topic of ownership, and also how it applies to libdex fibers.

I thought the book I'm reading had typos when I read code that uses this:

uint32_t src = 0xf0;
uint32_t dest = 0x400;

int main() {
    *&dest = *&src;
}

However if you take a look at the decompiled version on godbolt: link this correctly takes the value at the address stored in src, and copies it to the address in dest.

I'd love some help understanding what going on. The code looks like nonsense to me, "*&" should "cancel out" IMO.

========

Meanwhile here's what I thought the correct code would be:

uint32_t src = 0xf0;
uint32_t dest = 0x400;

int main() {
    *(uint32_t*) dest = *(uint32_t*) src;
}

Doesn't do what's expected, see decompiled: link. What's wrong with this?

When the RHS is a constant it works fine, and seems to be a common pattern people use.

I'm trying to write a linker file to get C code running on a risc-v MCU (using riscv64-unknown-elf toolchain). My linker script looks like this, simplified:

MEMORY {
        IRAM (rx) : ORIGIN = 0x00000000, LENGTH = 1024
}

ENTRY(_start)

SECTIONS {
    .text : ALIGN(4) {
        *(.text)
    } >IRAM

...

readelf -h correctly shows the entry point's address to be the same as where _start is in the output executable. But I want _start to be at 0x0, not somewhere else, so that when I objcopy it to a flat binary, the start code will be at the beginning. How can I do this?

Right now I'm having the _start function go in a new section called ".boot" I've defined in the C file using __attribute__((section(".boot"))), then, placing this at the start of .text in the linker script like so

...
    .text : ALIGN(4) {
        *(.boot)
        *(.text)
...

But IDK if this how it should be done.

Thanks in advance :)

Hi! I've recently started learning C and I've been getting stuck on the basic tasks cuz I keep overcomplicating them T-T Could anyone please help me with this specific task?

Problem Statement

You have a digit sequence S of length 4. You are wondering which of the following formats S is in:

• YYMM format: the last two digits of the year and the two-digit representation of the month (example: 01 for January), concatenated in this order
• MMYY format: the two-digit representation of the month and the last two digits of the year, concatenated in this order

If S is valid in only YYMM format, print YYMM; if S is valid in only MMYY format, print MMYY; if S is valid in both formats, print AMBIGUOUS; if S is valid in neither format, print NA.

Constraints
－ S is a digit sequence of length 4.

Sample Input 1
1905

Sample Output 1
YYMM
May XX19 is a valid date, but 19 is not valid as a month. Thus, this string is only valid in YYMM format.

Sample Input 2
0112

Sample 2
AMBIGUOUS
Both December XX01 and January XX12 are valid dates. Thus, this string is valid in both formats.

Sample Input 3
1700

Sample Output 3
NA
Neither 0 nor 17 is valid as a month. Thus, this string is valid in neither format.

The code I wrote for this is:

#include <stdio.h>

int main(){
    int S;
    scanf("%d", &S);
    int p1 = S/100;
    int p2 = S%100;
    if (p1!=0 && p1<=12){
        if(p2!=0 && p2<=12){
            printf("AMBIGUOUS");
        }
        else if (p2>=13){
            printf("MMYY");
        }
        else{
            printf("NA");
        }
    }
    else if (p1>=13){
        
        if(p2!=0 && p2<=12){
            printf("YYMM");
        }
        else {
            printf("NA");
        }
    }
   return 0;
}

It passed the 7 checks in the system, but failed on the 8th and I have no idea what kind of values are on the 8th check... Thanks to anyone for reading this far!

Many interesting presentations.

(I replaced the post with the YouTube link. This post links to the event page instead.)

I was just wondering if there are some really good websites to learn some tricks in C. As a not so beginner programmer I would really appreciate any kind of C snippet archive or something to find inspiration. I occasionally find some gold while watching Tsoding streams, but that experience is usually less dense in terms of fancy code and focuses more on problem solving.

I encounter memory corruption issue at work coming from a signal handler and decided to write a blog post about it. Feedback welcome.

C is one of the top languages in terms of speed, memory and energy

https://www.threads.com/@engineerscodex/post/C9_R-uhvGbv?hl=en