C Passa de parametro parametro static

José Cesar Ribeiro · 13 de fevereiro de 2023

Estou compilando este código porém , quando passo o parametro x para a função ele não inverte o bit ,tem em anexo um arquivo que possui uma função

que não passa parametro o arquivo teste_Y.txt

#include<stdio.h>
#include<conio.h>
char ch;
int i;
int inv()
{
 static int flag=0;
 flag=!flag;
 return flag;
}

int main()
{
printf ("o endereco com valor :\n");
ch=getch();
if (ch=='x')
{
for (i=0;i<10;i++)
{
printf("%d ", inv());
}
}
return 0;
}

Teste 2

#include<stdio.h>
#include<conio.h>
char ch;
int x=0;
int static i;
int inv( int flag)
{
 flag=!flag;
 return flag;
}

int main()
{

printf ("o endereco com valor :\n");
ch=getch();
if (ch=='b')
{
for (i=0;i<10;i++)
{
printf("%d ", inv(x));
}
}
return 0;
}

arfneto · 14 de fevereiro de 2023

4 horas atrás, José Cesar Ribeiro disse:

quando passo o parametro x para a função ele não inverte o bit ,tem em anexo um arquivo que possui uma função

que não passa parametro o arquivo teste_Y.txt

não consegui entender isso

4 horas atrás, José Cesar Ribeiro disse:
int inv()
{
 static int flag=0;
 flag=!flag;
 return flag;
}

0 e !0 são a mesma coisa então não tem sentido nada disso. A função podia ser só

		return 0;

Sobre esse trecho

4 horas atrás, José Cesar Ribeiro disse:
#include<conio.h>
char ch;
int x=0;
int static i;

conio.h é uma coisa dos anos 80 é não é possível que seja importante em 2023. É uma biblioteca derivada do Apple II migrada para o Turbo Pascal e que vinha em dois disquetes de 5.25" com a hoje folclórica capacidade de 1.2 MegaBytes cada um.

E uma variável global ser static num projeto assim não tem sentido. Só tem um fonte. E uma global com o nome de i e outra com o nome de x e uma letrinha chamada ch??? Tudo global? Não deve ter NADA global, muito menos com esses nomes ingênuos. Fuja disso.

4 horas atrás, José Cesar Ribeiro disse:
int inv( int flag)
{
 flag=!flag;
 return flag;
}

Isso está quase ok. Mas porque não retorna logo !flag? pra que duas linhas???

Talvez já tenha notado que é difícil ler !x como not x. Nem todo mundo tem essa dificuldade, mas eu tenho e outros. and, or xor e not deviam ser aceitos também como texto.

É muito mais simples ler

	int x = not flag and 0x20;

que

	int x = !flag & 0x20;

E você pode escrever isso dos dois modos em C se incluir iso646.h desde 1995.

4 horas atrás, José Cesar Ribeiro disse:

int main()
{

printf ("o endereco com valor :\n");
ch=getch();
if (ch=='b')
{
for (i=0;i<10;i++)
{
printf("%d ", inv(x));
}
}
return 0;
}

Essa parte é bem folclórica!

Você vai ler uma letrinha. O prompt é

	"o endereco com valor :\n"

e de alguma forma o cara que rodou o programa deve adivinhar que se ele digitar 'b' o programa vai fazer umas coisas. Para qualquer outra coisa o programa simplesmente termina.

Então pra que ler?

E depois vem um for para contar de 0 a 9 e chamar uma função que deveria inverter o valor.

Só que você mandar inverter o valor de x que é sempre ZERO.

E o for está ruim: declare i dentro do for. E não precisa desse monte de chaves. Algo assim seria mais razoável:

	for (int i=0;i<10;i++)
		printf("inv(%d) = %d\n ", i, inv(i) );

Sugiro rever tudo isso.

devair1010 · 14 de fevereiro de 2023

