C++
सिस्टम बनाएँ

परिचय

टिप्पणियों

सीएमके साथ बिल्ड पर्यावरण का निर्माण

CMake लगभग किसी भी कंपाइलर या IDE से एकल प्रोजेक्ट परिभाषा के लिए वातावरण बनाता है। निम्न उदाहरण प्रदर्शित करेगा कि क्रॉस-प्लेटफ़ॉर्म "हैलो वर्ल्ड" सी ++ कोड में सीएमके फ़ाइल कैसे जोड़ें।

CMake फ़ाइलों को हमेशा "CMakeLists.txt" नाम दिया जाता है और पहले से ही हर प्रोजेक्ट की रूट डायरेक्टरी में मौजूद होना चाहिए (और संभवतः उप-निर्देशिकाओं में भी।) एक मूल CMakeLists.txt फाइल इस तरह दिखती है:

cmake_minimum_required(VERSION 2.4)

project(HelloWorld)

add_executable(HelloWorld main.cpp)

इसे कोलिरु पर लाइव देखें।

यह फ़ाइल प्रोजेक्ट नाम सीएमके को बताती है कि किस फ़ाइल संस्करण की अपेक्षा करनी है, और "हैलोवर्ल्ड" नामक एक निष्पादन योग्य उत्पन्न करने के लिए निर्देश दिए जाने की आवश्यकता है जो कि 8 main.cpp आवश्यकता है।

कमांड लाइन से अपने स्थापित कंपाइलर / आईडीई के लिए एक बिल्ड वातावरण बनाएं:

> cmake .

के साथ आवेदन बनाएँ:

> cmake --build .

यह ओएस और इंस्टॉल किए गए टूल के आधार पर सिस्टम के लिए डिफ़ॉल्ट बिल्ड वातावरण उत्पन्न करता है। "आउट-ऑफ-सोर्स" बिल्ड के उपयोग के साथ किसी भी निर्माण कलाकृतियों से स्रोत कोड को साफ रखें:

> mkdir build
> cd build
> cmake ..
> cmake --build .

सीएमके पिछले उदाहरण से प्लेटफ़ॉर्म शेल के मूल आदेशों को भी रद्द कर सकता है:

> cmake -E make_directory build
> cmake -E chdir build cmake .. 
> cmake --build build 

CMake में कई सामान्य बिल्ड टूल और IDE के लिए जनरेटर शामिल हैं। Visual Studio के nmake के लिए nmake उत्पन्न करने के लिए:

> cmake -G "NMake Makefiles" ..
> nmake

जीएनयू बनाने के साथ संकलन

परिचय

GNU मेक (स्टाइल make ) एक प्रोग्राम है जो शेल कमांड को निष्पादित करने के स्वचालन के लिए समर्पित है। GNU मेक एक विशिष्ट कार्यक्रम है जो मेक परिवार के अंतर्गत आता है। लिनक्स कर्नेल, मैक ओएस एक्स, और बीएसडी से व्युत्पन्न सहित यूनिक्स-जैसे और पॉसिक्स जैसे ऑपरेटिंग सिस्टम के बीच लोकप्रिय बना रहता है।

GNU मेक विशेष रूप से GNU प्रोजेक्ट से जुड़े होने के लिए उल्लेखनीय है, जो लोकप्रिय GNU / Linux ऑपरेटिंग सिस्टम से जुड़ा हुआ है। जीएनयू मेक में विंडोज और मैक ओएस एक्स के विभिन्न स्वादों पर चलने वाले संगत संस्करण भी हैं। यह एक बहुत ही स्थिर संस्करण है जिसका ऐतिहासिक महत्व लोकप्रिय है। यह इन कारणों से है कि जीएनयू मेक को अक्सर सी और सी ++ के साथ पढ़ाया जाता है।

बुनियादी नियम

मेक के साथ संकलन करने के लिए, अपने प्रोजेक्ट डायरेक्टरी में मेकफाइल बनाएं। आपका मेकफाइल उतना ही सरल हो सकता है:

