Является gcc-переносной между всеми 64-битными Linux-машинами

Вопрос, который, вероятно, имел в виду ваш профессор, заключается в том, что размеры различных типов в C зависят от платформы. Например, вы сможете хранить гораздо большие числа в переменных long, если они скомпилированы для системы x86-64 Linux, по сравнению с тем, когда они компилируются для i386 Linux. Для правильных программ это не проблема, но если у вас есть программа, например, использует int и long взаимозаменяемо, он может работать нормально на i386, но сбой при работе на 64-битных системах.

Напротив, Java использует одинаковый размер для базовых типов на всех платформах, поэтому избегает этого класса проблемы переносимости.

Если ваша система разработки и удаленная система являются x86-64 Linux, тогда вы не должны сталкиваться с подобными различиями. У вас не должно возникнуть проблем с записью и отладкой ваших программ локально.

Учитывая это, если вы оцениваете, как ваша программа ведет себя на удаленной системе, было бы полезно проверить ваши готовые программы на удаленная система.

Если вы отправляете двоичный файл (я был бы удивлен, если бы вы это сделали), он будет работать (поскольку вы упомянули, что архитектура обеих машин одинакова), скорее всего, если не будет разницы установленных библиотек и вы действительно используете некоторые из них.

Но, полагая, что вам просто нужно отправить исходный код, ваш код будет скомпилирован на удаленном сервере. Это означает, что пока вы не используете какую-либо конкретную библиотеку, присутствующую в вашей системе, ваши программы будут компилироваться и выполняться на удаленном сервере. Но если вы закончите использовать такую ​​библиотеку, вы можете указать флаги привязки (в своем Makefile или указать это явно как часть вашего представления).

Как указывал @ rhn-grg, если обе машины имеют одну и ту же архитектуру процессора, то единственная разница, которая может помешать вашему двоичному файлу работать на другом компьютере, - это библиотеки, с которыми связаны ваши двоичные файлы, они динамически загружают библиотеки, что позволяет сохранить минимальные двоичные файлы, а также позволяет более эффективно использовать ОЗУ, поскольку библиотека загружается один раз, но может использоваться несколькими процессами.

Однако в тех случаях, когда вам необходимо обеспечить «переносимость» двоичного кода, вы можете сказать gcc связать бинарный статически - то есть включить все библиотеки, которые он использует в двоичный код - это приведет к созданию довольно большого двоичного файла, но это не будет зависеть от каких-либо внешних библиотек.

Мне никогда не приходилось это делать, однако теперь, когда вы знаете волшебные слова (статические ссылки, переносимые двоичные файлы), вы можете найти много предложений в Google, например this :

Обычно, когда вы загружаете архив из исходного кода, вы будете делать s tandard "configure; делать; make install ", чтобы построить его. Если вы хотите статически связанный двоичный файл, замените простой« make »на:

make SHARED=0 CC='gcc -static'

. Чтобы узнать, от каких библиотек зависит ваше, вы можете использовать ldd:

$ ldd /bin/bash
    linux-vdso.so.1 =>  (0x00007fff6dbff000)
    libtinfo.so.5 => /lib/x86_64-linux-gnu/libtinfo.so.5 (0x00007f8e37337000)
    libdl.so.2 => /lib/x86_64-linux-gnu/libdl.so.2 (0x00007f8e37133000)
    libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f8e36d75000)
    /lib64/ld-linux-x86-64.so.2 (0x00007f8e37587000)

Вопрос, который, вероятно, имел в виду ваш профессор, заключается в том, что размеры различных типов в C зависят от платформы. Например, вы сможете хранить гораздо большие числа в переменных long, если они скомпилированы для системы x86-64 Linux, по сравнению с тем, когда они компилируются для i386 Linux. Для правильных программ это не проблема, но если у вас есть программа, например, использует int и long взаимозаменяемо, он может работать нормально на i386, но сбой при работе на 64-битных системах.

