C++ 学习笔记1 - 日志 - 邱泳天 - 血与荣誉SNS平台 - Powered by ...

C++ 学习笔记

已有 150 次阅读  2009-04-16 22:12

最近开始结束C++和JAVA 学点新东西 呵呵 

已经注释的命令下一节将不再注释

C++ 所在IDE为 VC++ 2008

里面的内容全是俺一个一个打下来的 转载请你保留出处

 

1：

#include <iostream> //定义包含头文件 iostream输入输出文件
int main() 定义函数返回值 为整数型
{             //程序开始
std:：cout<<"我喜欢C++\n"; //屏幕输出 我喜欢c++ 并且换行

 int x;  //定义变量 x
 std::cin>>x; // cin 是获取键盘输入的值 也就是 当你点击键盘上的一个键后 下面就显示 
 std::cout<<x;
 return 0;  //返回0
}  //程序结束

 

2：

 

#include <iostream>
int main()
{
 std::cout<<"学生成绩表\n";
 std::cout<<"一班的瓜娃子成绩表A: \t"<<100; //  /t 是对其命令 制表符 让后面的数据输出对其
 std::cout<<std::endl;    //endl 是立即刷新缓存区 和\n 差不多 <<100 是现实100
 std::cout<<"一班的瓜娃子成绩表B: \t"<<90+1; // 运算符 90+1=?
 std::cout<<std::endl;
 std::cout<<"一班的瓜娃子成绩表C: \t"<<(float)5/8; //5除以8  除下来非整数。所以 要转换为浮点数 float
 std::cout<<std::endl;
 int x;
    std::cout<<"输入任意键回车关闭窗口\n";
 std::cin>>x; // 考虑到有些朋友的机器是运行完控制台窗口自动关闭 所以这里加个案任意键关闭
 return 0;
}

 

3：

STD 是名称空间标识符 C++标准库中的函数或者对象都是命令空间STD定义的

cout 是标准库中所提供的一个对象 而标准库在名字空间中被指定为STD 所以 在使用cout 的时候要在前面加上std:: 这样编译器就会明白我们调用的COUT是名字空间STD中的 COUT

STD 只是在标准库中 比如 iostream 才用到 如果非标准库 比如 iostream.h 就不需要了  直接 cout<< 就可以了 或者在 包含下面 输入一行 using namespace std； 也可以 就是告诉编译器 包含 std的函数或者对象

 

4：

也可以使用 using std::cout; 这样可以避免命名重复 因为不同的名字在不同的名字空间里面，我们将他释放出来，很可能不小心使用错误的库数中的对象

 

5：

#include <iostream>
namespace a  //定义名词空间A
{
 int b=1;
}
namespace c
{
 int b=2;
}
int main()
{
 //namespace a
 //namespace c
    //std::cout<<b; 上面三条命令 就是错误的 编译器就不知道输出哪个B 会报错
 int b=9;
 std::cout<<b<<" "<<a::b<<" "<<c::b<<std::endl;  // 显示和输出 b 和名次空间 a 以及c 的值 就是 9 1 2 “ ” 为空格
 int x;
    std::cout<<"输入任意键回车关闭窗口\n";
    std::cin>>x;
 return 0;
}

搞清楚名词空间了，就是 说 namespace a  如果要调用这个里面的值 就需要加 a::?<< 输出就可以了

 

6:

 

#include <iostream>
using namespace std;
int main()
{
 /* 这种注释 是表示 注释从 反斜杠* 到 *反斜杠 结束
 可以注释多行语句 */
 // 这个只能注释一行
 cout<<"我喜欢C++\n";
 return 0;
}

7:

#include <iostream>
void show()  /* void 定义函数 show 是函数名  show 的() 是该函数说需要的参数
              如果为空 说明 该函数不需要参数*/
{   //函数开始
 std::cout<<"hello world\n";  //函数所拥有的功能
}   //函数结束
int main()
{
 show();  //调用函数show 这里无返回值和参数 所以可以直接调用 show 中的内容 。 如果有返回值 就需要 std::cout<< 这样调用
 //当函数执行完毕后 才继续执行下面的命令
 int x;
    std::cout<<"输入任意键回车关闭窗口\n";
    std::cin>>x;
}

 

