Что такое «статическая» функция в C?

Вопрос был о равнине с функции, а не C ++ static методы, как пояснено в комментариях.

Я понимаю, что такое staticпеременная, но что такое staticфункция?

И почему, если я объявляю функцию, скажем void print_matrix, скажем так a.c(БЕЗ a.h) и включаю "a.c"- я получаю "print_matrix@@....) already defined in a.obj", НО, если я объявлю ее так, как static void print_matrixона компилируется?

ОБНОВЛЕНИЕ Просто чтобы прояснить ситуацию - я знаю, что в том числе .cплохо, как многие из вас указали. Я просто делаю это, чтобы временно освободить место, main.cпока у меня не появится лучшее представление о том, как сгруппировать все эти функции в нужные файлы .hи .cфайлы. Просто временное, быстрое решение.

staticфункции - это функции, которые видны только другим функциям в том же файле (точнее, той же единице перевода ).

РЕДАКТИРОВАТЬ : Для тех, кто думал, что автор вопросов означал «метод класса»: так как вопрос помечен, Cон означает обычную старую функцию C. Для методов класса (C ++ / Java / ...) staticозначает, что этот метод может быть вызван для самого класса, экземпляр этого класса не требуется.

Существует большая разница между статическими функциями в C и статическими функциями-членами в C ++. В Си статическая функция не видна за пределами ее единицы перевода, то есть объектного файла, в который она компилируется. Другими словами, создание статической функции ограничивает область ее применения. Вы можете думать о статической функции как о «закрытой» для ее файла * .c (хотя это не совсем правильно).

В C ++ «static» также может применяться к функциям-членам и данным-членам классов. Статический член данных также называется «переменной класса», в то время как нестатический член данных является «переменной экземпляра». Это терминология Smalltalk. Это означает, что существует только одна копия статического члена данных, совместно используемого всеми объектами класса, в то время как каждый объект имеет свою собственную копию нестатического члена данных. Таким образом, статический член данных по сути является глобальной переменной, то есть членом класса.

Нестатические функции-члены могут получить доступ ко всем данным-членам класса: статическим и нестатическим. Статические функции-члены могут работать только со статическими данными-членами.

Один из способов думать об этом состоит в том, что в C ++ статические члены-данные и статические функции-члены принадлежат не какому-либо объекту, а всему классу.

Существует два варианта использования ключевого слова static в отношении функций в C ++.

Первый - пометить функцию как имеющую внутреннюю связь, чтобы на нее нельзя было ссылаться в других единицах перевода. Это использование устарело в C ++. Безымянные пространства имен являются предпочтительными для этого использования.

// inside some .cpp file:

static void foo();    // old "C" way of having internal linkage

// C++ way:
namespace
{
   void this_function_has_internal_linkage()
   {
      // ...
   }
}

Второе использование в контексте класса. Если класс имеет статическую функцию-член, это означает, что функция является членом класса (и имеет обычный доступ к другим членам), но ее не нужно вызывать через определенный объект. Другими словами, внутри этой функции нет указателя «this».

Пример минимальной работоспособной многофайловой области

Здесь я проиллюстрирую, как staticвлияет область определения функций в нескольких файлах.

переменный ток

#include <stdio.h>

/* Undefined behavior: already defined in main.
 * Binutils 2.24 gives an error and refuses to link.
 * /programming/27667277/why-does-borland-compile-with-multiple-definitions-of-same-object-in-different-c
 */
/*void f() { puts("a f"); }*/

/* OK: only declared, not defined. Will use the one in main. */
void f(void);

/* OK: only visible to this file. */
static void sf() { puts("a sf"); }

void a() {
    f();
    sf();
}

main.c

#include <stdio.h>

void a(void);        

void f() { puts("main f"); }

static void sf() { puts("main sf"); }

void m() {
    f();
    sf();
}

int main() {
    m();
    a();
    return 0;
}

GitHub вверх по течению .

Скомпилируйте и запустите:

gcc -c a.c -o a.o
gcc -c main.c -o main.o
gcc -o main main.o a.o
./main

Вывод:

main f
main sf
main f
a sf

интерпретация

• Есть две отдельные функции sf, по одной для каждого файла
• есть одна общая функция f

Как обычно, чем меньше область действия, тем лучше, поэтому всегда объявляйте функции, staticесли можете.

В программировании на C файлы часто используются для представления «классов», а staticфункции представляют «частные» методы класса.

Обычный шаблон C - это передача thisструктуры в качестве первого аргумента «метода», что в основном и делает C ++ под капотом.

Что говорят об этом стандарты

C99 N1256 черновик 6.7.1 « Спецификаторы класса хранения» говорит, что staticэто «спецификатор класса хранения».

6.2.2 / 3 «Связи идентификаторов» говорит, что staticподразумевает internal linkage:

Если объявление идентификатора области файла для объекта или функции содержит статический спецификатор класса хранения, идентификатор имеет внутреннюю связь.

и 6.2.2 / 2 говорит, что internal linkageведет себя как в нашем примере:

В наборе единиц перевода и библиотек, составляющих целую программу, каждое объявление определенного идентификатора с внешней связью обозначает один и тот же объект или функцию. В пределах одной единицы перевода каждое объявление идентификатора с внутренней связью обозначает один и тот же объект или функцию.

где «единица перевода» - исходный файл после предварительной обработки.

Как GCC реализует это для ELF (Linux)?

С STB_LOCALпривязкой.

Если мы скомпилируем:

int f() { return 0; }
static int sf() { return 0; }

и разберите таблицу символов с помощью:

readelf -s main.o

вывод содержит:

Num:    Value          Size Type    Bind   Vis      Ndx Name
  5: 000000000000000b    11 FUNC    LOCAL  DEFAULT    1 sf
  9: 0000000000000000    11 FUNC    GLOBAL DEFAULT    1 f

таким образом, связывание - единственное существенное различие между ними. Valueэто просто их смещение в .bssразделе, поэтому мы ожидаем, что он будет отличаться.

STB_LOCALзадокументировано в спецификации ELF по адресу http://www.sco.com/developers/gabi/2003-12-17/ch4.symtab.html :

STB_LOCAL Локальные символы не видны за пределами объектного файла, содержащего их определение. Локальные символы с одинаковыми именами могут существовать в нескольких файлах, не мешая друг другу

что делает его идеальным выбором для представления static.

Функции без статики есть STB_GLOBAL, а в спецификации сказано:

Когда редактор ссылок объединяет несколько перемещаемых объектных файлов, он не позволяет использовать несколько определений символов STB_GLOBAL с одним и тем же именем.

что согласуется с ошибками ссылок в нескольких нестатических определениях.

Если мы запускаем оптимизацию с помощью -O3, sfсимвол полностью удаляется из таблицы символов: его нельзя использовать извне. TODO зачем вообще хранить статические функции в таблице символов, когда нет оптимизации? Могут ли они быть использованы для чего-либо?

Смотрите также

• То же самое для переменных: https://stackoverflow.com/a/14339047/895245
• externявляется противоположностью static, и функции уже externпо умолчанию: Как я могу использовать extern для обмена переменными между исходными файлами?

C ++ анонимные пространства имен

В C ++ вы можете захотеть использовать анонимные пространства имен вместо статических, что дает аналогичный эффект, но дополнительно скрывает определения типов: Безымянный / анонимный пространства имен против статических функций

Ниже приведены простые функции C - в классе C ++ модификатор «static» имеет другое значение.

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

В C каждый «модуль» (комбинация sample.c и sample.h) компилируется независимо, и после этого каждый из этих скомпилированных объектных файлов (sample.o) связывается компоновщиком с исполняемым файлом.

Допустим, у вас есть несколько файлов, которые вы включаете в свой основной файл, и два из них имеют функцию, которая используется только для удобства, add(int a, b)- для удобства компилятор легко создает объектные файлы для этих двух модулей, но компоновщик выдаст ошибку, потому что он находит две функции с одинаковыми именами и не знает, какую из них использовать (даже если нечего связывать, потому что они не используются где-то еще, кроме как в его собственном файле).

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

Первое: вообще плохая идея включать .cppфайл в другой файл - это приводит к таким проблемам :-) Обычный способ - создать отдельные модули компиляции и добавить файл заголовка для включенного файла.

Во-вторых:

C ++ имеет здесь некоторую запутанную терминологию - я не знал об этом, пока не было указано в комментариях.

а) static functions- унаследовано от C, и о чем вы тут говорите. Вне любого класса. Статическая функция означает, что она не видна вне текущего модуля компиляции - поэтому в вашем случае a.obj имеет копию, а ваш другой код имеет независимую копию. (Вздутие конечного исполняемого файла с несколькими копиями кода).

б) static member function- что объектная ориентация называет статическим методом . Живет внутри класса. Вы вызываете это с помощью класса, а не через экземпляр объекта.

Эти два разных определения статических функций совершенно разные. Будьте осторожны - здесь будут драконы.

статические определения функций помечают этот символ как внутренний. Таким образом, он не будет виден для ссылок извне, а только для функций в том же модуле компиляции, обычно в том же файле.

Статическая функция - это функция, которая может быть вызвана в самом классе, в отличие от экземпляра класса.

Например, нестатический будет:

Person* tom = new Person();
tom->setName("Tom");

Этот метод работает с экземпляром класса, а не с самим классом. Однако у вас может быть статический метод, который может работать без экземпляра. Это иногда используется в шаблоне Factory:

Person* tom = Person::createNewPerson();

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

Стандарт, вероятно, говорит что-то вроде:

«Каждая программа должна содержать ровно одно определение каждой не встроенной функции или объекта, которая используется в этой программе; диагностика не требуется».

Это C-взгляд на статические функции. Это не рекомендуется в C ++, однако.

Кроме того, в C ++ вы можете объявлять статические функции-члены. В основном это метафункции, то есть они не описывают / не изменяют поведение / состояние конкретного объекта, а воздействуют на весь класс. Кроме того, это означает, что вам не нужно создавать объект для вызова статической функции-члена. Кроме того, это также означает, что вы получаете доступ к статическим переменным-членам только из такой функции.

