c语言中的位运算是怎么判别的？

i_p:i的值;

| 按位或 两个相应的二进制位中只要有一个为1，该位的结果值为1

一元运算符()将一个输入取反_一元运算符什么将一个输入取反

一元运算符()将一个输入取反_一元运算符什么将一个输入取反

一元运算符()将一个输入取反_一元运算符什么将一个输入取反

C语言诞生于美国的贝尔实验室，由丹尼斯·里奇（Dennis MacAlistair Ritchie）以肯尼斯·蓝·汤普森（Kenn Lane Thompson）设计的B语言为基础发展而来，在它的主体设计完成后，汤普森和里奇用它完全重写了UNIX，且随着UNIX的发展，C语言也得到了不断的完善。

^ 按位异或 若参加运算的两个二进制位值相同则为0，否则为1

~ 取反 ~是一元运算符，用来对一个二进制数按位取反，即将0变1，将1变0

<< 左移 用来将一个数的各二进制位全部左移N位，右补0

例如：若a=15,即00001111（2），左移2位得00111100（2）。>> 右移 将一个数的各二进制位右移N位，移到右端的低位被舍弃，对于无符号数，高位补0。

a:1001011111（计算机以补码存数据）正数补码是自身，负数补码是取反加一，11111111111111111111111111110000作为补码，对应原码100000000000000000000000001000，也就是-16101101 （用二进制形式表示）

a>>1: 0100101111110110 (逻辑右移时)

a>>1: 1100101111110110 (算术右移时)

Ja中的这几个位运算符有大神讲解一下不？举生活中的例子，谢谢！

所以：

/

c:不同点就是:正数的源码,反码,补码,都一样!

以下例子里面:0代表,1代表真;

按位与:&

真与真=真;(1&1=1)

与=;(0&0=0)

真与=;(1&0=0)

与真= ;(0&1=0)

总结(在按位与里面,逢(0)必(0));

----------------而且其是直接访问地址,在使用是直接传递一个地址值通过加减指针使用.-------------------------------------------------

按位或:|

真与真=真;(1|1=1)

与=;(0|0=0)

真与=;(1|0=1)

与真= ;(0|1=1)

总结(在按位或里面,逢真(1)必真(1));

-----------------------------------------------------------------

按位异或:^

真与真=真;(1^1=0)

与=;(0^0=0)

真与=;(1^0=1)

与真=;(0^1=1)

总结(在按位或里面,相同就(0)不同则(1));

按位非~

这个我思前想后了很久,我觉得我不好更通俗的讲解;

(请原谅,我尽可能的保持通俗)

我要是跟你讲这个,你需要了解一点基本知识,才比较好理解一点!

你了解这个:(源码--反码---补码),我比较好讲一点!

a:所有字面值常量(你暂时理解基本数字):他们在内存里面存储的时候,都是以二进制的补码形式存在的!

b:不管正数还是负数,在内存里面存储都是补码!

d:负数则不一样,一个负数的补码,是该正数的源码--->逐位取反--->然后末尾+1--->得到的就是该负数在内存里面存储的形式(补码)!

e:正数的位,即(最左边位是0,其他位有效值位),负数的位,即(最左边位是1,其他位是有效数值位!)

--->>进入主题:

按位非,是一元运算符:

它的作用是一把个数字的补码,逐位取反,得到另外一个数字的补码!这个我觉得需要举例比较容易理解一点:

例子:如(非5:~5),因为5是正数,所以5的二进制在内存里面形式都一样,举短一点的吧,byte类型,8位!

0 0 0 0 0 1 0 1<<---5的二进制;

1 1 1 1 1 0 1 0<<---按位非~,0变1,1变0(变完以后,这个是另外一个数字的补码,因为是负数,我们不好看,但是我们可以还原他的正数,就知道该数是几了!)

0 0 0 0 0 1 0 0<<---按照上面d步骤逆向过来,末尾-1--->>逐位取反--->>得到该数正数的原码!

所以你看这个数字有效位是4;所以,上面的那个负数补码就是-4,总结( ~5 = -4 );