8:

 

#include <iostream>
int show(int x,int y) // 定义show 函数返回值为证书并且让他支持参数 可以接受 两个整数型 参数
{
 return x+y;
}
int main()
{
 int a,b; //连续定义两个变量 a和b 为整数型
  std::cout<<"请输入两个整数：";
 std::cin>>a;
 std::cin>>b;
 std::cout<<"a+b的值是："<<show(a,b); //输出 "" 是字符串  show(a,b) 意思调用 a 和 b的值 并且相加 因为 int show 里面
 //已经定义了两个参数 所以我们也要给他两个 整数型的参数 show 里面 是 加的 所以输出来的是 a+b的和
 int z;
    std::cout<<"\n输入任意键回车关闭窗口\n";
    std::cin>>z;
}

 

9:

 

关于函数定义的说明 int show(int x,int y) 这个是关于到 函数的运行 返回值 比如x+y 这个是整数型 的 所以 返回值必须为整数 int   在后面调用得到时候 show(a,b) 是变量 要配合 前面的使用所以 ab 也必须是整数 当然 你可以直接 输入 show(1,2)  那么就是3

 

10：

int add(int ,int ); // 此为申明 告诉编译器有这个函数
int main()
{
  return 0;
}
int add(int x,int y) //此为定义 用于分配内存空间 三个INT 为 12个字节空间
{
 return x+y;
}

一般情况下都要先声明。象下面 就不好了 会导致无限循环

#include <iostream>
using namespace std;
void a();
void b();
void a()
{
    cout<<"此为A函数\n";
 b();
}
void b()
{
 cout<<"此为B函数\n";
 a();
}
int main()
{
 a();
 b();
 return 0;
}

11：

 

