[学习笔记-C++篇]day1 输入输出-判断

上次的学习计划夭折，大概就是只坚持了2天这么一个悲惨结局。所以现在逼不得已得“疯狂”找补，简单纪要，一周的学习。
感谢大佬几款优秀的支持C、C++在线编译器

---

stage1——2天入门阶段

教程网站：C++ 教程
在线编译器：compile c++ gcc online
刷题网站：阶段1第一关：基本数据类型

day1 planA
教程23+7，刷题1+2
教程完成度70%，刷题完成度0
主要原因：起晚了，效率可以再提高一点

---

1.输入输出

//除了常规cout来hello world，突然想起sprintf
#include<iostream>
//#include<stdio.h>

using namespace std;

int main()
{
	//cout << "hello world!" << endl;
	char out[100];
	sprintf(out,"%s","hello world!!");//sprintf只能对字符串赋值
    puts(out);//用于输出
	return 0;
}

2.注释

分段注释
#if 0
#endif

//一个注释的小tip
//可以嵌套，便于调试的注释符
#if 0
code
#endif
// #if 1 来执行测试代码，发布后使用 #if 0 来屏蔽测试代码
//#if 后可以是任意的条件语句。
//下面的代码如果 condition 条件为 true 执行 code1 ，否则执行 code2。
#if condition
code1
#else
code2
#endif

3.变量类型

//输出变量类型的字节和最大最小值，顺便复习一下注释符
#include<iostream>  
#include <limits>
 
using namespace std;  
  
int main()  
{  
    cout << "type:" << "\t" << "************size**************" << endl;
    cout << "bool:" << "\t" << "所占字节数：" << sizeof(bool) << "\t" << "最大值：" <<  (numeric_limits<bool>::max)() << "\t" << "最小值：" << (numeric_limits<bool>::min)() << endl; 
    #if 1
    cout << "bool:" << "\t" << "所占字节数：" << sizeof(bool) ;
    cout << "\t" << "最大值：" <<  (numeric_limits<bool>::max)() ;
    cout << "\t" << "最小值：" << (numeric_limits<bool>::min)() << endl; 
    #endif
    return 0;  
}

4.声明

//很少用到，一般现有的好记又好用
//typedef type newname;
typedef int newint;

5.枚举

定义枚举的时候，只需要enum加自己起的一个枚举名称就行，比如enum time{one, two, three, four, five};
使用的时候再定义枚举变量的值。比如time day=five;
也可以在定义的时候直接在}后加上枚举变量名称，然后使用的时候直接用，比如enum time{one, two, three, four, five}day;day=five;

枚举中的值是有默认数值的，从0开始依次累加；
如果更改了其中某个值，则后面的值在此基础上依次加一；
除非说明输出的值是什么，否则默认输出数字。

//需要明确一个概念
//首先在定义枚举的时候，只需要enum加自己起的一个枚举名称就行，比如enum time{one, two, three, four, five};
//可以在使用的时候再定义枚举变量的值。比如time day=five;
//当然也可以在定义的时候直接在}后加上枚举变量名称，然后使用的时候直接用，比如enum time{one, two, three, four, five}day;day=five;
#include<iostream>  
 
using namespace std;  
  
int main()  
{  
//此外，枚举中的值是有默认数值的，从0开始依次累加
//所以如果在输出的时候不说明，默认输出数值
    #if 1
    enum time{one, two, three, four, five};
    #endif
    //如果更改了其中某个值，则后面的值在此基础上依次加一
    #if 0
    enum time{one=2, two, three, four, five};
    #endif
    
    time day=five;
    switch(day)
    {
        case one:
        cout << "day=" << day << endl;
        break;
        case two:
        cout << "day=" << day << endl;
        break;
        case three:
        cout << "day=" << day << endl;
        break;
        case four:
        cout << "day=" << day << endl;
        break;
        case five:
        cout << "day=" << day << endl;
        //除非说明输出的值是什么，否则都输出数字
        #if 1
        cout << "day=" << "five" << endl;
        #endif
        break;
    }
    return 0;  
}