Напротив, Java использует одинаковый размер для базовых типов на всех платформах, поэтому избегает этого класса проблемы переносимости.

Если ваша система разработки и удаленная система являются x86-64 Linux, тогда вы не должны сталкиваться с подобными различиями. У вас не должно возникнуть проблем с записью и отладкой ваших программ локально.

Учитывая это, если вы оцениваете, как ваша программа ведет себя на удаленной системе, было бы полезно проверить ваши готовые программы на удаленная система.

Если вы отправляете двоичный файл (я был бы удивлен, если бы вы это сделали), он будет работать (поскольку вы упомянули, что архитектура обеих машин одинакова), скорее всего, если не будет разницы установленных библиотек и вы действительно используете некоторые из них.

Но, полагая, что вам просто нужно отправить исходный код, ваш код будет скомпилирован на удаленном сервере. Это означает, что пока вы не используете какую-либо конкретную библиотеку, присутствующую в вашей системе, ваши программы будут компилироваться и выполняться на удаленном сервере. Но если вы закончите использовать такую ​​библиотеку, вы можете указать флаги привязки (в своем Makefile или указать это явно как часть вашего представления).

Как указывал @ rhn-grg, если обе машины имеют одну и ту же архитектуру процессора, то единственная разница, которая может помешать вашему двоичному файлу работать на другом компьютере, - это библиотеки, с которыми связаны ваши двоичные файлы, они динамически загружают библиотеки, что позволяет сохранить минимальные двоичные файлы, а также позволяет более эффективно использовать ОЗУ, поскольку библиотека загружается один раз, но может использоваться несколькими процессами.

Однако в тех случаях, когда вам необходимо обеспечить «переносимость» двоичного кода, вы можете сказать gcc связать бинарный статически - то есть включить все библиотеки, которые он использует в двоичный код - это приведет к созданию довольно большого двоичного файла, но это не будет зависеть от каких-либо внешних библиотек.

Мне никогда не приходилось это делать, однако теперь, когда вы знаете волшебные слова (статические ссылки, переносимые двоичные файлы), вы можете найти много предложений в Google, например this :

Обычно, когда вы загружаете архив из исходного кода, вы будете делать s tandard "configure; делать; make install ", чтобы построить его. Если вы хотите статически связанный двоичный файл, замените простой« make »на:

make SHARED=0 CC='gcc -static'

. Чтобы узнать, от каких библиотек зависит ваше, вы можете использовать ldd:

$ ldd /bin/bash
    linux-vdso.so.1 =>  (0x00007fff6dbff000)
    libtinfo.so.5 => /lib/x86_64-linux-gnu/libtinfo.so.5 (0x00007f8e37337000)
    libdl.so.2 => /lib/x86_64-linux-gnu/libdl.so.2 (0x00007f8e37133000)
    libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f8e36d75000)
    /lib64/ld-linux-x86-64.so.2 (0x00007f8e37587000)

Вопрос, который, вероятно, имел в виду ваш профессор, заключается в том, что размеры различных типов в C зависят от платформы. Например, вы сможете хранить гораздо большие числа в переменных long, если они скомпилированы для системы x86-64 Linux, по сравнению с тем, когда они компилируются для i386 Linux. Для правильных программ это не проблема, но если у вас есть программа, например, использует int и long взаимозаменяемо, он может работать нормально на i386, но сбой при работе на 64-битных системах.

Напротив, Java использует одинаковый размер для базовых типов на всех платформах, поэтому избегает этого класса проблемы переносимости.

Если ваша система разработки и удаленная система являются x86-64 Linux, тогда вы не должны сталкиваться с подобными различиями. У вас не должно возникнуть проблем с записью и отладкой ваших программ локально.

Учитывая это, если вы оцениваете, как ваша программа ведет себя на удаленной системе, было бы полезно проверить ваши готовые программы на удаленная система.

Если вы отправляете двоичный файл (я был бы удивлен, если бы вы это сделали), он будет работать (поскольку вы упомянули, что архитектура обеих машин одинакова), скорее всего, если не будет разницы установленных библиотек и вы действительно используете некоторые из них.