@José Cesar Ribeiro nesse primeiro código funciona , modificando o valor da variável alternadamente por que tem o modificador "static" , assim dentro da função "inv()" só inicializa a variável flag a primeira vez , e mantém o mesmo valor que ele tem nas próximas chamadas da função ,

#define     _WIN32_WINNT 0x600
#define     _h GetStdHandle(STD_OUTPUT_HANDLE)
#include    <stdio.h>
#include    <stdlib.h>
#include    <conio.h>
#include    <string.h>
#include    <windows.h>
#include    <conio.h>
#include    <iso646.h>  
char ch;
int i;                 /// aqui antes da funCAo main todas as variAveis
                       /// sAo criadas e inicializadas com valor zero .
int inv()
{                      /// usando o modificador "static"
  static int flag = 0; /// só inicializa a variAvel na primeira vez
  flag = ! flag;       /// e matEm o valor nas prOximas vezes .
  return flag;
}
int main( int Argc, char Argv[] )
{
  printf ("o endereco com valor :\n");
  ch = getch();        /// getch da biblioteca conio.h retorna um valor do tipo int
  printf("não importa o valor da tecla digitada , ch= %c\n",ch);
                       /// if (ch=='x')
  {
    for (; i<10; i++)  /// loop bem esquisito usando a variAvel "i" já inicializada .
      printf("%d ", inv());
  }
  return 0;
}

e nesse segundo código , não faz a inversão pretendida , por que a variável "x" permanece sempre com o mesmo valor que é enviado para a função , apesar de usar o modificador "static" na variável "i" Global , e então para fazer a inversão alternadamente , precisa colocar o valor de retorno na variável "x" , para que da próxima vez inverta esse novo valor de "x" , então fiz assim para testar e , estranhamente funcionou :

#define     _WIN32_WINNT 0x600
#define     _h GetStdHandle(STD_OUTPUT_HANDLE)
#include    <stdio.h>
#include    <stdlib.h>
#include    <conio.h>
#include    <string.h>
#include    <windows.h>
#include    <conio.h>
#include    <iso646.h>  ///
char ch;
int x;                 /// nem precisa inicializar ser for zero   
int static i;          /// 
int inv( int flag)
{
  flag = ! flag;
  return   flag;
}

int main( int Argc, char Argv[] )
{

  printf ("o endereco com valor :\n");
  ch=getch();
  /*if (ch=='b')
  {*/
    for (i=0; i<10; i++)
    {
      printf("%d ",x = inv(x)); /// incrIvel assim ,  Mas funciona . !
    }
  /*}*/
  return 0;
}

José Cesar Ribeiro · 14 de fevereiro de 2023

23 horas atrás, José Cesar Ribeiro disse:

Estou compilando este código porém , quando passo o parametro x para a função ele não inverte o bit ,tem em anexo um arquivo que possui uma função

que não passa parametro o arquivo teste_Y.txt

#include<stdio.h>
#include<conio.h>
char ch;
int i;
int inv()
{
 static int flag=0;
 flag=!flag;
 return flag;
}

int main()
{
printf ("o endereco com valor :\n");
ch=getch();
if (ch=='x')
{
for (i=0;i<10;i++)
{
printf("%d ", inv());
}
}
return 0;
}

Teste 2

#include<stdio.h>
#include<conio.h>
char ch;
int x=0;
int static i;
int inv( int flag)
{
 flag=!flag;
 return flag;
}

int main()
{

printf ("o endereco com valor :\n");
ch=getch();
if (ch=='b')
{
for (i=0;i<10;i++)
{
printf("%d ", inv(x));
}
}
return 0;
}

Com um comando de atribuição foi resolvido o código,este código e base para um flag como status de um

sensor de nível de caixa dágua com pic , obrigado bora trabalhar muito obrigado !

arfneto · 15 de fevereiro de 2023

11 horas atrás, devair1010 disse:

modificando o valor da variável alternadamente por que tem o modificador "static"

Não muda "alternadamente" ali. Sempre muda. O que alterna é o resultado já que ! ! a é a mesma coisa que a. E mesmo que não fosse static mudaria. Só que mudaria sempre para o mesmo.