6.bool变量

bool本身只有true和false，但判断的时候只有0和1，非0会看作1

//bool本身只有true和false，但判断的时候只有0和1，非0会看作1
//闰年定义：整400；整除4不整百
#include<iostream>   
using namespace std;  
  
int main()  
{  
    int year;
    bool k;
    for(year=1;year<=1000;year++)
    {
        k=false;
        if((year%4==0 && year%100!=0) || year%400==0)
        {
            k=true;
        }
        if(k)
        {
            cout << year << " ";
        }
    }
    return 0;  
}

Tip: 闰年定义：整400；整除4不整百。

7.浮点数

float 4字节。1位符号，8位指数，23位小数
double 8字节。1位符号，11位指数，52位小数

8.变量声明

参考extern使用方法总结！

使用【多个文件】且只在其中一个文件中定义变量时（定义变量的文件在程序连接时是可用的），可以使用extern关键字在任何地方声明一个变量，只能定义一次。

//使用【多个文件】且只在其中一个文件中定义变量时（定义变量的文件在程序连接时是可用的），变量声明就显得非常有用。
//您可以使用 extern 关键字在任何地方声明一个变量。
//虽然您可以在 C++ 程序中【多次声明一个变量】，但变量只能在某个文件、函数或代码块中【被定义一次】。
/* test.c */
#include <stdio.h>
 
int etn = 100;
 
void layout()
{
    printf("test.c: The etn is %d\n", etn);
}
/* main.c */
#include <stdio.h>
 
extern int etn;
 
int main()
{
    layout();
    printf("main.c: The etn is %d\n", etn);
    return 0;
}

9.局部变量和全局变量

定义全局变量时，系统会自动初始化，一般默认初始化值为0，char为’\0’，pointer为NULL

全局变量在main()外定义，局部变量在main()内定义
在程序中，局部变量和全局变量的名称可以相同，但是在函数内，局部变量的值会覆盖全局变量的值。
定义全局变量时，系统会自动初始化，一般默认初始化值为0，char为'\0'，pointer为NULL

10.常量

整数常量默认10进制，用8进制前面加0，用16进制前面加0x或0X
整数常量也可以带一个后缀，后缀是 U 和 L 的组合，U 表示无符号整数（unsigned），L 表示长整数（long）。后缀可以是大写，也可以是小写
虽然但是，无论采用什么进制，输出的时候都会转换为10进制

浮点常量由整数部分、小数点、小数部分和指数部分组成。您可以使用小数形式或者指数形式来表示浮点常量
当使用小数形式表示时，必须包含整数部分、小数部分，或同时包含两者。当使用指数形式表示时， 必须包含小数点、指数，或同时包含两者。
带符号的指数是用 e 或 E 引入的。
但是，指数输出就是指数，不会变成小数，或者是因为用了计数法

定义常量，可以用#define NA 100这样的格式，也可以用const关键字比如const int a=2
注意，定义了常量后，只能读不能改，因此只能在定义的时候初始化，后面不能赋值

#include <iostream>
using namespace std;
  
int main ()
{
    int a=03;
    int b=0x3f;
    
    float c=1.35;
    float d=1e-5;
 
  cout << a << endl << b << endl << c << endl << d << endl;
 
  return 0;
}

定义常量，可以用#define NA 100这样的格式，也可以用const关键字比如const int a=2
注意，定义了常量后，只能读不能改，因此只能在定义的时候初始化，后面不能赋值

#define NA 100//这是宏定义，且可以取消
#undef NA

const int a=2;//必须在初始化的时候赋值

const int a;
a=2;//这是错误的

extern const int a;//这样是可以的

//
const char*, char * const的区别
char  * const cp; ( * 读成 pointer to ) 
cp is a const pointer to char //cp是字符变量的常量指针

