by ·0评论

计算机操作系统

操作系统

操作系统（Operating System，简称OS）是管理和控制计算机硬件与软件资源的计算机程序，是直接运行在“裸机”上的最基本的系统软件，任何其他软件都必须在操作系统的支持下才能运行

常用的操作系统

  • Microsoft Windows
  • Linux
  • Unix
  • DOS（Dicks Operating System）

常用的DOS命令

命令 作用
* 通配符 代表任意长度的字符串
? 通配符 代表单个字符
cd (change directory) 改变当前文件夹
dir 显示目录下文件
md 新建目录
copy 复制文件/文件夹
rm 删除空目录
del 删除文件
move 移动文件
ren 重命名

[] 表示可选参数 表示必选参数

常用快捷键

kuajiejian

计算机网络

计算机网络分类

局域网（LAN）

集线器 共享宽带
交换器 独享宽带

城域网

广域网

就是互联网

基础概念

ICP/IP：　　　 传输控制协议/国际协议
IP地址：　　　 唯一标识网络上的计算机

IP地址

32位： 由4个进制组成

IP地址分类

根据网络ID的不同：
A类： 1~126.0.0.0　　　 可容纳1亿台主机
B类： 128~191.0~255.0~255.0~255
C类： 192~223.0~255.0~255.0~255
D类： 224~239.0~255.0~255.0~255
E类： 240~255.0~255.0~255.0~255

IP地址为10,192为局域网 127为本机

子网掩码

讲某个IP地址分成网络地址和主机地址两部分
特殊:127.0.0.1　　本机回环地址，测试地址

　　　 　　　 　　　 　　　 　　　 　　　 　　　 　　　 　　　 　　　 　　　——BY 看不懂啊

———————–2017年12月1日———————-

by ·0评论

操作系统：管理硬件资源，控制其他程序运行，并为用户提供交互操作。

常用DOS命令

命令 详细
cd 改变当前命令
dir 显示目录下的文件及子目录
md 新建目录
copy 复制
rd 删除空目录
del 删除一个或一组文件
move 移动
  • dir
    • /p：分页显示
    • /s：显示素有目录及子目录下文件
    • /w：宽屏显示
    • /o:分类顺序显示
  • 通配符*和？
    • *：代表任意长度的字符串
    • ?：代表单个字符

计算机网络类型

名称 范围
局域网LAN 小的地理区域
城域网MAN 一个城市范围内（几~几十公里），如校园网
广域网WAN 跨越国界，全球范围

网络通讯基本概念

基础概念

ICP/IP:传输控制/网际协议
IP地址：唯一标识网络上的计算机。
　　　　32位．由4个8位二进制组成
　　　　使用点分十进制表示

IP地址：

  • IP地址由IANA(互联网数字分配机构)负责维护和分配。
  • IP地址根据网络ID的不同分为5种：
  1. A类：1~126.0.0.0
  2. B类：128~191.0~255.0~255.0~255
  3. C类：192~233.0~255.0~255.0~255
  4. D类：224~239.0~255.0~255.0~255
  5. E类：240~255.0~255.0~255.0~255

– 备注：127表示本机
– 特殊的IP地址：127.0.0.1本机回环（测试）地址　　　　localhost

子网掩码

将某个IP地址分成网络地址和主机两部分
– A类默认：255.0.0.0
– B类默认：255.255.0.0
– C类默认：255.255.255.0

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　2017/12/4 by cq

by ·0评论

5.运算符

5.1 常见运算符种类

算数运算符
算数运算符可以进行算术运算

一元运算符：++ --
二元运算符：+ - * ／ %

关系运算符
关系运算符可以比较大小，长短，高低
> = <
&& 逻辑于
|| 逻辑或
赋值运算符

###5.2 运算符优先级

! () sizeof() ++
算数运算符
关系运算符
&& 、||
赋值运算符

案例1：取模的注意事项
取模注意要点：取模结果的符号只与第一位相同。
下面看这个小案例

