This is a common phenomenon in competitive programming, as well – we typically need to use the ASCII value of characters when solving some of the problems on various online platforms like HackerRank, Codeforces, and Codechef.

What do we do in those situations? Most of us simply search for the ASCII value on the internet, like this:

Yes, it's true that we can get the ASCII value of any character directly by searching the internet. But sometimes you might not be able to search for them on the internet. Like if you are taking an exam, you might be forbidden from accessing the internet during the exam.

So what would you do if you don't remember the ASCII value of the character you need, and you are also forbidden to search for it on the internet?

No need to panic! In this article, I am going to solve the problem for you. You will never need the internet for searching the ASCII value of any character ever again.

Getting Started

Suppose you are writing a C program, and you also need to know the ASCII value of a character. Fear not! You do not need to shift to other languages just to get the value using code – you can do that within your C code! Follow the code below:

#include<stdio.h>
int main()
{
    char ch = 'A';
    printf("%c\n" , ch);
}

Can you tell me what we would get in the output? If you think that you would get the character itself in the output, then you are correct!

// A

I used the //to indicate the comment here.

Let me give you a nice screenshot below as well:

In line 4, I am taking a character type data as ch, and I am assigning a character to this variable. For now, I am taking the character 'A', then I am printing the character itself in line 5.

But if I use %d instead of %c, then I am telling it to print the integer value of the character, not the character itself.

If we talk about the integer value of a character, then it can represent one thing – the ASCII value of the character, right? The sample code is given below:

Sample input

In the output, we will get the ASCII value of the character 'A'.

That is how we get the ASCII value of any character using the above code.

Let me introduce you to a more interesting thing now. As I am only showing you the process of getting the ASCII value of the English alphabet, you may wonder whether the code only works for getting the ASCII value of an alphabet letter or whether it works with any valid characters.

Well, the good news is that this process works for any valid characters! Let me show you more examples first.

How to Get the ASCII Value of a Space ( )

A space is also considered a valid character. In code, normally we use a space to represent it, like char ch = ' '. So if I use the space in the above code – but this time I use the space instead of the alphabet letter – then the code would be like this:

In line 4, we assigned a space into the character variable named char. Now, if I run the code, then I would get the ASCII value of a space, which is 32.

Now, if you can understand how this works, then let me give you a simple task. In all of the code, we assigned character data manually and we checked the ASCII value by printing the value in the output.

In this process, if we want to get the ASCII value of various characters, then we need to change the code manually each time. But this might be a hassle if we want something like an ASCII calculator, where the user would provide the character as an input and the code would provide the exact ASCII value as the output in the terminal.

Do you think you could create that now on your own? Don't scroll down until you have tried to write down the code at least once!

Alright, I hope you have tried to make the calculator by tweaking the code a little bit. If you struggle in doing so, then do not worry as I have you covered.

How to Make an ASCII Calculator

Earlier we assigned each character manually in our code. As we want the user to provide the character itself, we will tweak the code a little bit.

This time, we won't assign character values in the character variables. We will declare a character variable first so that we can assign the character to the variable later. Then we'll ask the user to provide a character in the terminal.

After getting the input from the user, we will assign the value to our character variable. Then we'll simply print the ASCII value of the character in the terminal. It's that easy!

Simply follow the code below, and I'll explain all of the steps again below:

Our ASCII Calculator using the C programming language

Let me explain what I did in the code first. Then I will show you the result by running the program.

As you can see, I included the basic and must needed standard header file in line 1. stdio represents the standard input and output format.

Basically, stdio.h is a header file that has the necessary information to include the input/output related functions in our program. As we will definitely work on input and output, it is a necessary header file in our C program.

In line 2, I added the main function. A main is a predefined keyword or function in C. The execution of any C program always starts from the main function – keep that in your mind.

We have to provide the return type of the function. I used int so that the main function can return any integer value. But as you can see, I am not actually returning anything later. So, I can also use void instead of int in line 2. The output would be exactly the same. Void means that it does not return anything.

In line 3 and in line 7, I used curly braces { }. Normally we use curly braces to group a set of statements. As all of the statements (or, you could say, the lines of code) from line 4 to line 6 are included in the main function, I used those curly braces to represent them all as a set of statements, or a block of code.

In line 4, I declared a character variable. We use char to represent the character data type.

