Funções: Divididas em funções de biblioteca e funções personalizadas. Funções
personalizadas, como funções de biblioteca, têm nomes de função, tipos de valor de retorno e parâmetros de função; mas a diferença é que todos eles são projetados por nós mesmos.
Chamada de função: chamada
por valor:
os parâmetros formais e parâmetros reais da função ocupam diferentes blocos de memória, e a modificação dos parâmetros formais não afetará a
chamada de parâmetros reais :
chamada por endereço passa o endereço de memória da variável criada fora da função para Uma forma de chamar uma função com parâmetros de
função.Esta forma de passar parâmetros permite que a função estabeleça uma conexão real com as variáveis externas à função, ou seja, as variáveis externas à função podem ser manipuladas diretamente dentro da função.
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
void Swap2 (int pa, int pb)
{
int tmp = 0;
tmp = pa;
pa = pb;
pb = tmp;
}
int main ()
{
int a = 10;
int b = 20;
printf ("a =% db =% d \ n", a, b);
Swap2 (& a, & b);
printf ("a =% db =% d", a, b);
return 0;
}
// int main ()
// {
// int a = 10;
// int pa = & a;
// pa = 20;
// printf ("% d \ n", a);
// return 0;
//}
// void Swap (int x, int y)
// {
// int tmp = 0;
// tmp = x;
// x = y;
// y = tmp;
//)
//
// int main ()
// {
// int a = 10;
// int b = 20;
// / int tmp = 0; /
// printf ("a =% db =% d \ n", a, b);
// Troca (a, b);
// / tmp = a;
// a = b;
// b = tmp; /
// printf ("a =% db =% d \ n", a, b);
// retornar 0;
//}
Exercício:
1. Escreva uma função para determinar se um número é um número primo.
2. Escreva uma função para determinar se um ano é um ano bissexto.
3. Escreva uma função para realizar a pesquisa binária de um inteiro e um array ordenado
4. Escreva uma função. Cada vez que esta função é chamada, o valor de num será aumentado em 1.
Recursão de função:
a habilidade de programação de um programa que chama a si mesmo é chamada de recursão. Como um algoritmo, a recursão é amplamente usada em linguagens de programação. Um processo ou função tem um método de chamar a si mesmo direta ou indiretamente em sua definição ou descrição. Geralmente, Transforme um problema grande e complexo em um problema menor semelhante ao problema original. A estratégia recursiva requer apenas um pequeno número de programas para descrever os vários cálculos repetitivos necessários no processo de resolução do problema, o que reduz muito o código Quantidade. A principal maneira de pensar sobre a recursão reside nas
duas condições necessárias para transformar coisas grandes em pequenas recursões:
1. Existem restrições. Quando essa condição é atendida, a recursão não continuará.
2. Após cada chamada recursiva, fica cada vez mais perto dessa restrição.
// Recursão da função
// int main ()
// {
// printf ("hehe \ n");
// main (); // estouro da pilha
// return 0;
//}
void print (int n) // 1234
{
if (n> 9) // condição recursiva 1
{
print (n / 10); // condição recursiva 2
}
printf ("% d", n% 10);
}
int main ()
{
unsigned int num = 0;
scanf ("% d", & num); // 1234
print (num);
return 0;
}
Funções de escrita não têm permissão para criar variáveis temporárias, encontre o comprimento da string
#define _CRT_SECLRE_NO_WARNINGS 1
#include <stdio.h>
// Crie uma variável temporária e encontre o comprimento da string
// int my_strlen (char str)
// {
// int count = 0;
// while ( str! = '\ 0')
// {
// count ++;
// str ++;
//}
// retornar contagem;
//}
// A função de criação não permite a criação de variáveis temporárias. Use o método recursivo para encontrar o comprimento da string
int my_strlen (char str)
{
if ( str! = '\ 0')
return 1 + my_strlen (str + 1);
senão
return 0;
// Coisas grandes se transformam em pequenas
// my_strlen ("bit");
// 1 + my_strlen ("it");
// 1 + 1 + my_strlen ("t");
// 1 + 1 + 1 + my_strlen (" \ 0 ");
// 1 + 1 + 1 + 0;
// 3
}
int main ()
{
char arr [] = "bit";
// int len = strlen (arr); // Encontre o comprimento da string
// printf ("% d \ n", len);
// Implementar um strlen Função
int len = my_strlen (arr); // arr é um array, e o array é passado como parâmetros. O que é passado não é o array inteiro, mas o endereço de um elemento
printf ("len =% d \ n", len);
return 0;}
Recursão e iteração
Recursão: a função que se chama é recursão;
iteração: é calcular uma coisa repetidamente e fazer uma coisa repetidamente;
encontrar o fatorial de n
#define _CRT_SECLRE_NO_WARNINGS 1
#include <stdio.h>
//// Loop
// int Fac1 (int n)
// {
// int i = 0;
// int ret = 1;
// for (i = 1, i <= n, i ++)
// {
// ret * = i;
//}
// return ret;
//}
//
// int main ()
// {
// // Encontre o fatorial de
n // int n = 0;
// int ret = 0;
/ / scanf ("% d", & n);
// ret = Fac1 (n); // O modo de loop
// printf ("% d \ n", ret);
//
// return 0;
//}
// 递归
int Fac2 (int n)
{
if (n <= 1)
return 1;
caso contrário,
retorne n * Fac2 (n - 1);
}
int main ()
{
// Encontre o fatorial de
n int n = 0;
int ret = 0;
scanf ("% d", & n);
ret = Fac2 (n); // O modo de loop
printf ("% d \ n ", ret);
return 0;}
Encontre o enésimo número de Fibonacci (sem considerar o estouro)
1 1 2 3 5 8 13 21 34
#define _CRT_SECLRE_NO_WARNINGS 1
#include <stdio.h>
// 迭代
int Fib (int n)
{
int a = 1;
int b = 1;
int c = 0;
enquanto (n> 2)
{
c = a + b;
a = b;
b = c;
n--;
}
return c;
}
int main ()
{
int n = 0;
ret int = 0;
scanf ("% d", & n);
ret = Fib (n);
printf ("ret =% d \ n", ret);
return 0;
}
//// Recursão
// int contagem = 0;
// int Fib (int n)
// {
// if (n == 3) // Teste o número de cálculos para o terceiro número de Fibonacci
// {
/ / count ++;
//}
// int ret = 0;
// if (n <= 2)
// return 1;
// else
//
// return Fib (n-1) + Fib (n-2);
/ /
//}
//
// int main ()
// {
// int n = 0;
// int ret = 0;
// scanf ("% d", & n);
// ret = Fib (n);
// printf ("ret =% d \ n", ret);
// printf ("count =% d \ n", count);
// return 0;
//}
Vários problemas clássicos de recursão de função (pesquisa independente):
1. O problema da Torre de Hanoi
2. O problema do sapo pulando da plataforma
67 perguntas do teste escrito de "Oferta de dedo de espada"