Я могу написать код C++ без заголовков (повторяющиеся объявления функции)?

Question

Я могу написать код C++ без заголовков (повторяющиеся объявления функции)?

Вы можете расширить вид, чтобы создать собственный вид. Что-то вроде

public class PieView extends View { 
    public PieView(Context context) {
        super(context);
        overlayBitmap = BitmapFactory.decodeResource(getResources(), R.drawable.piechart_shade, 
        null);
        overlayWidth  = overlayBitmap.getWidth();
        setLayoutParams(new LayoutParams(overlayWidth, overlayWidth));      
    }

    @Override     
    protected void onDraw(Canvas canvas) {      
        super.onDraw(canvas);
    }
}

В методе ondraw вы можете использовать canvas.drawBitmap и canvas.drawText для рисования растровых изображений и текста.

Таким образом, вы не требуете разметки кадра, поскольку все находится в одном пользовательском представлении.

Вы можете включить это в свой XML-файл как

<com.raj.PieView android:id="@+id/framelayout" android:layout_marginTop="30dip"      
    android:layout_height="fill_parent" android:layout_width="fill_parent"/>

.

56

header c++ header-files

задан TylerH 10 November 2016 в 21:26

17 ответов

Другие вопросы по тегам:

header c++ header-files

Похожие вопросы:

score 0 · Answer 1

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

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

в качестве примера подумайте об указателях. , передача параметров по значению / по ссылке ... и т. д.

для меня файлы заголовков позволяют мне правильно структурировать мои проекты

score 57 · Answer 2

Use Lzz. It takes a single file and automatically creates a .h and .cpp for you with all the declarations/definitions in the right place.

Lzz is really very powerful, and handles 99% of full C++ syntax, including templates, specializations etc etc etc.

Update 150120:

Newer C++ '11/14 syntax can only be used within Lzz function bodies.

score 0 · Answer 3

Для практических целей нет, это невозможно. Технически да, можно. Но, честно говоря, это злоупотребление языком, и вам следует адаптироваться к языку. Или перейдите на что-нибудь вроде C #.

score 0 · Answer 4

You can carefully lay out your functions so that all of the dependent functions are compiled after their dependencies, but as Nils implied, that is not practical.

Catalin (forgive the missing diacritical marks) also suggested a more practical alternative of defining your methods in the header files. This can actually work in most cases.. especially if you have guards in your header files to make sure they are only included once.

I personally think that header files + declaring functions is much more desirable for 'getting your head around' new code, but that is a personal preference I suppose...

score 2 · Answer 5

To offer a variant on the popular answer of rix0rrr:

// foo.cph

#define INCLUDEMODE
#include "foo.cph"
#include "other.cph"
#undef INCLUDEMODE

void foo()
#if !defined(INCLUDEMODE)
{
   printf("Hello World!\n");
}
#else
;
#endif

void bar()
#if !defined(INCLUDEMODE)
{
    foo();
}
#else
;
#endif

I do not recommend this, bit I think this construction demonstrates the removal of content repetition at the cost of rote repetition. I guess it makes copy-pasta easier? That's not really a virtue.

As with all the other tricks of this nature, a modification to the body of a function will still require recompilation of all files including the file containing that function. Very careful automated tools can partially avoid this, but they would still have to parse the source file to check, and be carefully constructed to not rewrite their output if it's no different.

For other readers: I spent a few minutes trying to figure out include guards in this format, but didn't come up with anything good. Comments?

score 0 · Answer 6

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

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

score 1 · Answer 7

As far as I know, no. Headers are an inherent part of C++ as a language. Don't forget that forward declaration allows the compiler to merely include a function pointer to a compiled object/function without having to include the whole function (which you can get around by declaring a function inline (if the compiler feels like it).

If you really, really, really hate making headers, write a perl-script to autogenerate them, instead. I'm not sure I'd recommend it though.

score 3 · Answer 8

Фактически ... Вы можете записать всю реализацию в файл. Все шаблонные классы определены в файле заголовка без файла cpp.

Вы также можете сохранить их с любыми расширениями, которые захотите. Затем в операторы #include вы должны включить свой файл.

/* mycode.cpp */
#pragma once
#include <iostreams.h>

class myclass {
public:
  myclass();

  dothing();
};

myclass::myclass() { }
myclass::dothing()
{
  // code
}

Затем в другом файле

/* myothercode.cpp */
#pragma once
#include "mycode.cpp"

int main() {
   myclass A;
   A.dothing();
   return 0;
}

Возможно, вам потребуется настроить некоторые правила сборки, но они должны работать.

score 5 · Answer 9

Есть программа для создания файла заголовка. Я никогда этим не пользовался, но, возможно, стоит посмотреть. Например, посмотрите mkhdr ! Предположительно он сканирует файлы C и C ++ и генерирует соответствующие файлы заголовков.

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

score 5 · Answer 10