After declaring the data type, we need to provide the name of the character. I used ch as my variable name, but you can use any name you want except the C keyword. There are some conventions of naming a variable in the C programming language you can check out, too.

The semicolons ( ; ) are the end statements in the C programming language. We use ; to indicate the end of a line of code.

In line 5, I am using the scanf function. We use it to get input from the user. I am taking a character value from the user as input. Here, %c refers to character type data.

After taking the character value as input from the user, we are storing the value into our character variable, ch. (If we don't store the data, then how we are going to make calculations on them, right?).

& is an address operator, and the & operator is used to get the address of the variable. As we are using &ch, it indicates that we are telling the C compiler that we are giving or passing the input data value in the ch variable. We pronounce & as Ampersand.

In line 6, I am printing the ASCII value of the character (the character we have taken as an input from the user).

I have talked a lot, haven't I? 😅 Now, it is time to show you the result of our very simple ASCII calculator.

Here I provided L as input to get the ASCII value of L. In the next line, the program provided 76 as the output, and 76 is the exact ASCII value of L.

Now let's check something different. I will check the ASCII value of ! now.

As you can see, it's working flawlessly! Now let's make the code prettier.

You see, as we have written the entire code, we can understand that we have to give a character value as input first. Then the program provides the ASCII value.

But other users might not get that. They might also get confused about what they should do after running the code – like, will the code directly provide the ASCII value of any random character or anything else? We do not want to make others confused with our simple yet kind of handy project, right?

Let's provide some statements first that make it easier for users to figure out what they need to do after executing the code. The code would look like this:

#include <stdio.h>
void main()
{
    char ch;
    printf("Enter a character: ");
    scanf("%c", &ch);
    printf("The ASCII value of %c is: %d\n", ch, ch);
}

We all want a nice screenshot. Let me give you one:

Our simple yet handy ASCII Calculator

Fear not! I will explain all the modified parts now:

In line 5, I have added a print statement to show the given string each time the user executes the code. I want the users to know that they simply need to input a character in the terminal after running the program.

In line 7, I have modified the print function a little bit. I want the code to generate a nice line along with providing the ASCII value of the given character. The %c indicates that we would provide the character itself here, and the %d is indicating to print the integer value as earlier.

Now let me show you the result by providing random characters as input.

The ASCII value for a

It looks beautiful, right? At least, prettier than the earlier code, as the users will get everything here – what they would need to do, what value the program is providing in the output, and so on, right?

The ASCII value for ^

I have also added this last code in my public gist.

Our ASCII calculator is ready! We have learned a lot, even though we only used some simple code.

If you're wondering that we used the C programming language in this article, but can't we do this using other programming languages? The answer is YES! I was thinking about showing you the exact ASCII calculator using other languages, but that would make this article way bigger. So I am keeping that task and letting you do it for yourself.

You can also customize the code to fit your needs, add a nice GUI, and so on. Explore the wonderful world of programming :)

Conclusion

I hope this article helps you in understanding how basic C programs work.

Thanks for reading the entire article. If it helps you then you can also check out other articles of mine at freeCodeCamp.

If you want to get in touch with me, then you can do so using Twitter, LinkedIn, and GitHub.

You can also SUBSCRIBE to my YouTube channel (Code With FahimFBA) if you want to learn various kinds of programming languages with a lot of practical examples regularly.

If you want to check out my highlights, then you can do so at my Polywork timeline.

You can also visit my website to learn more about me and what I'm working on.

Thanks a bunch!

If you search for these codes online, you'll often find tables that are really just images. These are inaccessible to people with disabilities, and inconvenient to use – you can't search for something and copy-paste code you want.

To make your life easier, I created a table from the best sources I could find. Just scroll or use Ctrl/Cmd + f to find the value you're looking for.

Here's the traditional ASCII table:

And here's the extended ASCII table for the web:

Sources for both tables: ASCII, Windows-1252, and ASCII Code - The extended ASCII table

Note that there are several other extended ASCII tables like ISO 8859, ISO 8859-1, ISO 8859-2, and so on. The extended table above is based on Windows-1252 ASCII table, and is what web browsers used before UTF-8 was created.

Even though we've largely moved past ASCII and its limitations to modern character encodings like UTF-8, all of the HTML values in the tables above will still work on current browsers.