#include <iostream>
using namespace std;
void swap(int ,int );
int main()
{
 int x=3,y=4;
 cout<<"在main函数中 在调用SWAP函数之前。X的值是："<<x<<" Y的值是"<<y<<endl;
 swap(x,y);
 cout<<"在main函数中 在调用SWAP函数之后。X的值是："<<x<<" Y的值是"<<y<<endl;
    return 0;
}
void swap(int x,int y)  //交换函数 定义X Y
{
    cout<<"在SWAP函数中 在调用SWAP函数之前 X的值是："<<x<<" Y的值是"<<y<<endl;
 int z; //局部变量 只在此函数中有用 过了此函数后 变量将无效。
 z=x; // X复制给Z  也就是 z=3  下同 
 x=y;
 y=z;
 cout<<"在SWAP函数中 在调用SWAP函数之后 X的值是："<<x<<" Y的值是"<<y<<endl;
}
/*   最终输出  3 4  调用 后 首先输出  main swap 因为是首个输出命令
               3 4  现在开始 swap 函数的输出 因为这里已经开始调用 3 4 因为上面 定义了的
      4 3  现在输出4 3 因为通过下面的变量被交换
      3 4  这里在执行 SWAP 函数下的 内容 main swap  输出3 4 证明 没有影响到 其他语句

 

12:

 

#include <iostream>
using namespace std;
void swap(int ,int );
int x=4000,y=3000; // 定义全局变量 可以在所有函数中应用
int main()
{
 int x=3,y=4;//这里是局部变量  优先级高与全局
 cout<<"在main函数中 在调用SWAP函数之前。X的值是："<<x<<" Y的值是"<<y<<endl;
 swap(x,y);
 cout<<"在main函数中 在调用SWAP函数之后。X的值是："<<x<<" Y的值是"<<y<<endl;
    return 0;
}

13:

数据类型

可以分为 常量和变量 变量是可以改变的量 常量是不能改变的。

变量 可以包括 INT 整数型 BOOL 布尔型 真假 char 字符型 双字符型 wchar_t 单精度浮点型 float 双精度浮点型 double

 

14:

 

#include <iostream>
using namespace std;
int main()
{
 int x; //定义一个变量 但是并没有赋值
 x=1; //这里才是赋值
 int y=2;//这里是初始化 变量Y 为2 不是赋值
    return 0;
}
//变量可以这样说，变量是存储数据的地方，是内存中的地址，在这个地址中。我们可以对他读取和存储

 

15:

 

变量和数据如何存储在内存上？  百度下  内存可以看做是一个一个格子，而每个格子都有一个编号，这些编号就是内存地址。。。。等等

由于内存的种种特性 所以我们要定义变量的类型  这样 编译器才会给我们变量分配内存空间 然后做好放置这种变量的准备 每个格子是一个字节  如果我们定义的变量类型占用两个字节 就需要两个字节 也就是两个格子

深入数据类型 了解 位 和 字节

 

16:

#include <iostream>
using namespace std;
int main()
{
   bool check; //定义一个布尔型变量
   check=true; //让他表示为真，也可以是 false 假。 对应 1真 0假
   if (check=true)//如果check是真
   {
    cout<<"HELLO WORLD \n";//输出
   }
   return 0;
    int x;
    std::cout<<"输入任意键回车关闭窗口\n";
    std::cin>>x;
}
17:

 

#include <iostream>
using namespace std;
int main()
{
   char ch;  //定义一个字符型变量 ch
   ch='0'; // 字符型变量要用 '' 单引号 括起来
   cout<<ch<<endl; 
   cout<<(int)ch; //转换字符型变量为 int 0的ascll 码 就是48
     for(int i=32;i<128;i++) // 下面是循环语句 表示 i=32 如果I小于128的时候 就停止 否则 i一直加1
        {
        cout<<(char)i;//这里是输出 ASCLL玛值 ，也就是一直循环输出32 到 128 ASCLL玛对应的字符
        }
   char ax;
   ax='\t' //特殊字符：包括 \t 对其相当于TAB建 \r 回车键 不等于换行 \又称为 转移字符
   return 0;
}
//关于字符型变量输出 的转换 比如 ASCLL 可以去百科查看和研究。
/* 特殊字符 \a 铃声 \b 回退 \f 换行 以下不写斜杠 v 垂直制表 000 八进制 xhhh 十六进制

 

18:

 

#include <iostream>
#include <locale>  //调用一个头文件用于支持 locale
using namespace std;
int main()
{
    setlocale(LC_ALL,"chs");//设置 本地机器 语言 日期 货币格式等  lc_all为 所有 chs 中国
  wchar_t ch[]=L"中";// 定义 双字节型 wchar_t   因为 字节型 只能输出一个字节 而中文 韩文 日文 等都是双字节型 所以要这样定义
  wcout<<ch; //上面的 [] 是数组的意思 L 表示 告诉编译器 分配两个字节的内存空间 cout 不支持输出双字节 所有用 wcout来表示
        return 0;
}

19

 

#include <iostream>
using namespace std;
int main()
{
 cout<<"int:"<<sizeof(int)<<endl;  //sizeof 函数是输出INT 这个类型的长度 为4个字节 所以是4
 cout<<"short:"<<sizeof(short)<<endl; // short 为短整型 占用空间两个字节 输出2
 cout<<"long:"<<sizeof(long)<<endl; // long长整形 输出4 long 和int 在32位系统中没区别 16位 int 为2
    //上面是有符号位 有符号位可以表示正整数和负整数shot int他的取自最大范围为-32768- 32767 因为 最高位为填充为 其余 15位为1 二转十的概念
 // int 为-2147483648 - 2147483647
 unsigned short a;
 cout<<"short:"<<sizeof(short)<<endl; // 无符号为 短整型 只能输出 正整数 // 因为 正整数不需要 填充 所以 16个1 为 65535
 return 0;
}
//这些关系到补码 和进制 之间的转换。 下图 是占用表：

20:

/* 运算： 计算机运算的时候 全部以二进制运行 比如
1+1  就是 00000001 +  00000001 那么就等于 00000010 因为    进制运算 1+1 =2 2不是二进制 所以要补1 就是 前面那个数了
但是计算机不识别 减法 所以 要这样表示 2+(-1) 那么就是 00000010 10000000 因为 最高位为符号号 1表示 负数 0表示整数
而 这样运算的结果不对 所以要用补码 补码 分两步走  一 全部 翻转 所以是 01111111 最后添加一个1 就是11111111 所以 就是
00000010+11111111=0000001 就是 1了
这就是 计算机中的进制运算 也是补码的作用
*/