我天,我都尽可能说详细了...还是觉得怕你看不明白!

--------------------------------------------------------------------------------

左移:<<(理解是乘法,2的n次幂,2是底数!)--->>低位补零

5<<2=20 等价 5x(2x2)=20

6<<3=48 等价 6x(2x2x2)=48

4<<4=64 等价 4x(2x2x2x2)=64

右移:>>(理解是除法,倍率同上)---->>如果是正数,在高位补零,如果是负数,则在高位补1

8>>2=2 等价 8÷(2x2)=2;

16>>3=2 等价 16÷(2x2x2)=2;

无符号右移>>>(和右移是一回事,区别在后面)--->不管正负数:高位都是补0;

16>>3=2 等价 16÷(2x2x2)=2;

-16>>3=-2 等价 16÷(2x2x2)=2;

(不管正负还是负数,结果都是正数,懂了?这就是无符号右移的区别!)

-------------------------------------------------------------------------------

这些知识都是非常基础的知识,很关键,也很重要,如果我说的你看不懂,也没关系,你可以跳过这一步,向后面学习

学一段时间后,在回头看看..会恍然大悟的!!

不好意思解答能力有限:不足之处还请路人..指点!!

/

C语言的取反运算符

例： a的值是八进制数113755：

a=15=00000000000000000000000000001111

----------------------------------------------------------------

~a=1000=11111111111111111111111111110000

!!!true == false

c语言中scanf有什么作用？