11 horas atrás, devair1010 disse:
int main( int Argc, char Argv[] )

Esse não é o protótipo de main. argv é char** e pode ser visto como char* argv[]

Procure reservar a primeira letra em maiúscula para structs.

11 horas atrás, devair1010 disse:

#include    <iso646.h>  
char ch;
int i;                 /// aqui antes da funCAo main todas as variAveis
                       /// sAo criadas e inicializadas com valor zero .
int inv()
{                      /// usando o modificador "static"
  static int flag = 0; /// só inicializa a variAvel na primeira vez
  flag = ! flag;       /// e matEm o valor nas prOximas vezes .
  return flag;
}

Nesse caso aqui a razão de incluir iso646.h é por o autor do programa achar que é difícil ler ! no meio de uma expressão e assim poder usar coisas como

	int um = not outro;

    printf("o endereco com valor :\n");
    printf("não importa o valor da tecla digitada , ch= %c\n", ch);

Não entendo o que significa a primeira mensagem. Agora a segunda é uma alternativa ao clássico "Tecle ENTER para prosseguir"? Seria uma vantagem?

De todo modo ao menos é mais ilustrativo que esperar apenas um ´b´ para seguir.

Note que não precisa de uma variável para guardar um resultado que não vai ser usado. E incluir a folclórica e absurda conio.h que nem faz parte da linguagem apenas para ler um valor que não vai ser usado pode ser um exagero. Eis um equivalente:

    printf("Tecle ENTER para prosseguir...");
    fgetc(stdin);

11 horas atrás, devair1010 disse:

  {
    for (; i<10; i++)  /// loop bem esquisito usando a variAvel "i" já inicializada .
      printf("%d ", inv());
  }

Esquisito MESMO é ter uma variável global chamada i. Não seria aceito em lugar nenhum. Prefira o simples

    for (int i = 0; i < 10; i++) printf("%d ", inv());

11 horas atrás, devair1010 disse:

      printf("%d ",x = inv(x)); /// incrIvel assim ,  Mas funciona . !

A atribuição é executada antes. Veja a tabela de prioridade dos operadores. Então

vai chamar a função e passar x.
vai receber o valor e redefinir x e
vai usar o x para avaliar o único especificador do printf(), o %d.

Pode usar algo simples assim

#include    <stdio.h>
#include    <iso646.h> 

int inv()
{
    static int flag = 0;
    return flag = not flag;
}

int main(int argc, char * argv[])
{
    printf("Tecle ENTER para prosseguir...");
    fgetc(stdin);
    for (int i = 0; i < 10; i++) printf("%d ", inv());
    return 0;
}

5 horas atrás, José Cesar Ribeiro disse:

quando passo o parametro x para a função ele não inverte o bit ,tem em anexo um arquivo que possui uma função

porque...

5 horas atrás, José Cesar Ribeiro disse:
for (i=0;i<10;i++)
{
printf("%d ", inv(x));
}

Imagino que pretendia inverter o valor de i e não o de x que é constante e vale 0 sempre. E inv() inverte no sentido lógico e dificilmente será o que quer

#include <iso646.h>
#include <stdio.h>
char ch;
int x = 0;
int static i;

Como eu disse, não há sentido em um programa de um arquivo só usar static para uma variável global. Elas são por definição estáticas. E em geral não é aceito nem é esperto usar qualquer coisa global de todo modo.

Ainda sobre inv(x) e os operadores em C

o operador ! em C é um operador lógico. O operador NOT para bits é ~

Não sei se é isso que está buscando. Em C 0 é falso. Só 0 é falso. Todo o resto é verdadeiro. Se quer inverter bits use o operador para bits.

Veja a diferença:

#include <stdio.h>

int inv(int flag)
{
	return ~flag;
}