#include <stdio.h>
int main()
{
    int a=48;
    a%=(-13);
    printf("%d",a);
    return 0;
}

运行这段代码会得到 9, 取模得到的结果是48决定的。

#include <stdio.h>
int main()
{
    int a=（-48）;
    a%=(-13);
    printf("%d",a);
    return 0;
}

运行这段代码得到的结果为-9。

案例2:sizeof()的应用

#include <stdio.h>
int main()
{
printf("这个数字所占的空间为%d",sizeof(1900));
return 0;
}

运行这段代码这个数字所占的空间为4。

6.初探循环

循环的目的是为了让计算机重复做规则相同指令，下面开始介绍while循环。
基本语法

while(条件语句)
{
//循环操作语句
}

循环的三要素

循环变量和初值
循环变量的判断
循环变量的更新

初学者在写循环代码的时候，可以按照这三步来思考。
经典案例1：求累加1到100的结果

#include <stdio.h>
int main()
{
    int a=1;    /* 循环变量*/
    int sum=0;      /*初值*/
    while(a<=100){    /*对循环变量的判断*/
        sum +=a;
        a ++;  /*循环变量的更新*/
    }
     printf("%d",sum);
}

经典案例2：做一个简单的加密小程序，给输入的数字每位加5模10。

#include <stdio.h>
int main()
{
   /*将一个随机的数字取出每一位的数字，加五模十*/
    int num; 
    int a; /*定义初始变量*/
    printf("please input a number:"); /*随机输入一位数*/
    scanf("%d",&num);

    while(num>0){ /*判断数字是否还有下一位*/
        a= (num+5)%10;   /*将数字+5模10
        num/=10;  /*循环变量更新*/
        printf("%d",a); 
    }
    return 0;
}

经典案例3:打印斐波那契数列
观察数列的规律 1 1 2 3 5 8 13 21 34……

#include <stdio.h>
int main()
{
   int a = 1,b = 1;
   while(1)
   {
      printf("%d,%d",a,b);
      a = a + b;
      b = a + b;
   }
 return 0;
}

经典案例4:猴子吃桃的问题
有一只猴子拥有一堆桃子，它每次吃桃子的一半，然后扔掉一个桃子，到了第十天的时候，还剩下一个桃子，请问这堆桃子一共有多少？

#include <stdio.h>
int main()
{
    int peach; /*找到初始变量
    int days;
    peach=1;
    days=9;
    /*第十天的桃子数量是1，那么可以求第九天的桃子数量，所以初始的天数是第十天*/

    while(days>0){
        peach=(peach+1)*2;/*计算前一天桃子的数量*/
        days=days-1; /*变量自减，往前推算天数*/
    }
    printf("桃子总共的数量是%d",peach);
    return 0;
}

BY—刘华振
于老九学堂

by ·0评论

while循环

循环三要素：循环变量的初值，判断和更新

#include <stdio.h>

int main()
{
    int i = 1;
    int sum = 0;
    while(i <= 100)
    {
        sum += i;
        i++;
    }
    printf("%d", sum);
    return 0;
}

经典累加算法（如上代码）

运算符与优先级

优先级

简单记就是：！> （）> sizeof() > ++/– > 算术运算符 > 关系运算符 > && > || > 赋值运算符

优先级
!,(),size(),++
算数运算符
关系运算符
&&
赋值运算符

位运算符

符号 名称 含义
& 按位与 两个操作数同时为1结果为1
I 按位或 两个操作数只要有一个为1结果就为1
~ 按位非 操作数为1，结果为0；操作数为0，结果为1
^ 按位异或 两个数操作相同，结果为0；不相同结果为1
<> 右移 左侧空位补符号位
>>> 无符号右移 左侧空位补零

by ·0评论

C语言基础知识总结

一、C语言

C语言在1972年由贝尔实验室的Dennis Ritchie所开发，C语言具有高效性、可移植性、强大而且灵活的特点

二、C编译