makefile

# Set some variables to use in our command
# First, we set the compiler to be g++
CXX=g++

# Then, we say that we want to compile with g++'s recommended warnings and some extra ones.
CXXFLAGS=-Wall -Wextra -pedantic

# This will be the output file
EXE=app

SRCS=main.cpp

# When you call `make` at the command line, this "target" is called.
# The $(EXE) at the right says that the `all` target depends on the `$(EXE)` target.
# $(EXE) expands to be the content of the EXE variable
# Note: Because this is the first target, it becomes the default target if `make` is called without target
all: $(EXE)

# This is equivalent to saying
# app: $(SRCS)
# $(SRCS) can be separated, which means that this target would depend on each file.
# Note that this target has a "method body": the part indented by a tab (not four spaces).
# When we build this target, make will execute the command, which is:
# g++ -Wall -Wextra -pedantic -o app main.cpp
# I.E. Compile main.cpp with warnings, and output to the file ./app
$(EXE): $(SRCS)
    @$(CXX) $(CXXFLAGS) -o $@ $(SRCS)

# This target should reverse the `all` target. If you call
# make with an argument, like `make clean`, the corresponding target
# gets called.
clean:
    @rm -f $(EXE)

नोट: सुनिश्चित करें कि इंडेंटेशन एक टैब के साथ हैं, न कि चार स्थानों के साथ। अन्यथा, आपको Makefile:10: *** missing separator. Stop. त्रुटि मिलेगी Makefile:10: *** missing separator. Stop.

कमांड-लाइन से इसे चलाने के लिए, निम्नलिखित करें:

$ cd ~/Path/to/project
$ make
$ ls
app  main.cpp  Makefile

$ ./app
Hello World!

$ make clean
$ ls
main.cpp  Makefile

वृद्धिशील बनाता है

जब आपके पास अधिक फाइलें होने लगती हैं, तो आप अधिक उपयोगी हो जाते हैं। क्या हुआ अगर आपने a.cpp को एडिट किया लेकिन b.cpp को नहीं? Recompiling b.cpp में अधिक समय लगेगा।

निम्नलिखित निर्देशिका संरचना के साथ:

.
+-- src
|   +-- a.cpp
|   +-- a.hpp
|   +-- b.cpp
|   +-- b.hpp
+-- Makefile

यह एक अच्छा मेकफाइल होगा:

makefile

CXX=g++
CXXFLAGS=-Wall -Wextra -pedantic
EXE=app