int main(void)
{
	printf("Tecle ENTER para prosseguir...");
	fgetc(stdin);
	for (int i = 0; i < 16; i++)
      printf("inv(%d 0x%x) = %d 0x%x\n", i, i, inv(i), inv(i) );
	return 0;
}

que mostra

Tecle ENTER para prosseguir...
inv(0 0x0) = -1 0xffffffff
inv(1 0x1) = -2 0xfffffffe
inv(2 0x2) = -3 0xfffffffd
inv(3 0x3) = -4 0xfffffffc
inv(4 0x4) = -5 0xfffffffb
inv(5 0x5) = -6 0xfffffffa
inv(6 0x6) = -7 0xfffffff9
inv(7 0x7) = -8 0xfffffff8
inv(8 0x8) = -9 0xfffffff7
inv(9 0x9) = -10 0xfffffff6
inv(10 0xa) = -11 0xfffffff5
inv(11 0xb) = -12 0xfffffff4
inv(12 0xc) = -13 0xfffffff3
inv(13 0xd) = -14 0xfffffff2
inv(14 0xe) = -15 0xfffffff1
inv(15 0xf) = -16 0xfffffff0

arfneto · 15 de fevereiro de 2023

A menos de uma questão acadêmica ou recreativa claro que não faz sentido escrever uma função para fara fazer inv( x ) ao invés de só escrever ~x

devair1010 · 15 de fevereiro de 2023

@arfneto entendi que @José Cesar Ribeiro pretende usar a condição do bit , que só pode ter dois estados , 1 = ligado , e 0 = desligado , para com isso controlar o funcionamento de uma bomba d'agua .

arfneto · 15 de fevereiro de 2023

23 minutos atrás, devair1010 disse:

@arfneto entendi que @José Cesar Ribeiro pretende usar a condição do bit , que só pode ter dois estados , 1 = ligado , e 0 = desligado , para com isso controlar o funcionamento de uma bomba d'agua .

C não acessa bit. Acessa no mínimo um byte com oito deles. Se esse é o caso de inv() nada tem a ver com not que é um operador lógico ou ~que inverte TODOS.

Veja por exemplo

int inv(int flag)
{
	return ~flag;
}

que inverte os 32 bits num int com 4 bytes.

Se quer inverter um só dos 32 precisa de mais um parâmetro, a posição dele...

E aí se usa um shift com o que se chama de máscara.

Exemplo: inverte o bit 4

	int i = 31;
	printf("i = %d 0x%x\n", i, i);
	i = i ^ 0b10000; // binário: bit 4 = 16
    // ^ = xor operador ou exclusivo
	printf("i = %d 0x%x\n", i, i);

então se fosse usar uma função tinha que passar mais um argumento que seria o bit que quer inverter.

Claro que se for o primeiro é só usar o valor 1

Algo assim

	printf("inverte o bit %d de %d = 0x%x: ", pos, val, val);
	val = val ^ (1 << pos); // ^= operador xor ou exclusivo
	// << operador shift desloca bits para a esquerda
	printf("%d 0x%x\n", val, val);
// de novo
	printf("inverte o bit %d de %d = 0x%x: ", pos, val, val);
	val = val ^ (1 << pos);
	printf("%d 0x%x\n", val, val);

que mostra

inverte o bit 4 de 31 = 0x1f: 15 0xf
inverte o bit 4 de 15 = 0xf: 31 0x1f

Entende (m) a diferença? 1 é o bit 0. Desloca 4 pra esquerda vira... 16. Subtrai de 31 vira 15. E se fizer de novo volta a 31...

Entrar

C Passa de parametro parametro static

Posts recomendados

José Cesar Ribeiro

arfneto

devair1010

José Cesar Ribeiro

arfneto

arfneto

devair1010

arfneto

Crie uma conta ou entre para comentar

Criar uma conta

Entrar

Quem está navegando aqui 0 usuários estão online

Últimos tópicos

Livros

Cursos

Conteúdo recente

Sobre o Clube do Hardware

Direitos autorais

Mais

Fórum

Atividades

Artigos

Análises

Livros

Cursos