const char * p; 
p is a pointer to const char //p是字符常量的指针

11.修饰符

修饰符 signed、unsigned、long 和 short 可应用于整型，signed 和 unsigned 可应用于字符型，long 可应用于双精度型。

#include <iostream>
using namespace std;
 
/* 
 * 这个程序演示了有符号整数和无符号整数之间的差别
*/
int main()
{
   short int i;           // 有符号短整数
   short unsigned int j;  // 无符号短整数
 
   j = 50000;
 
   i = j;
   cout << i << " " << j;
 
   return 0;
}

输出结果为-15536 50000

声明为explicit的构造函数不能在隐式转换中使用

class Test1
{
public:
    Test1(int n)
    {
        num=n;
    }//普通构造函数
private:
    int num;
};
class Test2
{
public:
    explicit Test2(int n)
    {
        num=n;
    }//explicit(显式)构造函数
private:
    int num;
};
int main()
{
    Test1 t1=12;//隐式调用其构造函数,成功
    Test2 t2=12;//编译错误,不能隐式调用其构造函数
    Test2 t2(12);//显式调用成功
    return 0;
}

Test1的构造函数带一个int型的参数，Test1 t1=12;会隐式转换成调用Test1的这个构造函数。而Test2的构造函数被声明为explicit（显式），这表示不能通过隐式转换来调用这个构造函数，因此代码24行会出现编译错误。
普通构造函数能够被隐式调用。而explicit构造函数只能被显式调用。

这种定义方式，实际上在初始化的时候，就已经在调用函数了，不单纯是定义了一个类。
如果想先定义，然后用函数初始化，看下面

#include <iostream>
 
using namespace std;

class Test
{
    private:
    int num;
    
    public:
    #if 0
    Test(int n)
    {
        num=n;
    }
    #endif
    
    void Set(int m)
    {
        num=m;
    }
    
    void Output()
    {
        cout << num << endl;
    }
};

int main()
{
    #if 0
    Test t1 = 11;
    t1.Output();
    
    Test t2(12);
    t2.Output();
    #endif
    
    Test t3;
    t3.Set(13);
    t3.Output();
}

12.存储类

auto
在定义变量初始化的时候，直接初始化，系统依据数值自动确定变量类型
auto s("hello");  //const char*
auto s="hello";//和上面是一样的，反正"aaa"就是一个const char*类型的字符变量

相关内容，还是会牵扯到一些变量之间的辩证关系，和10里面的内容有点像，C++ 字符串、string、char 、char[]、const char的转换和区别

当 static 修饰全局变量时，会使变量的作用域限制在声明它的文件内。

static
使用 static 修饰局部变量可以在函数调用之间保持局部变量的值。
static 修饰符也可以应用于全局变量。当 static 修饰全局变量时，会使变量的作用域限制在声明它的文件内。

#include <iostream>
 
// 函数声明 
void func(void);
 
static int count = 10; /* 全局变量 */
 
int main()
{
    while(count--)
    {
       func();
    }
    return 0;
}
// 函数定义
void func( void )
{
    static int i = 5; // 局部静态变量
    i++;
    std::cout << "变量 i 为 " << i ;
    std::cout << " , 变量 count 为 " << count << std::endl;
}

-------------------------------------------
//结果
变量 i 为 6 , 变量 count 为 9
变量 i 为 7 , 变量 count 为 8
变量 i 为 8 , 变量 count 为 7
变量 i 为 9 , 变量 count 为 6
变量 i 为 10 , 变量 count 为 5
变量 i 为 11 , 变量 count 为 4
变量 i 为 12 , 变量 count 为 3
变量 i 为 13 , 变量 count 为 2
变量 i 为 14 , 变量 count 为 1
变量 i 为 15 , 变量 count 为 0

总的来说，static可以保持变量的值，即使重新调用函数，这个值也不会重新赋值，而是采用上次调用后的值！！！

