Definição de função genérica

def identity(k): return k def cube(k): return pow(k, 3) def square(k): return pow(k,2) def summation(n, term): if n == 0: return 0 else: return term(n) + summation(n-1, term) def sum_cubes(n): return summation(n, cube) if __name__ == "__main__": sum = sum_cubes(4) print(sum) """ In C, We can implement the same using function pointers. Goal is, to perform similar operations(Sum of ..) using single function summation()""" 

void qsort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *)); 

As funções genéricas recebem o tipo de pelo menos um argumento de função genericamente em tempo de compilação. Ou seja, o compilador descobre qual tipo é usado em um determinado local e aplica exatamente esse tipo onde é usado na função. Por exemplo. se você tiver um argumento genérico em sua função que é usado com um operador +, o tipo deve ter métodos apropriados. Para strings / arrays, isso seria em muitos casos uma concatenação e para integer / float uma adição. O compilador pode detectar se aplica a operação correta. Sua rotina C não é genérica nesse sentido, pois é o programador que aplica algumas informações de tamanho e não o compilador que detecta o tipo e usa o tamanho correto.

Por exemplo, em alguma linguagem fictícia

func add(p1,p2) { return p1+p2 } print add("a", "b") // yields "ab" print add(1, 2) // yields 3 

Aqui, o compilador detecta no primeiro caso que duas strings são aplicadas e irá expandir internamente algo como

func add(p1:string, p2:string) 

e tratar o + como concatenação, enquanto no segundo caso ele expandiria

func add(p1:int, p2:int) 

conforme fornecido Parâmetros inteiros. Genérico significa que o compilador gera código individual durante o tempo de compilação. Python, por exemplo, não é tipado e faria esse tipo de substituição durante o tempo de execução. Significa: Python não tem funções genéricas, pois tudo é meio genérico.

Comentários

• Não entendeu. Quer dizer que + é uma função genérica, sintaxe em C ++?
• Funções que levam argumentos de função são de ordem superior função s no mundo Python / JavaScript. Em C, precisamos de ponteiros de função, para o mesmo.
• Veja minha edição acima.
• Então, que tipo de função é summation, Função de ordem superior? e nada mais do que isso?
• Existem muitas definições para o que é genérico. Stroustrup, por exemplo, define como ” programação usando tipos como parâmetros “. Para obter a referência da Wikipedia, I ‘ d prefiro ir para: en.wikipedia.org/wiki/Generic_programming

Vou começar isso da perspectiva de C ++ e, em seguida, trabalhar meu caminho para C.

Em linguagens estaticamente tipadas como C, C ++, Java, etc., uma função “genérica” permite que você especifique as operações da função uma vez , usando marcadores para quaisquer tipos que podem variar entre chamadas diferentes (o que significa que funções como qsort e bsearch são definitivamente não funções genéricas). Idealmente, você também gostaria que o compilador detectasse automaticamente qualquer chamada para esta função genérica e gere o código real conforme necessário.

C ++ torna isso fácil ¹ oferecendo modelos :

template <typename T> T summation( T *values, size_t numValues ) { T result = 0; for ( size_t i = 0; i < numValues; i++ ) result += values[i]; return result; } 

T é um espaço reservado para qualquer tipo ² , então você pode chamá-lo como

int ivals[] = {1,2,3,4,5,6,7,8,9}; double dvals[] = {1,2,3,4,5,6,7,8,9}; int sumi = summation( ivals, 10 ); double sumd = summation( dvals, 10 ); 

Quando o código é compilado, o compilador vê as duas chamadas para summation e deduz os tipos dos argumentos. Para cada tipo diferente, ele gera uma nova instância da função, dando a ela um nome exclusivo:

int summation_i( int *values, size_t numValues ) // actual compilers will generate { // more complex "mangled" names int result = 0; // than this ... } double summation_d( double *values, size_t numValues ) { double result = 0; ... } 

Em seguida, gera o código de modo que o resultado de summation_i seja atribuído a sumi e summation_d seja atribuído a sumd.