21:

#include <iostream>
using namespace std;
int main()
{
    int a=-1;
 unsigned int b=-2; //可以缩写为 unsigned b
 short c=-3;
 long d=-4;
 unsigned long e;
 e=a+b+c+d; //让 abcd 加起来 并且赋值给 e
 cout<<"e:"<<e<<"\n"<<"a:"<<"\n"<<a<<"b:"<<"\n"<<"\n"<<"c:"<<c<<"\n"<<"e:"<<e<<endl;
 //以上语句 输出 每个的值 由于 unsigned b 是 无符号 所以 无法输出 -2 那么他的值将是 一串 数字 把他转成 二进制 在进行
 //反转和添加补码 就可以得出 二进制的结果 把他转成 十进制 就是-2 大家可以自己算算 其他结果一样 e的结果和上面原理 相同
 //-10 的结果 转换下 就知道了

 //下面为变量溢出
 short f=32767;//定义 短变量 最大的值
 short g;
 g=f+1; //g +1 就是 溢出
 cout<<"g:"<<g<<"\n"<<"f:"<<f<<endl;//当你看到结果 是 -32768 的时候 使用进制转换就明白了 32767 的二进制位 15个1
 // 因为最高位 问0 表示正数被忽略了 。 把他加1  他最高位 为1  其他全部0 1是负数 而 -32768 转成二进制后 要选中
 //单字 因为 一个字节占用两个空间  把他在转换后 自己都明白了吧 。。所以注意  超出最大范围的复制不会报错 所以一定要
    // 记住上面的一张表 不要 超出范围  当溢出后 就又从0开始了
    return 0;
}

 

22:

#include <iostream>
#include <iomanip> //包含头文件 问 设置精确函数引用
using namespace std;
int main()
{
/*float 计算出来的数字为 2X2的23次方 8388608. 可以表示八百多万 如果有负数 为 除二 这个只是他的最大表示位数。
 取出在十进制中占多少位 可以用计算机 科学计算 LOG  能取出  是 6.9 也就是可以表示的十进制为  6到7位
取值范围和有效数字是不同的 取值范围可以很大  但不一定每一位上的数值 都是精确数字  假如想每一位都精确 就要在
6-7位之间
 */
 float a; //定义一个A的浮点型变量 
 a=12.12345601234661;// a 的值为 这么多
 cout<<"a:"<<a<<endl; //输出A 可以看到 最多输出 6位 因为他的有效数字 就是6-7位  如何要让他全部输出 可以
 cout<<setprecision(15)<<a<<endl; //像这样，这里是 设置 精确 位数 也就是现实位数 此函数可以显示到15位 15也可以自定义输出
 int x;
    cout<<"输入任意键回车关闭窗口\n";
    std::cin>>x; // 考虑到有些朋友的机器是运行完控制台窗口自动关闭 所以这里加个案任意键关闭
 return 0;
//在VC2008中 会看到提示 warning C4305: “=”: 从“double”到“float”截断 意思是 超出范围
 //可以用 double 表示 只要把 float 改成 double 双精度浮点型 因为 double 可以精确到 15-16位 长度八个字节 64位二进制
//在 使用浮点型的时候 能使用 float 就使用  因为 double  要比 float 多消耗两倍内存 而且运算慢
}

23:

#include <iostream>
using namespace std;
int main()
{
    const char a='s'; //定义一个常量字符串 a a 为 s 常量是不可改变的量，所以 如果象下面
 a='b'; // 那么编译器将会报错   error C3892: “a”: 不能给常量赋值 所以 常量可以被初始化 但是以后将不能对他进行赋值
 cout<<a;
 return 0;
}
//定义一个常量 就是在 char int 等前面 加上一个 const 就是了

24:

#include <iostream>
using namespace std;
int main()
{
 enum num{zero=100,one,two=200,three,four};//定义一个枚举常量 num 枚举常量 里面包含值
 //枚举常量的意思是 在包含的数字里面 你只要定义一个值 比如 zero=100 那么以后的值是 101 依次加1
 // 如果不定义 那就是从0 开始 two 开始后是200 那么以后就 201 202 一次类推 可以看下结果 如下：
 cout<<zero<<"\t"<<one<<"\t"<<two<<"\t"<<three<<"\t"<<four<<"\n";
 //下面的程序就是利用 枚举常量来判断今天是否为上班
 enum day{Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday};
 day today;
 today=Monday;
 if(today==Sunday||today==Saturday)
 {
  cout<<"周末休息\n";
 }
 else
  cout<<"上班了\n"

return 0;
}
另外说一点  ctrl+f5 可以不关闭DOS

25：

#include <iostream>
using namespace std;
int main()
{
    x=1;// 语句 什么是语句，语句以分号结束 表示一条语句 ; 这个是一条空语句
 x=a+b; // 语句是不区分空格的 所以 你可以随便敲多少个空格 但是不美观， x=a+b 的意思是 a+b 然后把他加起来的值赋给x
 // 这里就执行了一个语句 因为他只有一个 ;号
    return 0;
}

26：

#include <iostream>
using namespace std;
int main()
{
 {  //块 什么是块 块是以坐大括号开始 右大括号结束 里面允许多条语句的就是块如下：
 int x,a=1,b=2;
 x=a+b;
    return 0;
 //这里也是可以被执行的。。
 }
}
27:

#include <iostream>
using namespace std;
int main()
{
 int a=1,b=2,c=3,x=0; //表达式：
 x=c=a+b; //这里是一个表达式 也是一个语句 因为有分号，凡是用于计算值的操作都可以看做是表达式  这里是把
 //a+b的值 加起来赋给c 然后在吧 c的值赋给x   也称为 赋值表达式
 cout<<x;//x输出3  因为赋值过来后的只 a+b 等于3
    return 0;// 表达式总能返回一个值
}

28:

#include <iostream>
using namespace std;
int main()
{
 int a,x;
 a=30;// 这个是赋值运算符 他是把30赋值给了a 但是你不能把 a赋给30 比如 30=a 因为30是个常量是恒定不变的
 x=a+1;  // 这个是 数学运算符 a+1 加法运算  还有 - 减法 *乘法 /除法 % 求模运算符
 cout<<x;
 //下面的例子 可以很好的说明 求模运算符的作用 下面的左右是依次输出0-60的数字 当每次可以被6除下后余数
 //等于0的时候 就换号 输出i 并且 \t 制表。。
 for(int i=0;i<60;i++)
 {
  if(i%6==0)
  {
   cout<<"\n";
  }
 cout<<i<<"\t";
 }
 return 0;
}
/*
什么是运算符？ 运算符是指可以运算的操作符号，而提供给运算符操作的数值 我们把他们叫做操作数。由于所有
操作数都可以返回一个值 ，所以 他们也是表达式 C++有好几类 运算符其中最常用的是 赋值运算符 和数学运算符
数学运算符既是可以对操作数进行数学运算的功能 
*/

29:

#include <iostream>
using namespace std;
int main()
{
    int a=1,b;
 b=a+1;
    a=b;
 //上面的语句过于啰嗦而且繁琐，我们可以通过 简化他的方式来简化操作 如下：
 int a=1;
 a=a+1; //或者 通过 数学运算符和复制运算符联合的方式更加简化他

 int a=1
 a+=1 // 这条语句的意思是 把 左边的A和1相加 并且把结果赋值给 a  相当于 a=a+1 也可以使用 a-=1 等等 和上一节一样的运算符来操作
 return 0;
}
30:

#include <iostream>
using namespace std;
int main()
{
    int a=1,b=2,c=3;
 a++;  //自加运算符，自加运算符表示 每次加1  所以 a+1 为 2
 cout<<"a: "<<a<<endl;
 a--; //自减运算符，原理同上，表示每次减一 所以结果为1
 cout<<"a: "<<a<<endl;
 //上面的后置自加运算符
 cout<<"++b: "<<++b<<endl; //前置自加运算符 意思是 先加先让B的值加1 然后输出结果 所以B的值是 3
 cout<<"c++: "<<c++<<endl; //他们的区别看这里就知道了，一个是先加 一个是后加 比如这里就是 后加所以他的值还是 3
 cout<<c; // 只有到这里后 他的值才会变为4 因为他是后加的 不信 你们可以看看运算结果
 return 0;
}

31:

#include <iostream>
using namespace std;
int main()
{
    int a=1+2*3+4*5;//优先级: 优先级和小学数学一样 数学运算符 也存在优先级。比如这条语句 那么他的优先级就是
 //乘法和除法优先 加减随后
 cout<<a<<endl;
 int b=(1+2)*(3+4)*5;//如果想先作加减发，那么只需要括起来即可
 cout<<b<<endl;
    return 0;
}

32:

#include <iostream>
using namespace std;
int main()
{
 int a=1,b=2;
 if(a==b)// 关系运算符 ， == 表示 等于 也就是 如果 a 等于 B 的话就输出 相等
 {      // 关系运算符在c++ 里面有 6种 还有就是 != 不等于 < 小于 > 大于  <= 小于等于 >= 大于等于
  cout<<"相等\n";
 }
 else //else 是 a 不等于b 那么就是输出 不相等
    cout<<"不相等\n";
 return 0;
}

33：

#include <iostream>
using namespace std;
int main()
{
 int a=1,b=2;
 if(a==b) // 判断语句 if if 是 如果的意思 意思是 如果 () 括号里面的语句是真的话 比如 a等于b  那么就执行大括号中的语句
 {      // 如果你有多条语句需要运行 就使用大括号 编译器会把他们看桌一条语句 如果你不用大括号 那么将只执行一条语句
  cout<<"相等\n";
 }
 // 如果为假的话 就执行大括号以外的语句 比如下面的这条 当然 为真也会执行下面这条 因为并没有else
    cout<<"不相等\n";
 return 0;
}
// 如果 命令有个返回值 也就是 如果这条语句 为真 就返回 真 假 就返回假 也就是返回

34：

#include <iostream>
using namespace std;
int main()
{
 int a,b;
 cout<<"请输入第一个数：\n";
 cin>>a;
 cout<<"请输入第二个数：\n";
 cin>>b;
 if(a==b)
 {     
  cout<<"相等\n";
 }
 else  //当有else 的时候  如果if 为真 就不会执行 像上面的语句了 他只会在为假的时候执行
  cout<<"不相等\n";
 return 0;
}

35:

#include <iostream>
using namespace std;
int main()
{
 int a;
 cout<<"请输入一个数：\n";
 cin>>a;
 if(a<10)
 {     
  cout<<"a小于10\n";
 }
 else if(a<20)
 {
  cout<<"a小于20\n";
 }
 else if(a<30)
 {
  cout<<"a小于30\n";
 }
 else
  cout<<"不相等\n";
 return 0;
}
//上面是 else if 的语句使用方法，可以多个判断循环，用于 精确判断 。else if 可以一直连续判断到你不想判断为止
// else if 和 if 一样 都是 如果真 就执行它下面大括号里面的语句 如国假 就执行下面的 else if 或者 else 语句

上面三节就是if 语句的学习了

36:

#include <iostream>
using namespace std;
int main()
{
 int a;
 cout<<"请输入一个数：\n";
 cin>>a;
 if(a>1)
  if(a<100)cout<<"a大于1而小于100\n"; //内嵌if 语句 ，上面的意思是 a>1 就执行 嵌套语句 当你输入 2的时候
  else cout<<"a大于或者等于100\n"; // 就执行 if (a<100)  2是小于100的 所以输出 如果 输入 101 那么if 判断 返回假执行else 这条语句
 else         // 只有在 if(a>1) 返回假的时候才执行这条语句 如果是 0 的话 就执行这个ELSE
  if(a<1)cout<<"a小于1\n"; // 0<1 所以执行 if  if 已经返回真了 所以 else 将不再执行
  else cout<<"a等于1\n";
 return 0;
}
//上面就是if嵌套语句 在一个if语句中 有多个if 语句 就是if语句嵌套

 

37：

#include <iostream>
using namespace std;
int main()
{
 int a;
 cout<<"请输入一个数：\n";
 cin>>a;
 if(a>1)
 { //大括号的作用 是用来说明 if 语句的作用范围 ， 这里有大括号所以if 语句从这里开始
  if(a<100)cout<<"a大于1而小于100\n";
  //else cout<<"a大于或者等于100\n"; 这里被注视了 你如果不用大括号 那么 else 将会自动寻找与他最近的if语句配套
  // 那么将产生错误 到时候就是 上面的if 和下面的else 相配套了 输出的结果将会让你以外 。可以自己去试
 }  // 到这里结束
 else      
  if(a<1)cout<<"a小于1\n";
  else cout<<"a等于1\n";
 return 0;
}
//以上语句 只要输出 大于 100的数 将会自动跳转到 return 因为并没有任何判断语句判断是否大于100

38：

#include <iostream>
using namespace std;
int main()
{
 int a;
 cout<<"请输入一个数：\n";
 cin>>a;
 if(a>1&&a<100) // 逻辑或 运算符  表示 两个条件都要为真 否则就返回假 比如 a>1 和 a<100这都要成立 才执行 下面的输出语句
 cout<<"a大于1而小于100\n";
 return 0;
}

39:

#include <iostream>
using namespace std;
int main()
{
 int a;
 cout<<"请输入一个数：\n";
 cin>>a;
 if(!a==1) // 逻辑非 表示 如果a等于1 那么 取反 就是不等于   意思就是 把所有为真或者为假的结果都让他相反
 cout<<"a不等于1 \n";
 else
  cout<<"a等于1";
 return 0;
}

40:

#include <iostream>
using namespace std;
int main()
{
 int a;
 cout<<"请输入一个数：\n";
 cin>>a;
 if(a>1||a<100) // 逻辑或运算符 只要有一边的条件成立 那么就返回真
 cout<<"a大于1切小于100 \n";
 return 0;
}

41:

#include <iostream>
using namespace std;
int main()
{
 int a;
 cout<<"请输入一个数：\n";
 cin>>a;
 int b;
 cout<<"请输入一个数：\n";
 cin>>b;
 int c;
 cout<<"请输入一个数：\n";
 cin>>c;
 if(a>1&&(b>1||c>1)) // 逻辑运算符的优先级， 在多条逻辑运算符中 要区分优先级 ，像这条就是 逻辑与优先
  //在括号里面的 优先级大，优先判断。 如果想要 逻辑或 优先 就应该 (a>1&&b>1)||c>1
 {
  cout<<"a一定大于1，b和c至少有一个大于1 \n";
 }
 else
  cout<<"a一定小于1，b和c都不大于一或者有一个大于1也有可能全部大于1";
 return 0;
}//说明：输出的时候 比如 你输入 2 0 1 那么 a就大于1  而里面是逻辑与 虽然b 不满足 但是c满足了条件 所以就返回真 两边都是真了
//所以执行if 的语句而不执行else 的语句

42:

#include <iostream>
using namespace std;
int main()
{
 char a='A';  //如果这样写 a='\0' 这是一个空值 空值是假 所以 下面如果想成立就的换成 if(!a) 逻辑非
 if(a)  //判断是否为真，如果是真就执行下面的语句
 {
  a='a';
  cout<<a<<endl;
 }
 else
 {
  a='A';
  cout<<a<<endl;
 }
 return 0;
}
//在计算机数字 符号 字母被看做是一个真值  空字符 返回的是假值