Но, полагая, что вам просто нужно отправить исходный код, ваш код будет скомпилирован на удаленном сервере. Это означает, что пока вы не используете какую-либо конкретную библиотеку, присутствующую в вашей системе, ваши программы будут компилироваться и выполняться на удаленном сервере. Но если вы закончите использовать такую ​​библиотеку, вы можете указать флаги привязки (в своем Makefile или указать это явно как часть вашего представления).

Как указывал @ rhn-grg, если обе машины имеют одну и ту же архитектуру процессора, то единственная разница, которая может помешать вашему двоичному файлу работать на другом компьютере, - это библиотеки, с которыми связаны ваши двоичные файлы, они динамически загружают библиотеки, что позволяет сохранить минимальные двоичные файлы, а также позволяет более эффективно использовать ОЗУ, поскольку библиотека загружается один раз, но может использоваться несколькими процессами.

Однако в тех случаях, когда вам необходимо обеспечить «переносимость» двоичного кода, вы можете сказать gcc связать бинарный статически - то есть включить все библиотеки, которые он использует в двоичный код - это приведет к созданию довольно большого двоичного файла, но это не будет зависеть от каких-либо внешних библиотек.

Мне никогда не приходилось это делать, однако теперь, когда вы знаете волшебные слова (статические ссылки, переносимые двоичные файлы), вы можете найти много предложений в Google, например this :

Обычно, когда вы загружаете архив из исходного кода, вы будете делать s tandard "configure; делать; make install ", чтобы построить его. Если вы хотите статически связанный двоичный файл, замените простой« make »на:

make SHARED=0 CC='gcc -static'

. Чтобы узнать, от каких библиотек зависит ваше, вы можете использовать ldd:

$ ldd /bin/bash
    linux-vdso.so.1 =>  (0x00007fff6dbff000)
    libtinfo.so.5 => /lib/x86_64-linux-gnu/libtinfo.so.5 (0x00007f8e37337000)
    libdl.so.2 => /lib/x86_64-linux-gnu/libdl.so.2 (0x00007f8e37133000)
    libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f8e36d75000)
    /lib64/ld-linux-x86-64.so.2 (0x00007f8e37587000)

Вопрос, который, вероятно, имел в виду ваш профессор, заключается в том, что размеры различных типов в C зависят от платформы. Например, вы сможете хранить гораздо большие числа в переменных long, если они скомпилированы для системы x86-64 Linux, по сравнению с тем, когда они компилируются для i386 Linux. Для правильных программ это не проблема, но если у вас есть программа, например, использует int и long взаимозаменяемо, он может работать нормально на i386, но сбой при работе на 64-битных системах.

Напротив, Java использует одинаковый размер для базовых типов на всех платформах, поэтому избегает этого класса проблемы переносимости.

Если ваша система разработки и удаленная система являются x86-64 Linux, тогда вы не должны сталкиваться с подобными различиями. У вас не должно возникнуть проблем с записью и отладкой ваших программ локально.

С учетом этого, если вы оцениваете, как ваша программа ведет себя на удаленной системе, было бы полезно проверить ваши готовые программы на удаленная система.

Если вы отправляете двоичный файл (я был бы удивлен, если бы вы это сделали), он будет работать (поскольку вы упомянули, что архитектура обеих машин одинакова), скорее всего, если не будет разницы установленных библиотек и вы действительно используете некоторые из них.

Но, полагая, что вам просто нужно отправить исходный код, ваш код будет скомпилирован на удаленном сервере. Это означает, что пока вы не используете какую-либо конкретную библиотеку, присутствующую в вашей системе, ваши программы будут компилироваться и выполняться на удаленном сервере. Но если вы закончите использовать такую ​​библиотеку, вы можете указать флаги привязки (в своем Makefile или указать это явно как часть вашего представления).