If you'd like to learn more about character encoding, ASCII, and unicode characters, check out this article.

How to Use ASCII Characters in HTML

ASCII characters can be useful for web developers, like if you need to manually insert whitespace or a special character into your HTML.

If you look at the tables above, you'll see that every ASCII character has an HTML entity number, and some also have an HTML entity name.

Each HTML entity number and name starts with an ampersand (&) and ends with a semicolon (;).

You can use these anywhere in your HTML to reliably render that character, no matter what the a person's browser language is set to.

In general, it's recommended to use the HTML entity name whenever possible – they're easier to remember, and are self-descriptive for any other developers that read your code.

For example, if you need to render the Euro currency sign (€), the HTML entity name € is much easier to remember than €.

Here are some of the more common ASCII characters you'll use in HTML, along with some examples.

How to Use the   Non-Breaking Space Character Code

There are times when you'll want to add a space, but want to keep other words or characters together, even if there's a limited amount of horizontal space.

An easy way to do this would be to use a non-breaking space character, for example:

<span>Superpower:&nbsp;listening</span>

Which renders the following:

Superpower: listening

Sure, it looks like there's a normal space between the colon and the "l" in "listening", but the   character makes it so that the line will never break there.

For example, here's that code with an outline around the span element, and with a width of 150 pixels:

Superpower: listening

With a normal space character, the line would break like this:

Superpower: listening

You can even insert several non-breaking spaces in a row to create make-shift text padding:

<span>Superpower:&nbsp;&nbsp;&nbsp;listening</span>

How to Make a Newline in HMTL using the 
 Newline Character Code

While you can use JavaScript to render \n as a newline in HTML, that's not always an option. You might only have access to the HTML code, or just want to keep things simple.

In that case, you can use the newline / line feed character code to force a newline:

<div style="margin-bottom: 1.5em;">
  <label for="example-1">Example 1: </label>
  <textarea name="example-1" id="example-1">Hello&#10;freeCodeCamp</textarea>
</div>

Which renders the following:

And yes, you can use these back-to-back, too:

<div style="margin-bottom: 1.5em;">
  <label for="example-2">Example 2: </label>
  <textarea name="example-2" id="example-2" style="height: 150px;">Hello&#10;&#10;&#10;freeCodeCamp</textarea>
</div>

However, note that the 
 character doesn't override the default styling of the element it's used in. For example, the p element doesn't allow line breaks within the element – you'd have to create another paragraph element:

<p style="outline: red 1px solid;">This is paragraph text and &#010; whoops there is a new line.</p>

The code above renders everything to a single line:

This is paragraph text and whoops there is a new line.

To override this behavior, just set the white-space property to pre-wrap:

<p style="outline: red 1px solid; white-space: pre-wrap;">This is paragraph text and &#010; whoops there is a new line.</p>

This is paragraph text and whoops there is a new line.

Thanks for Reading

If you found this helpful, please share it with your friends so more people can get started using ASCII characters.

Also, if you liked this article, let me know over on Twitter.

I'll explain a brief history of encoding in this article (and I'll discuss how little standardisation there was) and then I'll talk about what we use now. I'll also cover some Computer Science theory you need to understand.

Introduction to Encoding

A computer only can understand binary. Binary is the language of computers, and is made up of 0's and 1's. There is nothing else allowed. One digit is called a bit, and a byte is 8 bits. So 8 0's or 1's make up one byte.

Everything eventually ends up as binary – programming languages, mouse moves, typing, and all the words on the screen.

If all the text you're reading was once binary too, then how do we turn binary into text? Let's look at what we used to do back in the beginning.

A Brief History of Encoding

In the early days of the internet, it was English only. We didn't need to worry about any other characters and the American Standard Code for Information Interchange (ASCII) was the character encoding that fit this purpose.

ASCII is a mapping, from binary to alphanumeric characters. So when the PC receives binary:

01001000 01100101 01101100 01101100 01101111 00100000 01110111 01101111 01110010 01101100 01100100

With ASCII it can translate that into "Hello world".

One byte (eight bits) was large enough to fit every English character, and some control characters too. Some of these control characters were used for instruments called teleprinters, so at the time they were useful (not so much now!)

But the control characters were things like 7 (111 in binary) that would make a bell sound on your PC, 8 (1000 in binary) that would print over the last character it just printed, or 12 (1100 in binary) that would clear a video terminal from all the text just written.