编译：形成目标代码/文件，目标代码是编译器的输出结果，常见扩展名为“.c”或“.obj”。
连接：将目标代码与C函数程序相连接，并将源程序缩写的库代码与目标代码合并。形成最终可执行的二进制机器代码（可执行程序）。
执行：在特定的机器环境下运行C应用程序。

三、C程序

#include     //#指预处理指令，
//include:包含，stdio.h:标准输入输出函数头文件
void main()//main主函数名，
{ 
   printf(“Hello World!\n”);
   //printf:格式化打印函数，\n换行
   return 0;
}

四、数据类型

整型类型、浮点型、字符型、其他型
整型类型：int、short、long
浮点型：float ，double
字符型：char
其他型：布尔型 – _bool、虚数型、复数型
常量:常量包括字面常量、直接常量和符号常量
变量：C语言规定标志符只能由字母、数字和下划线三种字符组成，且第一个字符必须是字母或者下划线；必须先定义后使用；每一个变量被定义确定类型后，在编译时就能为其分配相应的存储单元；不能与关键字相同

驼峰命名：numName

五、运算符优先级

级别 运算符
最高 ！（） seziof() ++
算数运算符
关系运算符
与
或
最低 赋值运算符

一元运算符 ： i++
二元运算符 ： a + b
三元运算符 ： 5>6? 45:90 =90

六、分支结构

if代码结构

   if (x > 0)
        {
            printf ("正确！\n");
        }else
        {
            printf ("错误！\n");
        }

switch代码结构

switch(choice){
    case 1:
         printf("1\n");
         break;
    case 2:
         printf("2\n");
         break;
         .
         .
    case n:
         printf("n\n");
         break;
    default;
}

七、循环结构

循环三要素：变量的初值，变量的判断，变量的更新
循环案列1：
#include
#include
//9527， 取出每一位，并加5模10，打印出来
int main()
{
int num = 9527;
int num1;//临时变量
while(num > 0)
{
num1 = ((num % 10) + 5) % 10;//取最后一位并+5 ；%10
num = num / 10;//去最后一位
printf(“%d\n”,num1);
}
return 0;
}
循环案列2：
#include
#include
void main()
{
int days = 10;//天数
int peach = 1;//第十天的桃子数量
int i;//循环变量
for(i = days – 1;i > 0;i–)
{
peach = (peach + 1) * 2;
}
printf(“猴子一共吃了%d个桃子\n”,peach);
return 0;
}

                                            未完待续！！！！！！！！
                                    2017-11-30 17:06:32 星期四

by ·0评论

第三课 　　 C语言基础下

C语言位运算

符号 名称 含义
& 按位与 2个操作数同时为1，结果为1
｜ 按位或 两个操作数只要有一个为1，结果就为1
~ 取反 操作数为1，结果为0，操作数为0，结果为1
^ 按位异或 两个操作数相同，结果为0，
＞＞ 右移 左边的运算数的各二进位全部右移若干位
＜＜ 左移 左边的运算数的各二进位全部左移若干位

总之左移就是: 丢弃最高位,0补最低位,对于有符号数，而在右移时，符号位将随同移动。当为正数时， 最高位补0，而为负数时，符号位为1，最高位是补0或是补1 取决于编译系统的规定。

sizeof 的用法

注意：sizeof不是函数，是一种运算符
　　　sizeof量取的是数据类型的长度
　　　sizeof(++num); ++在sizeof()中无效

常用的运算符的优先级

  1. !　() 　sizeof()　++
  2. 算数运算符 : * / + –
  3. 关系运算符 > <
  4. && 逻辑于
  5. || 逻辑或
  6. 赋值运算符

分支结构

  • if else
  • switch()

循环结构

循环三要素：

1. 循环变量

不一定会是整型变量，具体分析

2. 循环判断

值为真时循环，为假时跳出循环

3. 循环变量更新

不同的循环变量的更新方式也会不一样

while循环　　经典案例

  • 取个位数字