Как указывал @ rhn-grg, если обе машины имеют одну и ту же архитектуру процессора, то единственная разница, которая может помешать вашему двоичному файлу работать на другом компьютере, - это библиотеки, с которыми связаны ваши двоичные файлы, они динамически загружают библиотеки, что позволяет сохранить минимальные двоичные файлы, а также позволяет более эффективно использовать ОЗУ, поскольку библиотека загружается один раз, но может использоваться несколькими процессами.

Однако в тех случаях, когда вам необходимо обеспечить «переносимость» двоичного кода, вы можете сказать gcc связать бинарный статически - то есть включить все библиотеки, которые он использует в двоичный код - это приведет к созданию довольно большого двоичного файла, но это не будет зависеть от каких-либо внешних библиотек.

Мне никогда не приходилось это делать, однако теперь, когда вы знаете волшебные слова (статические ссылки, переносимые двоичные файлы), вы можете найти много предложений в Google, например this :

Обычно, когда вы загружаете архив из исходного кода, вы будете делать s tandard "configure; делать; make install ", чтобы построить его. Если вы хотите статически связанный двоичный файл, замените простой« make »на:

make SHARED=0 CC='gcc -static'

. Чтобы узнать, от каких библиотек зависит ваше, вы можете использовать ldd:

$ ldd /bin/bash
    linux-vdso.so.1 =>  (0x00007fff6dbff000)
    libtinfo.so.5 => /lib/x86_64-linux-gnu/libtinfo.so.5 (0x00007f8e37337000)
    libdl.so.2 => /lib/x86_64-linux-gnu/libdl.so.2 (0x00007f8e37133000)
    libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f8e36d75000)
    /lib64/ld-linux-x86-64.so.2 (0x00007f8e37587000)

Вопрос, который, вероятно, имел в виду ваш профессор, заключается в том, что размеры различных типов в C зависят от платформы. Например, вы сможете хранить гораздо большие числа в переменных long, если они скомпилированы для системы x86-64 Linux, по сравнению с тем, когда они компилируются для i386 Linux. Для правильных программ это не проблема, но если у вас есть программа, например, использует int и long взаимозаменяемо, он может работать нормально на i386, но сбой при работе на 64-битных системах.

Напротив, Java использует одинаковый размер для базовых типов на всех платформах, поэтому избегает этого класса проблемы переносимости.

Если ваша система разработки и удаленная система являются x86-64 Linux, тогда вы не должны сталкиваться с подобными различиями. У вас не должно возникнуть проблем с записью и отладкой ваших программ локально.

С учетом этого, если вы оцениваете, как ваша программа ведет себя на удаленной системе, было бы полезно проверить ваши готовые программы на удаленная система.

Если вы отправляете двоичный файл (я был бы удивлен, если бы вы это сделали), он будет работать (поскольку вы упомянули, что архитектура обеих машин одинакова), скорее всего, если не будет разницы установленных библиотек и вы действительно используете некоторые из них.

Но, полагая, что вам просто нужно отправить исходный код, ваш код будет скомпилирован на удаленном сервере. Это означает, что пока вы не используете какую-либо конкретную библиотеку, присутствующую в вашей системе, ваши программы будут компилироваться и выполняться на удаленном сервере. Но если вы закончите использовать такую ​​библиотеку, вы можете указать флаги привязки (в своем Makefile или указать это явно как часть вашего представления).

Как указывал @ rhn-grg, если обе машины имеют одну и ту же архитектуру процессора, то единственная разница, которая может помешать вашему двоичному файлу работать на другом компьютере, - это библиотеки, с которыми связаны ваши двоичные файлы, они динамически загружают библиотеки, что позволяет сохранить минимальные двоичные файлы, а также позволяет более эффективно использовать ОЗУ, поскольку библиотека загружается один раз, но может использоваться несколькими процессами.