{>_< : 那么如何取得一个数据的地址呢?

C语言中scanf是标准库函数，主要用来接收用户输入的数!!true == true据。

scanf与printf函数一样，都被定义在头文件stdio.h里，因此在使用scanf函数时要加上#include 。它是格式输入函数，即按用户指定的格式从键盘上把数据输入到指定的变量之中。

函数格式：int scanf(char format, args, ...);

功 能：从标准输入设备按format指定格式输入数据给args所指向的内存单元；

扩展资料

基本特性

1、高级语言：它是把高级语言的基本结构和语句与低级语言的实用性结合起来的工作单元。

2、结构式语言：结构式语言的显著特点是代码及数据的分隔化，即程序的各个部分除了必要的信息交流外彼此。这种结构化方式可使程序层次清晰，便于使用、维护以及调试。

3、代码级别的跨平台：由于标准的存在，使得几乎模式同样的C代码可以用于多种作系统，如Windows、DOS、UNIX等等；也适用于多种机型。C语言对编写需要进行硬件作的场合，优于其它高级语言。

4、使用指针：可以直接进行靠近硬件的作，但是C的指针作不做保护，也给它带来了很多不安全的因素。C++在这方面做了改进，在保留了指针作的同时又增强了安全性，受到了一些用户的支持。

但是，由于这些改进增加语言的复杂度，也为另一部分所诟病。Ja则吸取了C++的教训，取消了指针作，也取消了C++改进中一些备受争议的地方，在安全性和适合性方面均取得良好的效果，但其本身解释在虚拟机中运行，运行效率低于C++/C。

一般而言，C，C++，ja被视为同一系的语言，它们长期占据着程序使用榜的前三名。

参考资料：

scanf是C语言中的一个输入函数，与printf函数一样，都被声明在头文件stdio.h里，因此在使用scanf函数时要加上#include 。（在有一些实现中，printf函数与scanf函数在使用时可以不使用预编译命令#include 。）它是格式输入函数，即按用户指定的格式从键盘上把数据输入到指定的变量之中。scanf函数返回成功读入的数据项数，读入数据时遇到了“文件结束”则返回EOF。

C语言中scanf是标准库函数，主要用来接收用户输入的数据。

函数格式：int scanf(char format, args, ...);

功 能：从标准输入设备按format指定格式输入数据给args所指向的内存单元

返 回 值 ：读入并赋给args的数据个数。遇文件结束返回EOF，出错返回0

举例如下：

int a;

scanf("%d", &a); // 按%d的格式（即整型的格式），将用户输入的数据赋值给&a指向的内存单元（即变量a所在的内存单元）。

// 简单理解就是将用户输入的数转换为int类型并赋值给变量a

scanf是指格式输入函数，比如说要输入一个数判断是不是素数，那就需要我们从键盘上敲入这个数，才能判断，对吧？这就需要scanf 函数，例如scanf（“%d”，&n）；就是指输入n，你在键盘上打入“99”的话，就是说n等于99，n前面的“&”符号，指的是去地址，意思是说要输入一个数，取的是这个数的地址，就好像我们要去拿一样东西，那总要知道这个东西所在的地方，然后根据地方拿东西，道理其实是一样的。。。。恩，那个“%d”，指的是从键盘上敲入的数字的格式，如果像刚刚所说的敲入的是99的话，那格式就是%d，如果敲入的是abcd这种的话，格式就要写成%c，这都要根据后面那个&n来决定到底是什么格式。。。。

！作用如下：

①：取反，一般用于逻辑判断中，单目运算符，放在布尔值（真、）之前，取其反，!(true)=false , !(false)=true。

②：不boolean b = true;等于，使用格式是“!=”，双目运算符，一般放在两个数值之间，用以判断，两个对象是否相等,返回布尔值（真或），1!=1,返回，1!=2，返回真。

C语言中scanf是标准库函数，主要用来接收用户输入的数据。

scanf与printf函数一样，都被定义在头文件stdio.h里，因此在使用scanf函数时要加上#include 。它是格式输入函数，即按用户指定的格式从键盘上把数据输入到指定的变量之中。

函数格式：int scanf(char format, args, ...);

功 能：从标准输入设备按format指定格式输入数据给args所指向的内存单元；

用户的与程序交互，读取用户输入数据。

啦啦啦啦啦啦啦啦啦啦啦，这就是我的强项了，scanf表示输入函数， 就是你把想要存储的数据通过scanf输入进去

提取用户输入的数据

C语言中，关于指针传递的一个问题，求高手解？

& 按位与 如果两个相应的二进制位都为1，则该位的结果值为1，否则为0

针就是一种用来存储地址（地址指的就是数据在电脑的存储位置）的数据类型；就如int是存整数的，float，double用来存浮点数一样；

在c语言中，变量的声明格式为 数据类型|数据名|数据

指针也一样

数据类型：根据要取地址的数值的数据这样就可以使用指针表示变量和数组的值;的类型，指针有相应的数据类型；

如若要被取地址的是int类型那么

指针就是 int float 就是float（类推）

数据名 遵守变量的命名规则即可；

数据：就如前文讲的指针的数据是地址,即数据在电脑中的存储位置,将电脑比作一栋楼,数据比作楼中的房客的话,地址很好理解,最重要的是通过一个数据的地址可以访问到这个数据.在c语言中地址用16进制表示.

&:

^_^ : 用&这个符号，如 int i=9; int i_p=&i;&是一个一元运算符。他的作用就是取地址。

>_<:那么到底是怎么取地址的呢？电脑在读到&时候发生了什么？

^_^:每一个变量标识符在编译期间,编译器会为它们创建一个符号表,其中存放着变量标识符相应的各种属性,如类型.地址标识等,从这个符号表里找

>_<:那有这么多变量唉....每一个变量都要创建符号表不是很耗内存?电脑又是怎么从这么多变量中找到某个变量的?符号表中这么多数据每个又是存在那的?

}指针取地址之后我们称为指针指向某个物体;通过对一个指针可以获得指针指向的数据的值。

(int i=9;int i_p=&i;这样i_p就指向i);之后就可以通过来获取到i的值;

(printf("%dn%d",i_p,i))会输出两个一模一样的值,不,该说是输出同一个值两次.仔细分析之.int i;声明变量int整数,分配地址.赋值9,将值9丢到地址中;int i_p=&i;同样声明变量int指针,分配地址.赋值i的地址,将i地址丢到i_p的地址中.i_p 就会得到i的值;

i_p:i的地址值;

&i_p:指针的指针值;

规则;

求值:

求指针地址