Computers at this time were using 8 bits for one byte (they didn't always), so there were no issues. We could store all our control characters, all our numbers, all the English characters and have some left! Because one byte can encode 255 characters, and ASCII only needed 127 characters. So we had 128 encodings that were unused.

Let's look at an ASCII table here to see every character. All lowercase and uppercase A-Z and 0-9 were encoded to binary numbers. Remember the first 32 are unprintable control characters.

ASCII Character Table

Can you see how it ends with 127? We have some spare room at the end.

Issues with ASCII

The spare characters were 127 through to 255. People began to think about what would be best to fill those remaining characters. But everyone had different ideas about what those final characters should be.

The American National Standards Institute (ANSI - don't get confused with ASCII) is a standards body for establishing standards across lots of different fields. They decided what everyone was doing with 0-127, which is what ASCII was already doing. But the rest were open.

No one was debating what 0-127 in the ASCII encoding was. The problem was with the spare ones.

Below is what the first IBM computers did with the 128-255 encodings for ASCII.

Some squiggles, some background icons, math operators and some accented characters like é.

But other computers didn't all follow this. And everyone wanted to implement their own encodings for the end of ASCII.

These different endings for ASCII were called code pages.

What are ASCII Code Pages?

Here's a collection of over 465 different codepages! You can see that there were multiple codepages EVEN for the same language. Greek and Chinese both have multiple codepages, for example.

So how on EARTH were we ever going to standardise this? Or make it work between differing languages? Between the same language with different codepages? In a non English language?

Chinese has over 100,000 different characters. We don't even have enough spare characters for Chinese, let alone agreeing that the final characters should be Chinese ones. This isn't looking so good.

This problem even has its own term: Mojibake.

It's garbled text you may sometimes see from decoding text, but using the wrong decoding. It means character transformation in Japanese.

Example of completely garbled text (mojibake).

This sounds a little insane...

Exactly! We will have zero chance of reliably interchanging data.

The internet is just a huge connection of computers around the world. Imagine if all these countries decided what they each thought the standards should be. If the Greek computers only accepted Greek and the English computers only sent English...? You would just be shouting into an empty cave. No one would understand you. And no one would be able to decode the nonsense.

ASCII wasn't fit for real life use. In a global, connected internet, we had to evolve, or else forever deal with hundreds of codepages.

��� Unless you ������ fancied trying ��� to ��� read paragraphs like this. �֎֏0590֐��׀ׁׂ׃ׅׄ׆ׇ

Along Came Unicode

Unicode is sometimes called the Universal Coded Character Set (UCS), or even ISO/IEC 10646. But Unicode is its more common name.

But, this is where Unicode entered the scene to help solve the problems that encoding and code pages were causing.

Unicode is made up of lots of code points (mapping lots of characters from around the world to a key that all computers can reference.) A collection of code points is called a character set - which is what Unicode is.

We can map something abstract to a letter we want to reference. And it does every character! Even Egyptian Hieroglyphs.

Some people did all the hard work of mapping what each character would be (in all the languages) to a key that we could all access. They look like this:

"Hello World"

U+0048 : LATIN CAPITAL LETTER H

U+0065 : LATIN SMALL LETTER E
U+006C : LATIN SMALL LETTER L
U+006C : LATIN SMALL LETTER L
U+006F : LATIN SMALL LETTER O
U+0020 : SPACE [SP]
U+0057 : LATIN CAPITAL LETTER W
U+006F : LATIN SMALL LETTER O
U+0072 : LATIN SMALL LETTER R
U+006C : LATIN SMALL LETTER L
U+0064 : LATIN SMALL LETTER D

The U+ lets us know it's the Unicode standard, and the number is what results when the binary get's transformed to numbers. It uses hexadecimal notation which is just a simpler way of representing binary numbers. You don't have to worry too much about the hexadecimal here, though.

Here's a link where you can type whatever you want into the text box, and see the Unicode character encoding. Or look at all 143,859 Unicode character points here. You can also see where each character is from in the world!

I just want to be clear. At this point we have a big dictionary of code points mapping to characters. A really big character set. Nothing more.

There's one final ingredient we need to add to our mix.

Unicode Transform Protocol (UTF)

UTF is a way we encode Unicode code points. The UTF encodings are defined by the Unicode standard, and are able to encode every single Unicode code point we need.

But there are different types of UTF standards. They differ depending on the amount of bytes used to encode one code point. It also depends on whether you're using UTF-8 (one byte per code point), UTF-16 (two bytes per code point) or UTF-32 (four bytes per code point).

If we have these different encodings, how do we know which encoding a file will use? There's a thing called a Byte Order Mark (BOM) - sometimes referred to as an Encoding Signature. The BOM is a two-byte marker at the beginning of a file that tells what encoding the file is using.

UTF-8 is the most used on the internet, and is also specified in HTML5 as the preferred encoding for new documents, so I'll spend the most time explaining this one.

You can see in the diagram even from 2012, UTF-8 was widely becoming the most used encoding. And for the web it still is.

_W3 diagram to show how well used UTF-8 is used on a variety of websites._

What is UTF-8 and How Does it Work?

UTF-8 encodes all the Unicode code points from 0-127 in 1 byte (the same as ASCII). This means that if you were coding your program using ASCII, and your users used UTF-8, they wouldn't notice anything was wrong. Everything would just work.

Just remember how strong a selling point this is. We needed to remain ASCII backwards compatible while UTF-8 was being implemented and used by everyone. It doesn't break anything currently being used.

Because it's called UTF-8, remember that's the minimum number of bits (8 bits being one byte!) that a code point will be. There are other Unicode characters that are stored in multiple bytes (up to 6 bytes depending on the character). This is what people mean when the encoding is called variable length.

It might be more, depending on the language. English is 1 byte. European (Latin), Hebrew and Arabic are represented with 2 bytes. 3 bytes are used for Chinese, Japanese, Korean and other Asian characters. You get the idea.

When you need a character to span more than one byte, you have a bit combination to identify a continuation sign, saying this character is continued over the next several bytes. So you’ll still only use one byte per character for English, but if you need a document to contain some foreign characters, you can do that too.

And now, wonderfully, we can all agree on what the Sumerian cuneiform characters encoding is (𒀵 𒁷𒂅 𒐤), as well as some emoji's 😉😉 so we can all communicate!

The high level overview is: You first read the BOM so you know your encoding. You decode the file into Unicode code points, and then represent the characters from the Unicode character set into characters drawn onto the screen.

A Final Word About UTF

Remember, encoding is key. If I send the complete wrong encoding you can't read anything. Be aware of it when receiving or sending data. Often it is abstracted away in the tools you use everyday, but as programmers it's important to understand what is happening under the hood.

How do we specify our encodings, then? Because HTML is written in English, and almost all encodings can deal with English fine. We can embed it right at the top in the <head> section.

<html lang="en">
<head>
  <meta charset="utf-8">
</head>

It's important to do this at the very start of the <head>, as the parsing of the HTML may have to start again if the encoding it's currently using is wrong.

We also can get the encoding from the Content-Type header from the HTTP request/ response.

If an HTML document doesn't contain the encoding tag, the HTML5 spec has some interesting ways it can guess the encoding called BOM sniffing. This is where it guesses the encoding from the Byte Order Mark (BOM) we discussed earlier.

So is that it?

Unicode isn't finished. Like any standard, we add, remove and make new proposals to the standard. No specification is ever considered "complete".

There are generally 1 or 2 release a year, and you can find them here.

Recently I read about a very interesting bug around Twitter rendering Russian Unicode characters incorrectly.

If you have read this far, congratulations – it's a lot to digest.

I would encourage you to do one last piece of homework.

Look at how broken websites can really be when the encoding is wrong. I used this Google Chrome extension and changed my encoding and tried to read webpages. The message was completely unclear. Try and read this article. Try and navigate Wikipedia. See Mojibake for yourself.

It helps to see how important encoding truly is.

Conclusion

In my time spent researching and trying to simplify this article, I learned about Michael Everson. Since 1993, he has proposed over 200 Unicode changes, and has added thousands of characters to the standard. As of 2003, he was credited as the leading contributor of Unicode proposals. He is one huge reason why Unicode is what it is. Very impressive, and he has done a great deal for the Internet as we know it.

I hope this has explained a good overview of why we need encodings, what problems encoding solves, and what happens when it goes wrong.

I share my writing on Twitter if you enjoyed this article and want to see more.