1147_ Makefile learning_ Target files and dependent files in makefile

    All learning summary ： https://github.com/GreyZhang/g_makefile

    Let's start with a simple example ：

hello:

    echo "hello world"

    If you create a file named Makefile The file of , Enter the above content to save . after , Start the command line and enter the directory where the file is located make（ perhaps gmake etc. ） The following effect appears ：

    It can be seen that the original command statement is printed on the interactive interface , At the same time, the result of statement execution is printed . I understand this somewhat , It should be possible to add a @ Symbol to deal with the echo of the command itself .

    This is a makefile Part of the basic grammar of . According to the explanation here , The target file can be multiple . Between target files , Use spaces to distinguish . such , In fact, there is a problem worth confirming ： If the name of the file itself has spaces , What should be done here ？ Again , Similar problems also exist in dependent files . Next , Another thing to note is that the command starts from TAB The beginning, not the space .

    Let's take another example ：

    Result of operation ：

    This example has a note when running , That is in Windows You need to use a bash Simulation environment of . because Windows There is also a command system in echo, But with the bash Medium echo Their behavior is different . If you don't pay attention to this , The above example cannot be executed successfully .

    Here is an interesting mode of thinking , That is, the execution sequence written in the comment . In this way ,Makefile The execution and derivation process of is a little recursive in programming .

    Here are two other examples , Easier to understand . First every time make Will execute the output , Because the target file never exists . The second one will print for the first time because the target file does not exist , create a file . From the second execution , It will not output but prompt that the file has been updated .

    Considering dependence and time relationship , The above implementation process is very understandable . But here we can also see another problem ：Makefile The implementation of does not mean that the target file will be updated to the latest .

some_file: other_file

    echo "This will run second, because it depends on other_file"

    touch some_file

other_file:

    echo "This will run first"

    touch other_file

    The example above , It involves the dependence on other files . The effect of operation ：

    This example can actually show the relationship between File Dependencies , If the file is not ready , So update . If the file is ready , Then don't update . If the timestamp of the dependent file changes , The target file will also be updated .

    A better test method described above is like this , Directly by formulating target To generate other_file, After performing gmake Handle default target, That's the first one target. such , Not only can we see makefile For the management concept of file timestamp , At the same time, you can also see the specified target Processing function .

    such , Another concept about object file is introduced .make clean Is a common operation , In fact, it is only used to deal with the specified target nothing more .clean Not at all makefile A keyword or reserved word in .