#pragma once x preprocessing guards

[MARCOS UBIRAJARA]

Pessoal,

 

Antes de tudo uma excelente semana para todos,

 

Estou com uma dúvida a respeito do #pragma once, ele realmente impede duplicação de cabecalhos, ou temos que utilizar as guardas de pre-processamento (#ifndef X_H ;#define X_H; conteudo do arquivo X.h; #endif)?

 

Novamente muito grato,

 

Marcos

 

[Renan Greinert]

Sim, realmente impede.

O único detalhe é que os comandos #pragma são específicos de cada compilador.

Embora a maioria dos compiladores modernos suporte "#pragma once", eu ainda prefiro utilizar "ifndef/define/endif" para evitar problemas quando tenho que migrar de ambiente.

Uma vantagem que já li sobre o "#pragma once" é que ele pode ser mais rápido que as guardas de pre-processamento (embora não acredite que isto vá fazer grande diferença no tempo de compilação de um projeto).

Abraço,

Renan Greinert

2012/2/13 MARCOS UBIRAJARA <marcosu...@ig.com.br>

--
Antes de enviar um e-mail para o grupo leia:
http://www.ccppbrasil.org/wiki/Lista:AntesdePerguntar
--~--~---------~--~----~---------------------------------~----------~--~----~
[&] Colabore com a Pesquisa de Preferência de Conteúdo
para Eventos do Grupo C & C++ Brasil:
http://www.surveymonkey.com/s/GBBGTXN
------~----~-------~---~---~---~---~----------------~------------~---------~
[&] C & C++ Brasil - http://www.ccppbrasil.org/
Para sair dessa lista, envie um e-mail para ccppbrasil-...@googlegroups.com
Para mais opções, visite http://groups.google.com/group/ccppbrasil
--~--~---------~--~----~--~-~--~---~----~-----------------~--~----------~
Emprego & carreira: vag...@ccppbrasil.org
http://groups.google.com/group/dev-guys?hl=en

[P.]

Em segunda-feira, 13 de fevereiro de 2012 09h49min56s UTC-2, Renan Greinert escreveu:

 

Uma vantagem que já li sobre o "#pragma once" é que ele pode ser mais rápido que as guardas de pre-processamento (embora não acredite que isto vá fazer grande diferença no tempo de compilação de um projeto).

Se o pré-processador precisa abrir o arquivo, ler o conteúdo inteiro, e então determinar que precisa jogar tudo fora, bastante tempo foi jogado no lixo.

--
 P.

[Wander Lairson Costa]

Em 13 de fevereiro de 2012 11:02, P. <pedro....@gmail.com> escreveu:
> Se o pré-processador precisa abrir o arquivo, ler o conteúdo inteiro, e
> então determinar que precisa jogar tudo fora, bastante tempo foi jogado no
> lixo.
>

Some compilers such as GCC, Clang, and EDG-based compilers include
special speedup code to recognize and optimize the handling of include
guards, and thus little or no speedup benefit is obtained from the use
of #pragma once. [1]

[1] http://en.wikipedia.org/wiki/Pragma_once

--
Best Regards,
Wander Lairson Costa

[Thiago Adams]

On Feb 13, 11:22 am, Wander Lairson Costa <wander.lair...@gmail.com>
wrote:

> Em 13 de fevereiro de 2012 11:02, P. <pedro.lama...@gmail.com> escreveu:
>
> > Se o pré-processador precisa abrir o arquivo, ler o conteúdo inteiro, e
> > então determinar que precisa jogar tudo fora, bastante tempo foi jogado no
> > lixo.
>
> Some compilers such as GCC, Clang, and EDG-based compilers include
> special speedup code to recognize and optimize the handling of include
> guards, and thus little or no speedup benefit is obtained from the use
> of #pragma once. [1]

Além da questão da performance existe o beneficio de limpeza do fonte.
É uma pena não ter um "#once" no padrão.
Eu prefiro o oposto inclusive, todo header seria "#pragma once" e
somente se fosse pedido #multiple que deixaria incluir mais de uma
vez.