Я бы добавил к примеру Parrot шаблон Singleton, который основан на статической функции-члене такого типа, чтобы получать / использовать один объект в течение всей жизни программы.

Ответ на статическую функцию зависит от языка:

1) В языках без OOPS, таких как C, это означает, что функция доступна только внутри файла, в котором она определена.

2) В языках с OOPS, таких как C ++, это означает, что функция может быть вызвана непосредственно в классе без создания его экземпляра.

Так как статическая функция видна только в этом файле. Фактически, компилятор может сделать некоторую оптимизацию для вас, если вы объявите «static» какой-либо функции.

Вот простой пример.

main.c

#include <stdio.h>

static void test() 
{
    ghost(); // This is an unexist function.
}

int main()
{
    int ret = 0;

#ifdef TEST
#else
    test();
#endif
    return (ret);
} 

И скомпилировать с

gcc -o main main.c

Вы увидите, что это не удалось. Потому что вы даже не реализуете функцию ghost ().

Но что, если мы используем следующую команду?

gcc -DTEST -O2 -o main main.c

Это успех , и эту программу можно выполнить нормально.

Почему? Есть 3 ключевых момента.

1. -O2: уровень оптимизации компилятора не менее 2.
2. -DTEST: определить TEST, поэтому test () не будет вызываться.
3. Определен «статический» для теста ().

Только если все эти 3 условия выполнены, вы можете пройти компиляцию. Из-за этого «статического» объявления компилятор может подтвердить, что test () НИКОГДА не будет вызываться в другом файле. Ваш компилятор может удалить test () при компиляции. Поскольку нам не нужен test (), не имеет значения, определен или реализован ghost ().

« Что такое« static»функция в C? »

Давайте начнем с самого начала.

Все это основано на том, что называется «связь»:

« Идентификатор, объявленный в разных областях или в одной и той же области более одного раза, может быть создан для ссылки на один и тот же объект или функцию с помощью процесса, называемого связыванием. 29) Существует три вида связывания: внешнее, внутреннее и ни одного ».

Источник: С18, 6.2.2 / 1.

«В наборе единиц перевода и библиотек, составляющих целую программу, каждое объявление определенного идентификатора с внешней связью обозначает один и тот же объект или функцию. В пределах одной единицы перевода каждое объявление идентификатора с внутренней связью обозначает один и тот же объект или функцию . Каждое объявление идентификатора без привязки обозначает уникальный объект. "

Источник: С18, 6.2.2 / 2.

Если функция определена без спецификатора класса хранилища, функция externпо умолчанию имеет все связи:

«Если объявление идентификатора для функции не имеет спецификатора класса хранения, его связь определяется точно так, как если бы он был объявлен с помощью спецификатора класса хранения extern ».

Источник: С18, 6.2.2 / 5.

Это означает, что - если ваша программа состоит из нескольких единиц перевода / исходных файлов ( .cили .cpp) - функция видна во всех единицах перевода / исходных файлах, которые есть в вашей программе.

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

В C и C ++ staticквалификатор класса хранения, примененный к функции в области видимости файла (не статическая функция-член класса в C ++ или функция в другом блоке), теперь помогает и означает, что соответствующая функция видна только внутри модуль перевода / исходный файл, в котором он был определен, а не в других TLU / файлах.

«Если объявление идентификатора области файла для объекта или функции содержит статический спецификатор класса хранения , идентификатор имеет внутреннюю связь. 30)»

---

30) Объявление функции может содержать спецификатор класса хранения только в том случае, если он находится в области видимости файла; см. 6.7.1.

Источник: С18, 6.2.2 / 3.

Таким образом, staticфункция имеет смысл только тогда, когда:

1. Ваша программа содержит несколько единиц перевода / исходных файлов ( .cили .cpp).

   а также

2. Вы хотите ограничить область действия функции файлом, в котором определена определенная функция.

Если оба эти требования не совпадают, вам не нужно задумываться о том, чтобы квалифицировать функцию как static.

Примечания стороны:

• Как уже упоминалось, staticфункция A не имеет абсолютно никакой разницы между C и C ++, поскольку это функция C ++, унаследованная от C.

  Неважно, что в сообществе C ++ идут душераздирающие дебаты об обесценивании квалифицирующих функций staticпо сравнению с использованием вместо этого безымянных пространств имен , сначала инициализированных неуместным абзацем в стандарте C ++ 03, объявляя об использовании статические функции как устаревшие, которые вскоре были пересмотрены самим комитетом и удалены в C ++ 11.

  Это было предметом различных вопросов SO:

  Безымянное / анонимное пространство имен против статических функций

  Превосходство безымянного пространства имен над статическим?

  Почему безымянное пространство имен является «превосходящей» альтернативой статическому?

  Устаревание статического ключевого слова ... не более?

  На самом деле, это не считается устаревшим в соответствии со стандартом C ++. Таким образом, использование staticфункций все еще законно. Даже если у неназванных пространств имен есть свои преимущества, обсуждение использования или неиспользования статических функций в C ++ является предметом единого мнения (основанного на мнениях), и тот, который не подходит для данного веб-сайта.