Однако в тех случаях, когда вам необходимо обеспечить «переносимость» двоичного кода, вы можете сказать gcc связать бинарный статически - то есть включить все библиотеки, которые он использует в двоичный код - это приведет к созданию довольно большого двоичного файла, но это не будет зависеть от каких-либо внешних библиотек.

Мне никогда не приходилось это делать, однако теперь, когда вы знаете волшебные слова (статические ссылки, переносимые двоичные файлы), вы можете найти много предложений в Google, например this :

Обычно, когда вы загружаете архив из исходного кода, вы будете делать s tandard "configure; делать; make install ", чтобы построить его. Если вы хотите статически связанный двоичный файл, замените простой« make »на:

make SHARED=0 CC='gcc -static'

. Чтобы узнать, от каких библиотек зависит ваше, вы можете использовать ldd:

$ ldd /bin/bash
    linux-vdso.so.1 =>  (0x00007fff6dbff000)
    libtinfo.so.5 => /lib/x86_64-linux-gnu/libtinfo.so.5 (0x00007f8e37337000)
    libdl.so.2 => /lib/x86_64-linux-gnu/libdl.so.2 (0x00007f8e37133000)
    libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f8e36d75000)
    /lib64/ld-linux-x86-64.so.2 (0x00007f8e37587000)

Вопрос, который, вероятно, имел в виду ваш профессор, заключается в том, что размеры различных типов в C зависят от платформы. Например, вы сможете хранить гораздо большие числа в переменных long, если они скомпилированы для системы x86-64 Linux, по сравнению с тем, когда они компилируются для i386 Linux. Для правильных программ это не проблема, но если у вас есть программа, например, использует int и long взаимозаменяемо, он может работать нормально на i386, но сбой при работе на 64-битных системах.

Напротив, Java использует одинаковый размер для базовых типов на всех платформах, поэтому избегает этого класса проблемы переносимости.

Если ваша система разработки и удаленная система являются x86-64 Linux, тогда вы не должны сталкиваться с подобными различиями. У вас не должно возникнуть проблем с записью и отладкой ваших программ локально.

Учитывая это, если вы оцениваете, как ваша программа ведет себя на удаленной системе, было бы полезно проверить ваши готовые программы на удаленная система.

Если вы отправляете двоичный файл (я был бы удивлен, если бы вы это сделали), он будет работать (поскольку вы упомянули, что архитектура обеих машин одинакова), скорее всего, если не будет разницы установленных библиотек и вы действительно используете некоторые из них.

Но, полагая, что вам просто нужно отправить исходный код, ваш код будет скомпилирован на удаленном сервере. Это означает, что пока вы не используете какую-либо конкретную библиотеку, присутствующую в вашей системе, ваши программы будут компилироваться и выполняться на удаленном сервере. Но если вы закончите использовать такую ​​библиотеку, вы можете указать флаги привязки (в своем Makefile или указать это явно как часть вашего представления).

Как указывал @ rhn-grg, если обе машины имеют одну и ту же архитектуру процессора, то единственная разница, которая может помешать вашему двоичному файлу работать на другом компьютере, - это библиотеки, с которыми связаны ваши двоичные файлы, они динамически загружают библиотеки, что позволяет сохранить минимальные двоичные файлы, а также позволяет более эффективно использовать ОЗУ, поскольку библиотека загружается один раз, но может использоваться несколькими процессами.

Однако в тех случаях, когда вам необходимо обеспечить «переносимость» двоичного кода, вы можете сказать gcc связать бинарный статически - то есть включить все библиотеки, которые он использует в двоичный код - это приведет к созданию довольно большого двоичного файла, но это не будет зависеть от каких-либо внешних библиотек.

Мне никогда не приходилось это делать, однако теперь, когда вы знаете волшебные слова (статические ссылки, переносимые двоичные файлы), вы можете найти много предложений в Google, например this :

Обычно, когда вы загружаете архив из исходного кода, вы будете делать s tandard "configure; делать; make install ", чтобы построить его. Если вы хотите статически связанный двоичный файл, замените простой« make »на:

make SHARED=0 CC='gcc -static'