#include <stido.h>
    void main()
    {
        int num = 9527;
    /*  每一位：+ 5 % 10 并打印
     *取出每一位的原理：
     *个位 = num % 10
     *十位 = num / 10 % 10 
     *百位 = num / 10 / 10 % 10  ->规律：每次循环都要 num / 10
     */
    while( num != 0)
        {
         int temp = num % 10;
        temp = (temp + 5 ) % 10;
        printf("%d\n",temp);
        num /= num; //每次循环都去尾
    }
}
  • 斐波那契数列
//打印斐波那契数列前二十个数字：1，1，2，3，5，8，13，…………
    int i = 0;a = 1;b = 1;
    for(i = 0;i < 10;i++)
    {
        printf("%d\t%d",a,b);
        a = a + b;
        b = a + b;
    }

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 　-BY 看不懂啊

——————–2017年11月30日———————–

by ·0评论

运算符

运算符的分类

一级运算符： ++ ， —
二级运算符： + ， – ， * ， /
三级运算符： ?
  • 例1：num = 5 > 6 ? 45 : 90;
    意为：当5大于6为真则num赋值45，否则则为90.

  • 例2：

    short sex = 0; //0-男；1-女；
    printf("%s",sex ? "男" : "女");

位运算符

运算符 作用 示例
& 按位与 两个操作数同时为1结果为1
l 按位或 两个操作数只要有一个为1，结果就为1
~ 按位非 操作数为1，结果为0；操作数为0，结果为1
^ 按位异或 两个操作数相同，结果为0；不相同结果为1
》 右移 左侧空位补0
《 左移 右侧空位补0

运算符的优先等级

运算符优先等级从高到低排列顺序如下：
– ！，（），sizeof()，前置++
– 算术运算符
– 关系运算符
– 逻辑运算符（&& ， ||优先）
– 赋值运算符

实战案例

sizeof用法

    int num = 10;
    printf("%d\n",sizeof(++num));
    printf("%d\n",num);
    //输出结果为：4,10

猴子吃桃

//猴子每天总量的一半再丢一个，到第十天刚好剩1个
//问一共有多少桃
    int num;   //桃子数
    int i;     //天数
//采用倒推模式，从第十天开始，桃子数为1，天数剩九天即
    num = 1,i = 9;
    while(i > 0)
    {
        num = (num + 1) * 2;
        i--;
    }
    printf("桃子总数为：%d",num);

斐波那契数列

//打印数列前二十个数字：1，1，2，3，5，8，13，…………
    int i = 0;a = 1;b = 1;
    for(i = 0;i < 10;i++)
    {
        printf("%d\t%d",a,b);
        a = a + b;
        b = a + b;
    }

取位

//将一个数每一位加5再取出
    int num;//输入的数字
    int temp;//需要的数字
    int count；//计数器
    printf("请输入一个数字：");
    scanf("%d",&num);
    while(num != 0)
    {
        temp = num % 10;
        temp = (temp + 5) % 10;
        num /= 10;
        printf("%d",temp);
    }

by ·0评论

近日在教学过程中，遇到了一个比较有意思的代码：

int main()
{
    int i = 0;
    i = i++;

    //问如果打印i的值，结果是多少？
    return 0;
}

这个问题实际上涉及到了前置及后置操作符的内部实现问题。关于深入语言的底层汇编实现机制，大师兄的另一篇博客已经探讨过了，这里不再赘述，有兴趣的小伙伴可以移步：http://blog.csdn.net/shouhouxinling/article/details/52776646
下面我们通过模仿前置和后置操作符的实现方式，来加深对前置、后置操作符实现原理的理解：

首先，我们使用类MyInt来模拟整型：

class MyInt{
public:
    int value;              //实际的value值

    MyInt(int value){       //方便初始化：MyInt i = 0;
        this->value = value;
    }

    /**
     * 重写前置式++运算符（++i时会自动调用本函数）
     * @return 前置式运算会返回当前对象的引用
     */
    MyInt& operator++(){
        *this += 1; //累加后取出
        return *this;
    }