给指针加上一个整数;(数组有意义)

求值(数组有意义)

数组与指针;

int num[2]={1,2};

即printf("%pn%p",num,&num[0]);输出是相同的

为什么呢?

当当...这就是指针存在的意义啊.

指针还有一个特性,即指针加上一个数相当于指针的数值+指针所指数据类型的字节数;

如int num[2] = { 1, 2 };

printf("%p n %p n %d n%d",num,num+1,num,(num+1));

显示为:00D8FD10

00D8F-16>>3=-2 等价 -16÷(2x2x2)=-2;D14

12

计算机将数组存储在相邻的内存中,通过指针的这个特性,就可以通过指针的加减来获取数组的值;

比较复杂的是数组.但是原理还是同上的;

二维数组

数组名是数组元素的地址值;

num=&num[0];

但是num[0]同样也是一个数组

num[0]=&num[0][0];

为什么呢?

对于二维数组来说使用指针获得数组中值的方法是-—num[n][m]=((n_p+n)+m);

c++定义一个有理数类，实现有理数的加减乘除以及化简成最简分数等，要代码。问题解决了还会加分。

fz=pfz; fm=pfm;

看看这个：

#include

using namespace std;

class Rationalnumber; //提前声明

ostream& operator<<(ostream& out,Rationalnumber& ofs);

class Rationalnumber //分数

{int fz,fm; //分子，分母

int Gcd(); //求fz和fm的公约数

public:

Rationalnumber(); //无参构造函数，创建1/1对象

Rationalnumber(int pfz,int pfm=1);//pfz为分子，pfm为分母

void Set(int pfz,int pfm); //设置值：pfz为分子，pfm为分母

void Display(); //输出形如"x/y"的分数

void Division();//约分

double ToDec(); //化为小数

Rationalnumber operator+(Rationalnumber& ofs);// 重载+

Rationalnumber operator-(Rationalnumber& ofs);// 重载-

Rationalnumber operator(Rationalnumber& ofs);// 重载

Rationalnumber operator/(Rationalnumber& ofs);// 重载/

Rationalnumber& operator+=(Rationalnumber& ofs);

Rationalnumber& operator-=(Rationalnumber& ofs);

Rationalnumber& operator=(Rationalnumber& ofs);

Rationalnumber& operator/=(Rationalnumber& ofs);

friend ostream& operator<<(ostream& out,Rationalnumber& ofs);

}; //End Of class Rationalnumber

int Rationalnumber::Gcd(){

int x=abs(fz),y=abs(fm),r;

r=x % y;

while( r!=0 ){

x=y; y=r; r=x % y;

}return y;

}Rationalnumber::Rationalnumber(){ //无参构造函数，创建1/1对象

fz=1; fm=1;

}Rationalnumber::Rationalnumber(int pfz,int pfm){//pfz为分子，pfm为分母

}void Rationalnumber::Set(int pfz,int pfm){ //设置值：pfz为分子，pfm为分母

Division(); //约分

}void Rationalnumber::Display(){//输出形如"x/y"的分数

cou返 回 值 ：读入并赋给args的数据个数。遇文件结束返回EOF，出错返回0。t <

}void Rationalnumber::Division(){//约分

fz/=t; fm/=t;

if(fm<0) { fz=-fz; fm=-fm; } //使负号在分子上

}double Rationalnumber::ToDec(){ //化为小数

}Rationalnumber Rationalnumber::operator+(Rationalnumber& ofs){ //重载+

t.fz=fzofs.fm+ofs.fzfm;

t.fm=fmofs.fm;

t.Division(); //约分

return t;

}Rationalnumber Rationalnumber::operator-(Rationalnumber& ofs){ //重载-

t.fz=fzofs.fm-ofs!value的话value要是boolean值才可以进行运算。.fzfm;

t.fm=fmofs.fm;

t.Division(); //约分

return t;

}Rationalnumber Rationalnumber::operator(Rationalnumber& ofs){ //重载

t.fz=fzofs.fz; t.fm=fmofs.fm;

t.Division(); //约分

return t;

}Rationalnumber Rationalnumber::operator/(Rationalnumber& ofs){ //重载/

t.fz=fzofs.fm; t.fm=fmofs.fz;

t.Division(); //约分

return t;

}Rationalnumber& Rationalnumber::operator+=(Rationalnumber& ofs){

Rationalnumber t(this);

fz=t.fzofs.fm+ofs.fzt.fm;

fm=t.fmofs.fm;

Division(); //约分

return this;

}Rationalnumber& Rationalnumber::operator-=(Rationalnumber& ofs){

Rationalnumber t(this);

fm=t.fmofs.fm;

Division(); //约分

return this;

}Rationalnumber& Rationalnumber::operator=(Rationalnumber& ofs){

Rationalnumber t(this);

fz=t.fzofs.fz; fm=t.fmofs.fm;

Division(); //约分

return this;

}Rationalnumber& Rationalnumber::operator/=(Rationalnumber& ofs){

Rationalnumber t(this);

Division(); //约分

return this;

}ostream& operator<<(ostream& out,Rationalnumber& ofs){

ofs.Display();

return out;

}void main()