. Чтобы узнать, от каких библиотек зависит ваше, вы можете использовать ldd:

$ ldd /bin/bash
    linux-vdso.so.1 =>  (0x00007fff6dbff000)
    libtinfo.so.5 => /lib/x86_64-linux-gnu/libtinfo.so.5 (0x00007f8e37337000)
    libdl.so.2 => /lib/x86_64-linux-gnu/libdl.so.2 (0x00007f8e37133000)
    libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f8e36d75000)
    /lib64/ld-linux-x86-64.so.2 (0x00007f8e37587000)

Вопрос, который, вероятно, имел в виду ваш профессор, заключается в том, что размеры различных типов в C зависят от платформы. Например, вы сможете хранить гораздо большие числа в переменных long, если они скомпилированы для системы x86-64 Linux, по сравнению с тем, когда они компилируются для i386 Linux. Для правильных программ это не проблема, но если у вас есть программа, например, использует int и long взаимозаменяемо, он может работать нормально на i386, но сбой при работе на 64-битных системах.

Напротив, Java использует одинаковый размер для базовых типов на всех платформах, поэтому избегает этого класса проблемы переносимости.

Если ваша система разработки и удаленная система являются x86-64 Linux, тогда вы не должны сталкиваться с подобными различиями. У вас не должно возникнуть проблем с записью и отладкой ваших программ локально.

Учитывая это, если вы оцениваете, как ваша программа ведет себя на удаленной системе, было бы полезно проверить ваши готовые программы на удаленная система.

Если вы отправляете двоичный файл (я был бы удивлен, если бы вы это сделали), он будет работать (поскольку вы упомянули, что архитектура обеих машин одинакова), скорее всего, если не будет разницы установленных библиотек и вы действительно используете некоторые из них.

Но, полагая, что вам просто нужно отправить исходный код, ваш код будет скомпилирован на удаленном сервере. Это означает, что пока вы не используете какую-либо конкретную библиотеку, присутствующую в вашей системе, ваши программы будут компилироваться и выполняться на удаленном сервере. Но если вы закончите использовать такую ​​библиотеку, вы можете указать флаги привязки (в своем Makefile или указать это явно как часть вашего представления).

Как указывал @ rhn-grg, если обе машины имеют одну и ту же архитектуру процессора, то единственная разница, которая может помешать вашему двоичному файлу работать на другом компьютере, - это библиотеки, с которыми связаны ваши двоичные файлы, они динамически загружают библиотеки, что позволяет сохранить минимальные двоичные файлы, а также позволяет более эффективно использовать ОЗУ, поскольку библиотека загружается один раз, но может использоваться несколькими процессами.

Однако в тех случаях, когда вам необходимо обеспечить «переносимость» двоичного кода, вы можете сказать gcc связать бинарный статически - то есть включить все библиотеки, которые он использует в двоичный код - это приведет к созданию довольно большого двоичного файла, но это не будет зависеть от каких-либо внешних библиотек.

Мне никогда не приходилось это делать, однако теперь, когда вы знаете волшебные слова (статические ссылки, переносимые двоичные файлы), вы можете найти много предложений в Google, например this :

Обычно, когда вы загружаете архив из исходного кода, вы будете делать s tandard "configure; делать; make install ", чтобы построить его. Если вы хотите статически связанный двоичный файл, замените простой« make »на:

make SHARED=0 CC='gcc -static'

. Чтобы узнать, от каких библиотек зависит ваше, вы можете использовать ldd:

$ ldd /bin/bash
    linux-vdso.so.1 =>  (0x00007fff6dbff000)
    libtinfo.so.5 => /lib/x86_64-linux-gnu/libtinfo.so.5 (0x00007f8e37337000)
    libdl.so.2 => /lib/x86_64-linux-gnu/libdl.so.2 (0x00007f8e37133000)
    libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f8e36d75000)
    /lib64/ld-linux-x86-64.so.2 (0x00007f8e37587000)