You have to write function declaration twice, actually (once in header file, once in implementation file). The definition (AKA implementation) of the function will be written once, in the implementation file.

You can write all the code in header files (it is actually a very used practice in generic programming in C++), but this implies that every C/CPP file including that header will imply recompilation of the implementation from those header files.

If you are thinking to a system similar to C# or Java, it is not possible in C++.

score 8 · Answer 11

What I have seen some people like you do is write everything in the headers. That gives your desired property of only having to write the method profiles once.

Personally I think there are very good reasons why it is better to separate declaration and definition, but if this distresses you there is a way to do what you want.

score 8 · Answer 12

There is no practical way to get around headers. The only thing you could do is to put all code into one big c++ file. That will end up in an umaintainable mess, so please don't do it.

At the moment C++ header-files are a nessesary evil. I don't like them, but there is no way around them. I'd love to see some improvements and fresh ideas on the problem though.

Btw - once you've got used to it it's not that bad anymore.. C++ (and any other language as well) has more anoying things.

score 10 · Answer 13

In his article Simple Support for Design by Contract in C++, Pedro Guerreiro stated:

Usually, a C++ class comes in two files: the header file and the definition file. Where should we write the assertions: in the header file, because assertions are specification? Or in the definition file, since they are executable? Or in both, running the risk of inconsistency (and duplicating work)? We recommend, instead, that we forsake the traditional style, and do away with the definition file, using only the header file, as if all functions were defined inline, very much like Java and Eiffel do.

This is such a drastic change from the C++ normality that it risks killing the endeavor at the outset. On the other hand, maintaining two files for each class is so awkward, that sooner or later a C++ development environment will come up that hides that from us, allowing us to concentrate on our classes, without having to worry about where they are хранится.

Это был 2001 год. Я согласился. Сейчас 2009 год, а «среда разработки, которая скрывает это от нас, позволяя нам сосредоточиться на наших классах», еще не появилась. Вместо этого, длительное время компиляции является нормой.

Примечание: Ссылка выше, похоже, теперь мертва. Это полная ссылка на публикацию, как она представлена в разделе Publications веб-сайта автора:

Pedro Guerreiro, Simple Support for Contract in C ++ , TOOLS USA 2001, Proceedings, pages 24-34, IEEE, 2001.

score 27 · Answer 14

Sorry, but there's no such thing as a "best practice" for eliminating headers in C++: it's a bad idea, period. If you hate them that much, you have three choices:

Become intimately familiar with C++ internals and any compilers you're using; you're going to run into different problems than the average C++ developer, and you'll probably need to solve them without a lot of help.
Pick a language you can use "right" without getting depressed
Get a tool to generate them for you; you'll still have headers, but you save some typing effort

score 2 · Answer 15

Вы можете избегать заголовков. Полностью. Но я не рекомендую это.

Вы столкнетесь с некоторыми очень специфическими ограничениями. Один из них заключается в том, что у вас не будет циклических ссылок (у вас не получится, чтобы класс Parent содержал указатель на экземпляр класса ChildNode, а класс ChildNode также содержал указатель на экземпляр класса Parent. Он Должно быть одно или другое.)

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

score 37 · Answer 16

Я чувствовал то же самое, когда начал писать C, поэтому я тоже изучил это. Ответ таков: да, это возможно, и нет, вы не хотите.

Сначала укажите да.

В GCC вы можете сделать это:

// foo.cph

void foo();

#if __INCLUDE_LEVEL__ == 0
void foo() {
   printf("Hello World!\n");
}
#endif

Это имеет предполагаемый эффект: вы объединяете оба заголовка и исходный код в один файл, который может быть включен и связан.

Затем с no:

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

И причина №2, почему вы этого не хотите, и это, вероятно, лучший вариант: скорость компиляции . Как обычно, Исходные файлы C необходимо перекомпилировать только тогда, когда изменяется сам файл или любой из файлов, в которые он входит.

Файл C может часто изменяться, но изменение включает только перекомпиляцию одного файла, который изменился.
Заголовочные файлы определяют интерфейсы, поэтому они не должны меняться так часто. Однако когда они это делают, они запускают перекомпиляцию каждого исходного файла , который их включает.

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

или любой из файлов, которые он содержит изменения.

Файл C может часто меняться, но изменение включает только перекомпиляцию одного измененного файла.
Заголовочные файлы определяют интерфейсы, поэтому они не должны меняться так часто. Однако когда они это делают, они запускают перекомпиляцию каждого исходного файла , который их включает.

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

или любой из файлов, которые он содержит изменения.

Файл C может часто меняться, но изменение включает только перекомпиляцию одного измененного файла.
Заголовочные файлы определяют интерфейсы, поэтому они не должны меняться так часто. Однако когда они это делают, они запускают перекомпиляцию каждого исходного файла , который их включает.

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

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

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

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

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

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

score 0 · Answer 17

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

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