    /**
     * 重写后置式++运算符（i++时会自动调用本函数）
     * 注意：由于函数重载是以参数类型来区分的，而前置、后置运算又都没有参数。为了解决这个语言学上的漏洞，只好让后置式运算符有一个int类型的参数（调用时，编译器会默默地为这个int型参数指定0值）
     * @return 返回一个const类型的对象
     */
    const MyInt operator++(int){
        MyInt oldValue = *this; //取出当前对象
        ++(*this);              //累加（调用上面的前置++的重载函数）
        return oldValue;        //返回先前被取出的值
    }

    /**
     * 重载运算符+=，方便赋值操作：*this += 1;
     */
    MyInt& operator+=(int value){
        this->value = this->value + value;
        return *this;
    }

    //MyInt &operator--();        //前置式--的实现与上面类似
    //MyInt UPInt operator--();   //后置式--的实现与上面类似
 };

有了上面的代码，我们再来看main函数里的调用：

#include <.......>
#include "MyInt.h"
int main()
{
    MyInt i = 0;    //调用带参构造
    ++i;            //调用 i.operator++()     i的值为1
    i++;            //调用 i.operator++(0)    i的值为2

    return 0;
}

从上面的结果看，都是实现了值的自增1
回到开始的问题：（使用我们模拟实现的类）

int main()
{
    MyInt i = 0;
    i = i++;

    //问如果打印i的值，结果是多少？
    return 0;
}

首先会调用i++，即 i.operator++(0)，函数代码如下：

    /**
     * 重写后置式++运算符（i++时会自动调用本函数）
     * @return 返回一个const类型的对象
     */
    const MyInt operator++(int){
        MyInt oldValue = *this; //注意：oldValue是*this的副本，不是引用
        ++(*this);              //这里累加的是*this对象，而不是oldValue
        return oldValue;        //返回的oldValue值并没有变化，仍然是初值
    }

所以，i.operater++(0)执行后，表达式就成了：i = 0，即

void main()
{
    //1、i = i++;
    //2、i.operator+=(i.operator++(0));
    //3、i.operator+=(0) -> i += 0
    //4、i = 0
}

i = i++ 运行的结果就为0。

by 窖头 · 老九学堂

by ·0评论

一．计算机的组成

　　一台完整的计算机系统由硬件系统和软件系统两部分组成。
硬件系统 计算机的硬件系统由以下几部分组成。
（1）、中央处理器（CPU）：中央处理器主要包括运算器和控制器两个部件。
（2）、存储器：存储器负责存储程序和数据，并根据控制命令提供这些程序和数据。
（3）输入设备：输入设备负责把用户的信息（包括程序和数据）输入到计算机中，并且将其转换为计算机内部可识别和接受的信息方式。
（4）输出设备：将计算机内部信息以用户可接受的方式输出的设备，常见的输出设备有显示器、打印机、音箱、绘图仪等。
（5）网络设备：网络设备是将计算机连接到网络的接口设备，常见的有网卡、调制解调器等
软件系统
软件通常分为系统软件和应用软件两大类。
（1）系统软件：系统软件是指管理、监控和维护计算机资源（包括硬件和软件）的软件。
（2）应用软件：应用软件是指除系统软件以外的所有软件，是由用户或第三方软件公司专门为解决某个应用领域中的具体任务而编制的程序。

二.计算机存储器以位和字节计量

 8bit -- 1byte
 1024byte -- 1kb
 1024kb -- 1mb
 1024mb -- 1gb
 1024gb -- 1tb

三.进制转换

1.十进制转二进制、八进制或者十六进制

短除法：把十进制转二进制、八进制或者十六进制按照除2、8或者16取余，直到商为0为止。
（从最后一位余数读到第一个）

2.二进制、八进制或者十六进制转十进制

方法为：把二进制数按权展开、相加即得十进制数。

3.二进制转八进制或者十六进制

3位二进制数按权展开相加得到1位八进制数，4位二进制数按权展开相加得到1位十六进制数，从右到左开始转换，不足时补0。（8421法）