{Rationalnumber fs1(1,2),fs2(1,3),fs3,fs4,fs5,fs6;

fs3=fs1+fs2;

fs4=fs1-fs2;

fs5=fs1fs2;

fs6=fs1/fs2;

cout <<"fs1=" <

cout <<"fs2=" <

cout <<"fs3=fs1+fs2=" <

cout <<"fs4=fs1-fs2=" <

cout <<"fs5=fs1fs2=" <

cout <<"fs6=fs1/fs2=" <

}

一元运算符有哪些？？

我通俗点说:在位运算好了,基本知识我说完了,不好意思我只有这能力了,能不能看懂完全看造化了数组名的值也就是数组元素的地址值;!里面,其实大多数都是进行二进制运算的,也就是0和1,之间的运算!

超详细的CMD DOS下符号的作用参考第1/2页

fz=t.fzofs.fm; fm=t.fmofs.fz;

一、单符号

C 语言是以函数形式提供给用户的，这些函数可方便的调用，并具有多种循环、条件语句控制程序流向，从而使程序完全结构化。

~①

在for中表示使用增强的变量扩展。

②在%var:~n,m%中表示使用扩展环境变量指定位置的字符串。

③在set/a中表示一元运算符，将作数按位取反。

!①

在set

/a中一元运算符，表示逻辑非。比如set

/a

a=!0，这时a就表示逻辑1。

@①

隐藏命令行本身的回显，常用于批处理中。

$①

在findstr命令里面表示一行的结束。

②在prompt命令里面，表示将其后的字符转义（符号化或者效果化）。

%①

在set

②命令行环境下，在for命令in前，后面接一个字符（可以是字母、数字或者一些特定字符），表示指定一个循环或者遍历指标变量。

③批处理中，后接一个数字表示引用本批处理当前执行时的指定的参数。

④其它情况下，%将会被脱去（批处理）或保留（命令行）

^①

取消特定字符的转逻辑非运算符【!】、按位取反运算符【~】、自增自减运算符【++ --】、负号运算符【-】、类型转换运算符【(类型)】、指针运算符和取地址运算符【和&】、长度运算符【sizeof】义作用，比如&

|>

"等，但不包括%。比如要在屏幕显示一些特殊的字符，比如>

>>

|^

&等符号时，就可以在其前面加一个^符号来显示这个^后面的字符了，^^就是显示一个^，^|就是显示一个|字符了;

②在set/a中的二元运算符，表示按位异或。

③在findstr/r的[]中表示不匹配指定的字符集。

&①

②在set/a中是按位与。

①

代表任意个任意字符，就是我们通常所说的"通配符";比如想在c盘的根目录查找c盘根目录里所有的文本文件(.txt)，那么就可以输入命令"dir

c:.txt"。

②在set

/a中的二元运算符，表示算术乘法。

③在findstr/r中表示将前一个字符多次匹配。

-①

范围表示符，比如日期的查找，for命令里的tokens作中就可以用到这个字符。