extern
extern 是用来在另一个文件中声明一个全局变量或函数。
结合8去看。

有且只有thread_local关键字修饰的变量具有线程周期(thread duration)，这些变量(或者说对象）在线程开始的时候被生成(allocated)，在线程结束的时候被销毁(deallocated).

thread_local
有且只有thread_local关键字修饰的变量具有线程周期(thread duration)，这些变量(或者说对象）在线程开始的时候被生成(allocated)，在线程结束的时候被销毁(deallocated).
在一个线程中改变不影响其他线程。
那么，哪些变量可以被声明为thread_local？以下3类都是ok的
1.命名空间下的全局变量
2.类的static成员变量
3.本地变量

13.运算符

数值运算区分一下++或--的位置
c=d++;//先把d赋值给c，然后d+1

关系运算，==和!=，主要用在if判断条件

逻辑运算，&&,||,!，同样多用于if判断

位运算符，与，或，异或分别&,|,^
少见的，取反~，左移<<,右移>>

#include <iostream>
using namespace std;
 
int main()
{
   unsigned int a = 60;      // 60 = 0011 1100  
   unsigned int b = 13;      // 13 = 0000 1101
   int c = 0;           
 
   c = a & b;             // 12 = 0000 1100
   cout << "Line 1 - c 的值是 " << c << endl ;
 
   c = a | b;             // 61 = 0011 1101
   cout << "Line 2 - c 的值是 " << c << endl ;
 
   c = a ^ b;             // 49 = 0011 0001
   cout << "Line 3 - c 的值是 " << c << endl ;
 
   c = ~a;                // -61 = 1100 0011
   cout << "Line 4 - c 的值是 " << c << endl ;
 
   c = a << 2;            // 240 = 1111 0000
   cout << "Line 5 - c 的值是 " << c << endl ;
 
   c = a >> 2;            // 15 = 0000 1111
   cout << "Line 6 - c 的值是 " << c << endl ;
 
   return 0;
}

赋值运算符

最简单的条件判断：
Condition ? X:Y

杂项运算符
sizeof//返回变量大小
Condition ? X:Y//如果 Condition 为真 ? 则值为 X : 否则值为 Y
.（点）和 ->（箭头）//成员运算符用于引用类、结构和共用体的成员
cast//强制转换运算符把一种数据类型转换为另一种数据类型。例如，int(2.2000) 将返回 2

优先级

14.循环

常见循环语句
for(int i;条件;操作){指令;}//满足条件就循环，执行指令，不满足就结束
while(条件){指令;}//满足条件就循环，执行指令，不满足就结束
do{指令;}while(条件);//先执行指令，满足条件继续，不满足就结束

控制语句
break;//常用于终止switch，loop，用于结束整个循环
continue;//结束一次循环，进入判断
goto//将控制转移到被标记的语句，不太记得了，比如goto loop，就转向loop语句

无限循环
for(;;)

15.判断

判断语句
if(条件)
{指令}
else {指令}
//也可以嵌套

switch(取变量)//变量类型：int,char,string,byte,short；必须是一个整型或枚举类型，或者是一个 class 类型，其中 class 有一个单一的转换函数将其转换为整型或枚举类型。
{
case 值1:
指令;
break;//不加break就继续执行下一个case
case 值2;
指令;
default:
指令;
break;
}//也可以嵌套

条件运算符
判断条件语句 ? 指令1 : 指令2;
如果 Exp1 为真，则计算 Exp2 的值，结果即为整个 ? 表达式的值。如果 Exp1 为假，则计算 Exp3 的值，结果即为整个 ? 表达式的值。

//测试实例
#include <iostream>

using namespace std;

int main()
{
    int a=1,b=2;
    
    //cout << "the maximum is "<< a>b ? a:b << endl;//这里会报错，因为在输出流里面不能出现>符号
    int m;
    m=a>b?a:b;
    cout << "the maximum is " << m << endl;
    
    return 0;
}