四.原码、反码和补码

  • 机器数（真值）:一个数在计算机中的二进制表示形式，机器数带符号，正数最高位为0，负数最高位为1。
  • 原码：符号位加上真值的绝对值。
  • 反码：正数的反码是其本身，负数的反码是其原码的基础上符号位不变，其余各位取反。
  • 补码：正数的补码就是其本身，负数的补码是在原码的基础上符号位不变，其余各位数取反，最后加1。
    原码的取值范围：-127~127
    反码的取值范围：-127~127
    补码码的取值范围：-128~127

五.使用命令行的方式编译和执行c语言Hello world的程序过程

1.首先打开记事本命名hello world.txt写入hello world程序另存为hello world.c格式
#include
int main()
{
printf(“Hello world!”);
return 0;
}
2.配置环境
3.打开命令行用gcc编译
　复制.c文件所在的路径
　　在命令行输入gcc 空格 .c文件所在的路径，此时会生成一个a.exe　
４.运行程序
　　直接输入a.exe即可以运行hellow world了

by ·0评论

计算机可执行以下四种功能:
1)输入
2)存储
3)处理
4)输出

机器数:一个数在计算机中的二进制表示形式
机器数带符号,最高位1表示负,最高位0表示正.
原码:人脑最容易理解和计算的方式
(符号位加上真值的绝对值)
反码:正数的反码是其本身
负数的反码是在其反码的基础上不变,符号位不变,其余位取反
补码:正数的补码就是其本身.
负数的补码就是在其反码的基础上+1.

变量名命名规则:
1.变量名的首字母字母或下划线
2.变量名的其他字母包含下划线,数字或字母
3.不能使用关键字

4.C语言规定变量名(标识符)只能由字母,数字和下划线3种字符组成切第一个字符必须为字母或下划线
5.变量名不能包含除_以外的任何特殊字符,如: % # ,逗号,空格等.
6.不可以使用保留字(32个保留字)

e.g:
正确的变量名:Radiu salary Knotted_Wool H301
错误的变量名:9_Ball 6_pake Hash!

数据类型(基本类型):
数值 1)整型:int short long
2)非整形: float double
非数值: char

#二进制与十进制或其他进制的转换#
#long long 是64位,取值范围是:-9223372036854775808~+9223372036854775807 可以表示1970年一月一日到2015-11-20的毫秒数:1448009202891#

数据类型 类型说明符 位数 取值范围
整型 int 32 -2147483648~+2147483647
短整型 short int 16 -32767~+32768
长整型 long int 32 -2147483648~+2147483647
单精度浮点型 float 32 -3.4E-38~+3.4E+38
双精度浮点型 double 64 1.7E-308~1.7E308
字符型 char 8 -128~+127

变量选用时的思考:

e.g //使用变量表示游戏角色的攻击力
//1.攻击力是什么类型数据
//3.用什么名称表示攻击力

@单精度浮点整型变量:
位数:32位
空间:4字节
取值范围 10^-38至10^+38
7位有效数字

eg:float flowerPrise = 150.0;
float cookies;
cookies = 98.5f;

#float 类型的占位符是%f#
#%.2f可以控制数字显示精度#

@双精度浮点型变量
位数:64位
空间:8个字节
取值范围:10^-308~10^+308
16位有效数字
(C语言当中默认的类型就是double类型)

e.g:
double total = 1547.2598745;
doudble values;
values = 98.5;

#通常小数被存为double型,如2.0和9.0#
#数字使用L时,数字成为long double类型,如4.76L#
#%.2lf可以控制数字显示精度#

char:字符串的使用
位数:8位
空间:1个字节
取值范围:-128~+127

生命初始化:char sex= ‘m’;

#有符号signed char 取值范围-128~+127#
#无符号unsigned char 取值范围0~255#
#char类型是否有符号取决于编译器#

编译和执行的过程:
1.编译
形成目标代码(文件),目标代码是编译器输出的结果,常见扩展名为”.o”或”.obj”.
2.连接
将目标代码跟C函数相连接,并将源程序所用的库代码与目标代码合并
形成最终可执行的二进制机器代码.(可执行代码)
3.执行
在特定的机器环境下运行C的应用程序