What is the difference between binding and binding?

I read about two things and was confused, what are the differences between them?


source to share

3 answers

Binding is a word that is used in multiple contexts. It always involves connecting one thing to another, but where the binding action can be different.

There is the concept of anchor time, or the point at which a component is linked to some other component. The main bind-time list is (1) compile-time bind, (2) link-time bind, (3) load-time bind, and (4) run-time bind.

Compile-time linking occurs when the source is compiled. For C / C ++, there are two main stages: the preprocessor, which performs the substitution of the source text, such as replacing the replacement or replacing the macro, and the compilation of the source text, which converts the source text to machine code along with the necessary instructions for the linker.

Link-time linking is when external symbols are linked to a specific set of object files and libraries. You can have several different static libraries that have the same set of function names, but the actual implementation of the function is different. Thus, you can choose which library implementation to use by choosing different static libraries.

Linking at load time is when the loader loads the executable into memory along with any dynamic or shared libraries. The loader associates function calls with a specific dynamic or shared library, and the selected library can change.

Runtime binding is when a program actually executes and makes choices based on the current thread of execution.

So binding is actually one type of binding. Take a look at this stackoverflow static linking and dynamic linking which has more information on links and libraries.

You may also be interested in std::bind

C ++, so here is the stackoverflow article std :: function and std :: bind what they should use when they should be used .

The longer you wait before something is related to something else, you can provide the degree of flexibility you need with your software. However, there is often a trade-off between binding latency and runtime efficiency, as well as source complexity.

For an example of binding time, consider an application that opens a file and reads it from a file, then closes it. You can choose a couple of times when the filename is associated with an open file.

You can hard-code the filename, bind it at compile time, which means it can only be used with one file. To change the filename, you must change the source and recompile.

You can have a file name entered by the user, for example, with a user prompt or a command line argument that associates a file name with an open file at runtime. To change the filename, you no longer need to recompile, you can run the program again with a different filename.



Suppose you have a function declared as:

void f(int, char);


and also how:

void f(int);


And you call the function f (4) with the right signature. This is a binding. The linker will link to the available function body definition to match f with signature void f (int);



In fact both have the same meaning in the c programming context. Some people use anchor and others use a link.

If you want to know what a link is, here's a short explanation.

Suppose you have created a user-defined function sum () whose declaration matches int sum (int, int); then whenever a function is called from within a program, your program needs to know where to scan in memory in order to execute that function. In simple terms, the address of a function must be known to your inorder program to get to its body, which is called an anchor.

The amount is now user definable, so it will appear in your source code. If called from main (), it will be linked to main at compile time, because at that time the compiler will know where your function will be present in the executable. This is called static linking.

Now consider that printf () is a library function and its body is missing from your program. Therefore, when the program is compiled, the printf body will not be present in the compiled executable. It will be loaded into memory when your program is running, and its address will be known as the main address at runtime, not at compile time as the sum of sum (). This type of binding is called dynamic binding.



All Articles