②在findstr/r中连接两个字符表示匹配范围。

③-跟在某些命令的/后表示取反向的开关。

④在set

/a中：

1.表示一个负数。

2.表示算术减运算。

+①

主要是在copy命令里面会用到它，表示将很多个文件合并为一个文件，就要用到这个+字符了。

②在set/a中的二元运算符,表示算术加法。

当前1/2页 12下一页

关于c语言按位取反的运算

return double(fz)/fm;

0x11=0x0011=

0000

0000

0001

0001（不用转成百十进制再转度二进制，太知麻烦，一个16进制的道位直接转成四位二进制的位就可回以了）

再取反就得到1111

1111

1110即0xFFEE

问题的关答键是要把位补齐了，前面的0不能省了呀

十六进制转化为2进制不用这么做，

将每位十六进制变成4位二进制即可，所以

11(16)

=0001

0001(2)

~0x11

这个0x11是整型常量

所以

=~另外二维数组指针的定义与普通指针不同0x

00Rationalnumber t;11

=0xFFEE

ja中!的用法

命令连接字符。比如我要在一行文本上同时执行两个命令，就可以用&命令连接这两个命令。

!是一个一元运算符，运算对象是boolean类型的，若运算对象为true则返回false，若运算对象为shutrue则返回false。

/a中的二元运算符，表示算术取余。

下面举的例子if(file!=null)就是如果file对象不为空，则执行if下面的语句。

if(!value.equal("")) 显然value是一个string类型的，这里的!作符并不是对value进行运算的，而是对value.equal("")进行运算的

equal()方法返回的值是boolean类型的

if(!value.equal(""))整个意思是如果value不为空字符串(注意哦，不是不为空，这是有区别的)，则执行if下面的于语句。

好像只有在判断的时候表示"非"的意思。

比如boolean b = false;

if(b){System.out.println("..."赋值：)}这是肯定进不来的。但是，如果是这样的，

if(!b){System.out.println("")}那就可以进来，"!"在这里的意思就是not的意思。你可以理解成not就可以了。

至于其它的，貌似没碰到在ja中还有其它的什么用法。

就是表示非的意思，再所有的布尔值（布尔对象，返回布尔的方法等）前面加!,表示一下否定：

比如：

!b就等于false;

public boolean test(){

....

return true;

}!test()就等于false

这是布尔取反，这个一元运算符的实际名称是，Logical Complement Operator它会反转布尔值。

rue == true

!true == false

!false == true

举例

代码：

System.out.println(!b); // outputs: false

System.out.println(!!b); // outputs: true

b = !b; // first switch: b is false now

b = !b; // second switch: b is true now

这是否意味着“如果网络未连接”？

是!

c语言中有哪些运算符按位取反？

=_=||:...........这个嘛.....你猜啊...在c中当定义一个变量并对其取地址的时候电脑发生了什么？

（取反、左移、按位与、按位异或、按位或）优先级由高到低的顺序排列为取反 > 左移 > 按位与 > 按位异或 > 按位或。

1110

1、～：意思是按位取反int t=Gcd();，类似于非（！）的关系，取它的反面。

2、<<: 意思是左移，移动二进制的位。

3、& : 意思是按位与，类似于与(&&)的关系，一为。

4、＾：意思是按位异或，通俗地说就是相同为0，不同为1．

5、｜：意思是按位或，类似于或（｜｜）的关系，一真为真。

扩展资料：

在标准C语言的文档里，取反、左移、按位与、按位异或、按位或都属于双目运算符。结合方向是“自左至右”，即：先左后右，也叫“左结合性”。除了左结合性外，C 语言有三类运算符的结合方向是从右至左，也叫“右结合性”，即：单目运算符、条件运算符、以及赋值运算符。

着重强调一点，无论是左结合性，还是右结合性，是针对两个相邻的优先级相同的运行符而言(不是表达中的运算对象)，运算符是决定左右的基准点，先以前面的运算符(即位置上处于左边的运算符)构造运算，就是左结合，反之，就是右结合。