SRCS_GLOB=src/*.cpp
SRCS=$(wildcard $(SRCS_GLOB))
OBJS=$(SRCS:.cpp=.o)

all: $(EXE)

$(EXE): $(OBJS)
    @$(CXX) -o $@ $(OBJS)

depend: .depend

.depend: $(SRCS)
    @-rm -f ./.depend
    @$(CXX) $(CXXFLAGS) -MM $^>>./.depend

clean:
    -rm -f $(EXE)
    -rm $(OBJS)
    -rm *~
    -rm .depend

include .depend

फिर से टैब देखें। यह नया मेकफाइल यह सुनिश्चित करता है कि आप केवल परिवर्तित फ़ाइलों को पुनः संकलित करें, संकलन समय को न्यूनतम करें।

प्रलेखन

मेक पर अधिक जानकारी के लिए, फ्री सॉफ्टवेयर फाउंडेशन द्वारा आधिकारिक दस्तावेज देखें, स्टैकओवरफ्लो दस्तावेज और स्टैकओवरफ्लो पर डमकी के विस्तृत जवाब ।

SCons के साथ भवन

आप Scons - A Python -language सॉफ्टवेयर कंस्ट्रक्शन टूल का उपयोग करके क्रॉस-प्लेटफॉर्म "हैलो वर्ल्ड" C ++ कोड का निर्माण कर सकते हैं।

सबसे पहले, SConstruct नामक एक फ़ाइल SConstruct (ध्यान दें कि SCons डिफ़ॉल्ट रूप से इस सटीक नाम वाली फ़ाइल की तलाश करेगा)। अभी के लिए, फ़ाइल आपके hello.cpp साथ एक निर्देशिका में होनी चाहिए। नई फ़ाइल लाइन में लिखें

 Program('hello.cpp')

अब, टर्मिनल से, scons चलाएं। आपको कुछ ऐसा देखना चाहिए

$ scons
scons: Reading SConscript files ...
scons: done reading SConscript files.
scons: Building targets ...
g++ -o hello.o -c hello.cpp
g++ -o hello hello.o
scons: done building targets.

(हालांकि विवरण आपके ऑपरेटिंग सिस्टम और इंस्टॉल किए गए कंपाइलर के आधार पर अलग-अलग होंगे)।

Environment और Glob कक्षाएं आपको आगे क्या निर्माण करने के लिए कॉन्फ़िगर करने में मदद करेगी। जैसे, SConstruct फ़ाइल

env=Environment(CPPPATH='/usr/include/boost/',
    CPPDEFINES=[],
    LIBS=[],
    SCONS_CXX_STANDARD="c++11"
    )

env.Program('hello', Glob('src/*.cpp'))     

निष्पादन योग्य hello बनाता है, जो src में सभी cpp फ़ाइलों का उपयोग करता है। इसका CPPPATH /usr/include/boost और यह C ++ 11 मानक निर्दिष्ट करता है।

निंजा

परिचय

निंजा बिल्ड सिस्टम को इसकी परियोजना वेबसाइट द्वारा "गति पर ध्यान देने के साथ एक छोटी बिल्ड सिस्टम" के रूप में वर्णित किया गया है। निंजा को सिस्टम फाइल जनरेटर द्वारा निर्मित अपनी फ़ाइलों को बनाने के लिए डिज़ाइन किया गया है, और सीएमके या मेसन जैसे उच्च-स्तरीय बिल्ड सिस्टम प्रबंधकों के विपरीत, सिस्टम बनाने के लिए निम्न-स्तरीय दृष्टिकोण लेता है।

निंजा मुख्य रूप से C ++ और पायथन में लिखा गया है, और क्रोमियम प्रोजेक्ट के लिए SCons बिल्ड सिस्टम के विकल्प के रूप में बनाया गया था।

NMAKE (Microsoft प्रोग्राम रखरखाव उपयोगिता)

परिचय

NMAKE Microsoft द्वारा विकसित एक कमांड-लाइन उपयोगिता है जिसे मुख्य रूप से Microsoft Visual Studio और / या Visual C ++ लाइन टूल के साथ संयोजन में उपयोग किया जाता है।

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

ऑटोटूलस (GNU)

परिचय

ऑटोटूलस प्रोग्रामों का एक समूह है जो किसी दिए गए सॉफ़्टवेयर पैकेज के लिए एक GNU बिल्ड सिस्टम बनाता है। यह एक उपकरण है जो विभिन्न बिल्ड संसाधनों को बनाने के लिए एक साथ काम करता है, जैसे कि मेकफाइल (जीएनयू मेक के साथ उपयोग किया जाना)। इस प्रकार, ऑटोटूलस को एक वास्तविक निर्माण प्रणाली जनरेटर माना जा सकता है।

कुछ उल्लेखनीय ऑटोटूलस कार्यक्रमों में शामिल हैं:

• autoconf
• स्वचालित करें ( make साथ भ्रमित न हों)

सामान्य तौर पर, ऑटोटूलस यूनिक्स-संगत स्क्रिप्ट और मेकफाइल उत्पन्न करने के लिए है ताकि निम्नलिखित कमांड को (साथ ही स्थापित) अधिकांश पैकेज (सरल मामले में) बनाने की अनुमति मिल सके:

./configure && make && make install

जैसे, ऑटोटूलस का कुछ विशेष पैकेज प्रबंधकों के साथ भी संबंध होता है, विशेष रूप से वे जो ऑपरेटिंग सिस्टम से जुड़े होते हैं जो POSIX Standard (s) के अनुरूप होते हैं।