C não oferece nada semelhante ao recurso de modelo. Tradicionalmente, atacamos a programação genérica de duas maneiras – usando macros ou usando void * em todos os lugares e delegando operações com reconhecimento de tipo para outras funções.

Aqui está um mau exemplo de uma solução baseada em macro:

#include <stdio.h> #define SUMMATION_DEF(t) \ t summation_##t( t *values, size_t numValues ) \ { \ t result = 0; \ for ( size_t i = 0; i < numValues; i++ ) \ result += values[i]; \ return result; \ } #define SUMMATION(t,x,s) summation_##t(x, s) SUMMATION_DEF(int) SUMMATION_DEF(double) int main( void ) { int ivals[] = {1, 2, 3, 4, 5}; double dvals[] = {1, 2, 3, 4, 5}; int sumi = SUMMATION(int, ivals, 5); double sumd = SUMMATION(double, dvals, 5); printf( "sumi = %d\n", sumi ); printf( "sumd = %f\n", sumd ); return 0; } 

O SUMMATION_DEF é aproximadamente semelhante a um modelo, pois especifica as operações da função, usando o parâmetro macro t como um marcador de posição de tipo. Também usamos t como parte do nome da função – o ## é o operador de colagem de token e o pré-processador expandirá t e acrescente esse valor ao nome da função ³ .

Onde ele difere do C ++ é o fato de que uma macro é apenas uma substituição de texto estúpida. Ela não aciona quaisquer operações especiais por parte do compilador. As instâncias reais da função não são geradas automaticamente com base em quaisquer invocações da macro SUMMATION – temos que gerar explicitamente as funções que queremos (daí o SUMMATION_DEF(int) e SUMMATION_DEF(double) antes de main). Também significa que, quando chamamos summation_xxx por meio da macro SUMMATION, temos que passar o tipo como parte da lista de argumentos da macro, de forma que a função correta seja chamada. Que chatice.

O O padrão C 2011 adicionou a palavra-chave _Generic, que pode tornar a vida um pouco mais fácil a esse respeito:

#include <stdio.h> #define SUMMATION_DEF(t) \ t summation_##t( t *values, size_t numValues ) \ { \ t result = 0; \ for ( size_t i = 0; i < numValues; i++ ) \ result += values[i]; \ return result; \ } #define SUMMATION(x,s) _Generic((x), \ int * : summation_int, \ double * : summation_double \ )(x, s) SUMMATION_DEF(int) SUMMATION_DEF(double) int main( void ) { int ivals[] = {1, 2, 3, 4, 5}; double dvals[] = {1, 2, 3, 4, 5}; int sumi = SUMMATION(ivals, 5); double sumd = SUMMATION(dvals, 5); printf( "sumi = %d\n", sumi ); printf( "sumd = %f\n", sumd ); return 0; } 

O _Generic palavra-chave permite que você avalie expressões com base em tipos ; portanto, se o tipo do primeiro argumento para SUMMATION é int *, chamamos summation_int; é “s it” s double *, chamamos summation_double. Dessa forma, não precisamos especificar o nome do tipo nos argumentos da macro.

A outra abordagem, como você “viu, é usar void * e delegar operações com reconhecimento de tipo a outras funções. Como eu disse acima, que” A programação não é realmente “genérica”, pois você precisa implementar manualmente cada função de comparação para cada tipo. Você não pode “codificar apenas uma vez e pronto. E usando void *, você basicamente joga a segurança de tipo pela janela e no tráfego que se aproxima.

E antes que alguém reclame – não, nenhuma dessas funções de soma verifica ou trata de estouro aritmético. Esse é um assunto para outro dia.

---

1. Para definições suficientemente soltas de “fácil”. A linguagem de metaprogramação usada para dar suporte a modelos é Turing-completa, então você pode fazer coisas * realmente incríveis * e impossíveis de entender com ela.
2. Para definições suficientemente soltas de “qualquer tipo”. Observe que qualquer tipo que você usar deve suportar o operador +=, caso contrário, o compilador gritará com você.
3. Este código será quebrado para tipos como unsigned int ou long double, pois eles têm um espaço em branco no nome. Não sei imediatamente a solução para esse problema e gastei bastante tempo com essa resposta como ela está.