43:

#include <iostream>
using namespace std;
int main()
{
    int a,b,z;
 cout<<"请输入两个数：\n";
 cout<<"a: ";
 cin>>a;
 cout<<"b: ";
 cin>>b;
 /*
 if(a>b)
  z=a;
 else
  z=b; 在程序中，我们经常用到上面的表达式 为了简化操作 。
 我们可以使用下面的语句来操作
 */
 z=(a>b)?a:b; //三目运算符 ：此条语句的意思是 如果 a>b 那么就把 : 左边的 a 赋值给 z  如果为假 就把 : 右边的 b  赋值给 z
 cout<<"\nz:"<<z<<endl;
 return 0;
}

44:

#include <iostream>
using namespace std;
int main()
{
    int a,b,z;
 cout<<"请输入两个数：\n";
 cout<<"a: ";
 cin>>a;
 cout<<"b: ";
 cin>>b;
 z=a>b?a:a>b?a:b; //三目运算符优先级： 优先级是从右到左，也就是 先 a>b?a:b 开始 如果 a=1 b=2 那么
 // a>b 为假 所以为b的值就是 2  在前面 a>b 也为假 所以 最后 z的值为2
 cout<<"\nz:"<<z<<endl;
 return 0;
}

45:

    int a=1,b=2;
 cout<<(a>b?a:b); //这里是配合使用cout 的例子。 三目运算符 可以在赋值语句中使用 上面的一小节已经看到了。
 //所以我们可以这样写 也是可以通过的
 return 0;

46:

#include <iostream>
using namespace std;
int main()
{
    int a=1;
    float b=2.1f; //这里加个 f 是为了防止警报 因为 2.1会被默认为 double型，因为2.1 才两位 double占用空间
 //具体的 以后不再阐述
 cout<<(a>b?a:b);//不加括号会报错。
 return 0;
}
//以上就是 三目运算符操作不同类型的数值进行操作
//三目运算符将A和B的值都转化为他们之中最高级的类型，也就是浮点数，跟着才对他们进行
//求职操作求出浮点数 b的值 也就是表达式的值

47:

#include <iostream>
using namespace std;
int main()
{
    char a;
 cin>>a;
 cout<<(a=(a>='A'&&a<='Z')?(a+32):a)<<endl; //这里是一个比较复杂的三目运算符我们知道 ? : 有这个的都是三目运算符
 //所以 当我们输入一个数 a 的时候  a 不大于 A 也不等于 Z 因为他们两个是大写的 。所以 a+32 在ASCLL玛里面 加32 是为
 //了吧 小写的 a或者 z 转换为大写的  如果相同 a+32 就不执行 直接 :右边的a赋值
 //  (a>='A'&&a<='Z')?(a+32):a)  这个里面才是三目运算符 提取出来是不是要清楚多了  如果还不清楚
 // (a>='A')?(a+32):a)  这样总明白了吧。。。我晕了
 return 0;
}

48:

#include <iostream>
using namespace std;
int main()
{
    int a;
 cout<<"请输入一个数：\n";
 cin>>a;
 if(a>=1)
 {
  if(a==1)
       cout<<"你输入了一个等于1的数\n";
  else
  {
   if(a<=100)
   {
    if(a==100)
     cout<<"你输入了一个等于100的数\n";
    else
     cout<<"你输入了一个大于1或者小于100的数\n";
      }
   else
    cout<<"你输入了一个大于100的数\n";
  }
 }
 else
  cout<<"你输入了一个小于1的数\n";
}
//以上为比较复杂的循环嵌套语句，在学习过程中 上面的例子不注释都应该看的出来。 其实很简单。
//如果你不会 可以吧一条IF ELSE 直接脱出来慢慢看 ，一般 只要说出要求 不看这例子你都应该会写了