कई सी प्रोग्राम संकलित करने के लिए मेकफ़ाइल?

Question

तेजी से सरल सवाल है लेकिन मैं मेकफ़ाइल के लिए नया हूं और एक मेकफ़ाइल बनाने की कोशिश कर रहा हूं जो दो स्वतंत्र कार्यक्रमों को संकलित करेगा। ऑनलाइन सभी उदाहरणों की आवश्यकता के मुकाबले ज्यादा जानकारी मिलती है और भ्रमित हो रही है!

मैं निम्नलिखित है:

program1: 
    gcc -o prog1 program1.c 

program2 
    gcc -o prog2 program2.c 

सभी मैं वास्तव में यह करने के लिए चाहते हैं दो जीसीसी लाइनों को चलाने के लिए है। मैं क्या गलत कर रहा हूं?

Answer 1

यह इतना

all: program1 program2 

program1: program1.c 
    gcc -o program1 program1.c 

program2: program2.c 
    gcc -o program2 program2.c 

आपने कहा कि आप उन्नत सामान नहीं करना चाहती पसंद है, लेकिन आप भी कुछ डिफ़ॉल्ट नियमों के आधार पर इस तरह इसे छोटा कर सकते हैं।

all: program1 program2 

program1: program1.c 
program2: program2.c 

Answer 2

all: program1 program2 

program1: 
    gcc -Wall -o prog1 program1.c 

program2: 
    gcc -Wall -o prog2 program2.c 

Answer 3

all: program1 program2 

program1: 
    gcc -Wall -ansi -pedantic -o prog1 program1.c 

program2: 
    gcc -Wall -ansi -pedantic -o prog2 program2.c 

मैं नहीं बल्कि एएनएसआई और पंडिताऊ, अपने कार्यक्रम के लिए एक बेहतर नियंत्रण। जब भी आपको चेतावनियां होंगी तो यह आपको संकलित नहीं करेगा !!

Answer 4

एक साधारण प्रोग्राम का संकलन वर्कफ़्लो सरल है, मैं इसे एक छोटे ग्राफ के रूप में आकर्षित कर सकता हूं: स्रोत -> [संकलन] -> ऑब्जेक्ट [लिंकिंग] -> निष्पादन योग्य। इस ग्राफ में फ़ाइलें (स्रोत, वस्तु, निष्पादन योग्य) हैं, और नियम ( की शब्दावली बनाते हैं)। यह ग्राफ मेकफ़ाइल में निश्चित है।

जब आप लांच बनाने के लिए, यह Makefile, और बदल फ़ाइलों के लिए चेक पढ़ता है। यदि कोई है, तो यह नियम को ट्रिगर करता है, जो इस पर निर्भर करता है। नियमफ़ाइलें का उत्पादन/अद्यतन कर सकता है, जो अन्य नियम नियमों को ट्रिगर कर सकता है और इसी तरह। यदि आप एक अच्छा मेकफ़ाइल बनाते हैं, तो केवल नियम (कंपाइलर/लिंक कमांड) चलाए जाएंगे, जो निर्भरता पथ में संशोधित फ़ाइल से "अगली" है।

एक उदाहरण उठाओ Makefile, वाक्य रचना के लिए मैनुअल पढ़ने (वैसे भी, यह पहली नजर के लिए स्पष्ट है, w/ओ मैनुअल), और ग्राफ आकर्षित। परिणाम फ़ाइलों के नाम जानने के लिए आपको कंपाइलर विकल्पों को समझना होगा।

मेक ग्राफ उतना ही जटिल होना चाहिए जितना आप चाहते हैं। आप अनंत लूप भी कर सकते हैं (मत करो)! आप बना सकते हैं, जो नियम आपके लक्ष्य है, इसलिए केवल बाएं-खड़े फ़ाइलें ट्रिगर्स के रूप में उपयोग की जाएंगी।

फिर से: ग्राफ ड्रा!

Answer 5

############################################################################ 
# 'A Generic Makefile for Building Multiple main() Targets in $PWD' 
# Author: Robert A. Nader (2012) 
# Email: naderra at some g 
# Web: xiberix 
############################################################################ 
# The purpose of this makefile is to compile to executable all C source 
# files in CWD, where each .c file has a main() function, and each object 
# links with a common LDFLAG. 
# 
# This makefile should suffice for simple projects that require building 
# similar executable targets. For example, if your CWD build requires 
# exclusively this pattern: 
# 
# cc -c $(CFLAGS) main_01.c 
# cc main_01.o $(LDFLAGS) -o main_01 
# 
# cc -c $(CFLAGS) main_2..c 
# cc main_02.o $(LDFLAGS) -o main_02 
# 
# etc, ... a common case when compiling the programs of some chapter, 
# then you may be interested in using this makefile. 
# 
# What YOU do: 
# 
# Set PRG_SUFFIX_FLAG below to either 0 or 1 to enable or disable 
# the generation of a .exe suffix on executables 
# 
# Set CFLAGS and LDFLAGS according to your needs. 
# 
# What this makefile does automagically: 
# 
# Sets SRC to a list of *.c files in PWD using wildcard. 
# Sets PRGS BINS and OBJS using pattern substitution. 
# Compiles each individual .c to .o object file. 
# Links each individual .o to its corresponding executable. 
# 
########################################################################### 
# 
PRG_SUFFIX_FLAG := 0 
# 
LDFLAGS := 
CFLAGS_INC := 
CFLAGS := -g -Wall $(CFLAGS_INC) 
# 
## ==================- NOTHING TO CHANGE BELOW THIS LINE =================== 
## 
SRCS := $(wildcard *.c) 
PRGS := $(patsubst %.c,%,$(SRCS)) 
PRG_SUFFIX=.exe 
BINS := $(patsubst %,%$(PRG_SUFFIX),$(PRGS)) 
## OBJS are automagically compiled by make. 
OBJS := $(patsubst %,%.o,$(PRGS)) 
## 
all : $(BINS) 
## 
## For clarity sake we make use of: 
.SECONDEXPANSION: 
OBJ = $(patsubst %$(PRG_SUFFIX),%.o,$@) 
ifeq ($(PRG_SUFFIX_FLAG),0) 
     BIN = $(patsubst %$(PRG_SUFFIX),%,$@) 
else 
     BIN = $@ 
endif 
## Compile the executables 
%$(PRG_SUFFIX) : $(OBJS) 
    $(CC) $(OBJ) $(LDFLAGS) -o $(BIN) 
## 
## $(OBJS) should be automagically removed right after linking. 
## 
veryclean: 
ifeq ($(PRG_SUFFIX_FLAG),0) 
    $(RM) $(PRGS) 
else 
    $(RM) $(BINS) 
endif 
## 
rebuild: veryclean all 
## 
## eof Generic_Multi_Main_PWD.makefile 

Answer 6

SRC = a.cpp b.cpp 
BIN = $(patsubst %.cpp,%,$(SRC)) 

all: $(BIN) 

clean: 
    rm -f $(BIN) 

.PHONY: all clean 

make all करना होगा:

c++  a.cpp -o a 
c++  b.cpp -o b 

आप CXX और CXXFLAGS चर सेट करते हैं make उनका उपयोग करेगा।

Answer 7

Pattern rules इस प्रकार आप एक से अधिक ग फ़ाइलें जो make का उपयोग कर एक ही संकलन आदेशों की आवश्यकता संकलन करते हैं:

objects = program1 program2 
all: $(objects) 

$(objects): %: %.c 
     $(CC) $(CFLAGS) -o $@ $<