Em 11 anos programando em C++ vi apenas um caso aonde precisei incluir
mais de uma vez o mesmo header e este caso não é mais necessário com
variadic templates do C++11.

[Ponto V! - Vinícius Godoy]

O que acho uma pena é ter que explicar para meus alunos que em 2011, o compilador ainda não é capaz de resolver dependências de headers sozinho.

E, ao mesmo tempo que é extremamente burro nesse aspecto, faz milagre com templates.

[]s,

Vinícius

[Adriano dos Santos Fernandes]

On 13-02-2012 14:53, Ponto V! - Vin�cius Godoy wrote:
> O que acho uma pena � ter que explicar para meus alunos que em 2011, o
> compilador ainda n�o � capaz de resolver depend�ncias de headers sozinho.
>
> E, ao mesmo tempo que � extremamente burro nesse aspecto, faz milagre
> com templates.
>

N�o � quest�o de ser capaz, a quest�o fundamental � *compatibilidade*
com o passado.

Adriano

[Reuben Morais]

https://code.google.com/p/include-what-you-use/

-- reuben

[Alisson Prestes]

Seria ótimo ter o "Include What You Use" incorporado às IDE's. 

Alisson Prestes

www.google.com/profiles/javalisson

On Mon, Feb 13, 2012 at 4:04 PM, Reuben Morais <reuben...@gmail.com> wrote:

https://code.google.com/p/include-what-you-use/

-- reuben

[P.]

Em segunda-feira, 13 de fevereiro de 2012 14h53min20s UTC-2, ViniGodoy escreveu:

 

O que acho uma pena é ter que explicar para meus alunos que em 2011, o compilador ainda não é capaz de resolver dependências de headers sozinho.

Isso é causado em parte porque, conceitualmente, o compilador nada tem a ver com diretivas #include, que estão no domínio do pré-processador.

O que você que -- também o Thiago Adams quer no outro email -- não é naturalmente oferecido por um pré-processador textual, mas sim por um sistema de módulos.

O mailing mais recente do  grupo de trabalho do C++ no ISO, inclui uma revisão recente do artigo "Modules for C++" do David Vandevoorde. É plausível que isto se torne objetivo principal na entrega do C++1? junto com "concepts".

Também é um projeto acessível a um pesquisador interessado: implementar "Modules for C++" como proposto. O código-fonte do clang é muitíssimo acessível nesse sentido. Aposto que o Vandevoorde receberia com prazer uma experiência de implementação.

--
 P.

[Thiago Adams]

On Feb 13, 5:36 pm, "P." <pedro.lama...@gmail.com> wrote:
> Em segunda-feira, 13 de fevereiro de 2012 14h53min20s UTC-2, ViniGodoy
> escreveu:
>
> > O que acho uma pena é ter que explicar para meus alunos que em 2011, o
> > compilador ainda não é capaz de resolver dependências de headers sozinho.
>
> Isso é causado em parte porque, conceitualmente, o compilador nada tem a
> ver com diretivas #include, que estão no domínio do pré-processador.
>
> O que você que -- também o Thiago Adams quer no outro email -- não é
> naturalmente oferecido por um pré-processador textual, mas sim por um
> sistema de módulos.

Minha sugestão seria apenas tornar padrão o que já é usado na forma
atual como é o "#pragma once".

[Ponto V! - Vinícius Godoy]

Oi.

Acho que compatibilidade com o passado não tem nada a ver aqui. Você poderia incluir uma diretiva nova, sem fazer com que as velhas deixassem de funcionar.

Você só teria que tomar cuidado se quisesse desenvolver código compatível com um compilador velho (e isso você já tem que fazer de qualquer jeito).


Eu sei que no fundo isso é tratado pelo pré-processador. Mas você ter que "explicar" para sua linguagem como fazer o include numa dependência ciclica até hoje beira o ridículo.

Eu concordo com o Thiago, passou da hora de tornar o #pragma once parte do padrão.

Att,

Vinícius