c++学习笔记五

最新推荐文章于 2022-09-03 10:46:19 发布
最新推荐文章于 2022-09-03 10:46:19 发布
阅读量183 收藏 1
点赞数
分类专栏： c/C++ 文章标签： 多态 抽象类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chxchxkkk/article/details/115198297
版权

4.6.5 继承同名成员处理方式
        问题：当子类与父类出现同名成员，如何通过子类对象，访问到父类中同名函数？
        》访问子类同名成员 直接访问即可
        》访问父类同名成员 需要加作用域
        》当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数
       
        示例：

#include <iostream>
using namespace std;

//继承中同名成员处理
class Base
{
    public:
    Base()
    {
        m_A = 100;
    }

    void func()
    {
        cout << "Base-func()调用" << endl;
    }

        void func(int a)
        {
                cout << "Base-func(a)调用" << endl;
        }

    int m_A;
};


class Son :public Base
{
    public:
    Son()
    {
        m_A = 200;
    }

        void func()
        {
                cout << "Son-func()调用" << endl;
        }       

    int m_A;
};

void test01()
{
    Son s;
    cout << "Son::m_A = " << s.m_A << endl;
    cout << "Base::m_A = " << s.Base::m_A << endl;
    s.func();
    s.Base::func();
    s.Base::func(10);
}

int main(void)
{
    test01();
   
    system("pause");
    return 0;
}

4.6.6 继承同名静态成员处理方式
        静态成员和非静态成员出现同名，处理方式一致。
       
        示例：

#include <iostream>
using namespace std;

//继承中同名静态成员处理方式

class Base
{
    public:
    static int m_A;

    static void func()
    {
        cout << "Base - static func()调用" << endl;
    }
};

//静态成员只能类外初始化
int Base::m_A = 100;

class Son : public Base
{
    public:
    static int m_A;

        static void func()
        {
                cout << "Son - static func()调用" << endl;
        }
};
int Son::m_A = 200;

void test01()
{
    //静态成员访问方式有两种：1、通过对象访问
    cout << "通过对象访问：" << endl;
    Son s;
    cout << "Son::m_A = " << s.m_A << endl;
    cout << "Base::m_A = " << s.Base::m_A << endl;

    //通过类名访问
    cout << "通过类名访问：" << endl;
    cout << "Son::m_A = " << Son::m_A << endl;
    cout << "Base::m_A = " << Son::Base::m_A << endl;

    //同名静态成员函数
    cout << "通过对象访问：" << endl;
    s.func();
    s.Base::func();
    cout << "通过类名访问：" << endl;
    Son::func();
    Son::Base::func();
}



int main(void)
{
    test01();

    system("pause");
    return 0;
}

4.6.7 多继承语法
        c++允许一个类继承多个类
        语法：class 子类 ： 继承方式 父类1， 继承方式 父类2 ...
        多继承可能会引发父类中同名成员出现，需要加作用域区分
        实际开发中不建议用多继承
       
        示例：

#include <iostream>
using namespace std;

//多继承语法

class Base1
{
    public:
    Base1()
    {
        m_A = 100;
    }
    int m_A;
};

class Base2
{
    public:
    Base2()
    {
        m_A = 200;
    }

    int m_A;
};

class Son :public Base1, public Base2
{
    public:
    Son()
    {
        m_C = 300;
    }

    int m_C;
};

void test01()
{
    Son s;
    cout << "Sizeof(Son) = " << sizeof(s) << endl;

    cout << "Base1::m_A = " << s.Base1::m_A << endl;
    cout << "Base2::m_A = " << s.Base2::m_A << endl;

}

int main(void)
{
    test01();

    system("pause");
    return 0;
}

4.6.8 菱形继承
        菱形继承的概念：
        两个派生类继承同一个基类
        又有某个类同时继承这两个派生类
        这种继承称为菱形继承，或者称钻石继承。
       
        示例

#include <iostream>
using namespace std;
//菱形继承
//此时父类变成虚基类
class Animal
{
    public:

    int m_Age;

};

//利用虚继承(在继承之前加上关键字virtual) 解决菱形继承的问题
class Sheep : virtual public Animal
{

};

class Tuo : virtual public Animal
{

};

class SheepTuo : public Sheep, public Tuo
{   

};

void test01()
{
        SheepTuo st;
        st.Sheep::m_Age = 18;
    st.Tuo::m_Age = 28;
    //当菱形继承时，两个父类拥有相同数据，需要加作用域区分
    cout << "Sheep::m_Age = " << st.Sheep::m_Age << endl;
    cout << "Tuo::m_Age = " << st.Tuo::m_Age << endl;
    cout << "st.m_Age = " << st.m_Age << endl;

    //这份数据只要有一份就可以了，菱形继承导致数据有两个，浪费资源
}

int main(void)
{
    test01();
   
    system("pause");
    return 0;
}

4.7 多态
4.7.1 多态的基本概念
        多态是c++面向对象的三大特性之一
        多态分为两类：
        》静态多态：函数重载 和 运算符重载属于静态多态，复用函数名
        》动态多态：派生类和虚函数实现运行时多态
       
        静态多态和动态多态的区别：
        》静态多态的函数地址早绑定 - 编译阶段确定函数地址
        》动态多态的函数地址晚绑定 - 运行阶段确定函数地址
       
        示例：


#include <iostream>
using namespace std;
//多态

//动物类
class Animal
{
    public:
    virtual void speak() //虚函数
    {
        cout << "动物在说话" << endl;
    }
};

//猫类
class Cat : public Animal
{
    public:
    void speak() //重写父类虚函数
    {
        cout << "小猫在说话" << endl;
    }
};

//狗类
class Dog :public Animal
{
    public:
    void speak() //重写父类虚函数
    {
        cout << "小狗在说话" << endl;
    }
};

/*执行说话的函数 地址早绑定，编译阶段就确定了函数的地址
  如果想执行让猫、狗说话，那么这个函数地址就不能提前绑定，需要在运行阶段绑定，地址晚绑定

  动态多态满足条件：
  1、有继承关系
  2、子类要重写父类的虚函数
     函数返回值类型 函数名 参数列表完全相同，称为重写

  动态多态的使用
  父类的指针或引用指向子类的对象。
  
*/
void doSpeak(Animal &animal)
{
    animal.speak();
}

void test01()
{
    Cat cat;
    doSpeak(cat);
    Dog dog;
    doSpeak(dog);
}

int main(void)
{
    test01();
   
    system("pause");
    return 0;
}

多态计算器示例

#include <iostream>
#include <string>
using namespace std;

//分别利用普通写法和多态技术实现计算器
//普通写法
class Calculator
{
    public:
    int getResult(string oper)
    {
        if (oper == "+")
        {
            return m_Num1 + m_Num2;
        }
        else if (oper == "-")
        {
            return m_Num1 - m_Num2;
        }
        else if (oper == "*")
        {
            return m_Num1 * m_Num2;
        }
        else if (oper == "/")
        {
            return m_Num1 / m_Num2;
        }

        /*
           如果想扩展新的功能，需求修改源码，
           在开发中，提但是开闭原则
           开闭原则：对扩展进行开发，对修改进行关闭
        */

    }

    int m_Num1; //操作数1
    int m_Num2; //操作数2
};

void test01()
{
    Calculator c;
    c.m_Num1 = 10;
    c.m_Num2 = 20;

    cout << c.m_Num1 << " + " << c.m_Num2 << " = " << c.getResult("+") << endl;
    cout << c.m_Num1 << " - " << c.m_Num2 << " = " << c.getResult("-") << endl;
    cout << c.m_Num1 << " * " << c.m_Num2 << " = " << c.getResult("*") << endl;
    cout << c.m_Num1 << " / " << c.m_Num2 << " = " << c.getResult("/") << endl;
}

//利用多态实现
//实现计算器抽象类
class AbstractCalculator
{
    public:

    virtual int getResult()
    {
        return 0;
    }

    int m_Num1;
    int m_Num2;
};

//加法计算器类
class AddCalculator : public AbstractCalculator
{
    public:

    int getResult()
    {
        return m_Num1 + m_Num2;
    }
};

//减法计算器类
class SubCalculator : public AbstractCalculator
{
        public:

        int getResult()
        {
                return m_Num1 - m_Num2;
        }
};

//乘法
class MulCalculator : public AbstractCalculator
{
        public:

        int getResult()
        {
                return m_Num1 * m_Num2;
        }
};

void test02()
{
    //父类指针指向子类对象
    //加法运算
    AbstractCalculator *abc = new AddCalculator;
    abc->m_Num1 = 10;
    abc->m_Num2 = 10;
    cout << abc->m_Num1 << " + " << abc->m_Num2 << " = " << abc->getResult() << endl;
    //new 用完后销毁
    delete abc;

    AbstractCalculator *ac = new SubCalculator;
    ac->m_Num1 = 50;
    ac->m_Num2 = 30;
        cout << ac->m_Num1 << " - " << ac->m_Num2 << " = " << ac->getResult() << endl;
        //new 用完后销毁
        delete ac;

        AbstractCalculator *ab = new MulCalculator;
        ab->m_Num1 = 50;
        ab->m_Num2 = 30;
        cout << ab->m_Num1 << " * " << ab->m_Num2 << " = " << ab->getResult() << endl;
        //new 用完后销毁
        delete ab;
}


int main(void)
{
    test02();
   
    system("pause");
    return 0;
}

4.7.3 纯虚函数和抽象类
        在多态中，通常父类中虚函数的实现是毫无意义的，主要是调用子类重写的内容，因此可以将虚函数改为纯虚函数。
       
        纯虚函数语法：virtual 返回值类型 函数名 (参数列表) = 0;
        当类中有了纯虚函数，这个类也称为抽象类。
       
        抽象类特点：
        》无法实例化对象
        》子类必须重写抽象类中的纯虚函数，否则也属于抽象类
       
        示例：

#include <iostream>
using namespace std;

//纯虚函数和抽象类

class Base
{
    public:
    //纯虚函数，这个类也称为抽象类
   
    virtual void func() = 0;
};

class Son : public Base
{
    public:
    void func()
    {
        cout << "Son子类重写了Base父类纯虚函数" << endl;
    }
   
};


void test01()
{
    // Base b; //抽象类无法实例化对象
    Son s;
    s.func();
}

int main(void)
{
    test01();
   
    system("pause");
    return 0;
}

        多态示例二：

//多态案例2：饮品
#include <iostream>
using namespace std;

class AbstractDrinking
{
    public:
    //煮水
    virtual void Boil() = 0;

    //冲泡
    virtual void Brew() = 0;

    //倒入杯中
    virtual void PourInCup() = 0;

    //加入辅料
    virtual void PourSomeThing() = 0;

    //制作饮品
    void makeDrink()
    {
        Boil();
        Brew();
        PourInCup();
        PourSomeThing();
    }
};

//制作咖啡
class Coffee :public AbstractDrinking
{
        public:
        //煮水
    virtual void Boil()
    {
        cout << "煮水" << endl;
    }

        //冲泡
    virtual void Brew()
    {
        cout << "冲泡咖啡" << endl;
    }

        //倒入杯中
    virtual void PourInCup()
    {
        cout << "倒入杯中" << endl;
    }

        //加入辅料
    virtual void PourSomeThing()
    {
        cout << "加入糖和牛奶" << endl;
    }
};

//制作茶叶
class Tea :public AbstractDrinking
{
        public:
        //煮水
        virtual void Boil()
        {
                cout << "煮矿泉水" << endl;
        }

        //冲泡
        virtual void Brew()
        {
                cout << "冲泡茶叶" << endl;
        }

        //倒入杯中
        virtual void PourInCup()
        {
                cout << "倒入杯中" << endl;
        }

        //加入辅料
        virtual void PourSomeThing()
        {
                cout << "加入柠檬" << endl;
        }
};

//制作函数
void doWork(AbstractDrinking *abs)
{
    abs->makeDrink();
    delete abs; //用完释放
}

void test01()
{
    //制作咖啡
    doWork(new Coffee);

    cout << "=============================" << endl;
    //制作茶叶
    doWork(new Tea);
}

int main(void)
{
    test01();
   
    system("pause");
    return 0;
}

4.7.5 虚析构和纯虚析构
        多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码
        解决方式：将父类中的析构函数改为虚析构或者纯虚析构
       
        虚析构和纯虚析构共性：
        》可以解决父类指针释放子类对象
        》都需要有具体的函数实现
        虚析构和纯虚析构区别：
        》如果是纯虚析构，该类属于抽象类，无法实例化对象
       
        虚析构语法：
        virtual ~类名(){}
       
        纯虚析构语法：
        virtual ~类名() = 0;
        类外实现：
        类名::~类名()
        {
        }
       
        示例：

//虚析构和纯虚析构
#include <iostream>
#include <string>
using namespace std;

class Animal
{
    public:
    Animal()
    {
        cout << "Animal构造函数调用。" << endl;
    }

    //利用虚析构可以解决父类指针释放子类对象不干净的问题
    /* 虚析构和纯虚析构有一个即可
    virtual ~Animal()
    {
        cout << "Animal构析函数调用。" << endl;
    }
    */
    /*纯虚析构需要声明，也需要实现，有纯虚析构，
      这个类也成为抽象类 */
    virtual ~Animal() = 0;

    //纯虚函数
    virtual void speak() = 0;
};

//纯虚析构需要声明，也需要实现
Animal::~Animal()
{
    cout << "Animal纯虚构析函数调用。" << endl;
}

class Cat :public Animal
{
    public:
    Cat(string name)
    {
        cout << "Cat构造函数调用。" << endl;
        m_Name = new string(name);
    }

    ~Cat()
    {
        if (m_Name != NULL)
        {
            cout << "Cat析构函数调用。" << endl;
            delete m_Name;
            m_Name = NULL;
        }
    }

    virtual void speak()
    {
        cout << *m_Name << "小猫在说话" << endl;
    }

    string *m_Name;

};

void test01()
{
    Animal *animal = new Cat("汤姆");
    animal->speak();
    //父类指针在析构时候，不会调用子类中析构函数，如果子类中有堆区属性，出现内存泄漏
    delete animal;
}

int main(void)
{
    test01();

    system("pause");
    return 0;
}

类的多态案例三：

//多态案例三：电脑组装
#include <iostream>
using namespace std;

//抽象CPU类
class CPU
{
    public:
    //抽象的计算函数
    virtual void calculate() = 0;
};

//抽象显卡类
class VideoCard
{
        public:
        //抽象的显示函数
    virtual void display() = 0;
};

//抽象内存类
class Memory
{
        public:
        //抽象的存储函数
    virtual void storage() = 0;
};

//电脑类
class Computer
{
    public:
    Computer(CPU *cpu, VideoCard *vc, Memory *mem)
    {
        m_cpu = cpu;
        m_mem = mem;
        m_vc = vc;
    }

    //提供析构函数，释放3个电脑零件
    ~Computer()
    {
        if (m_cpu != NULL)
        {
            delete m_cpu;
            m_cpu = NULL;
        }
        if (m_mem != NULL)
        {
            delete m_mem;
            m_mem = NULL;
        }
        if (m_vc != NULL)
        {
            delete m_vc;
            m_vc = NULL;
        }
    }

    //提供工作的函数
    void work()
    {
        m_cpu->calculate();
        m_vc->display();
        m_mem->storage();
    }

    private:

    CPU *m_cpu;         //CPU的零件指针
    VideoCard *m_vc;    //显卡零件指针
    Memory *m_mem;      //内存条零件指针
};

//具体厂商
//Intel
class IntelCPU :public CPU
{
    public:
    virtual void calculate()
    {
        cout << "Intel的CPU开始计算了！" << endl;
    }
};

class IntelVideoCard :public VideoCard
{
        public:
        virtual void display()
        {
                cout << "Intel的显卡开始显示了！" << endl;
        }
};

class IntelMemory :public Memory
{
        public:
        virtual void storage()
        {
                cout << "Intel的内存条开始存储了！" << endl;
        }
};

//华为
class HWCPU :public CPU
{
        public:
        virtual void calculate()
        {
                cout << "华为的CPU开始计算了！" << endl;
        }
};

class HWVideoCard :public VideoCard
{
        public:
        virtual void display()
        {
                cout << "华为的显卡开始显示了！" << endl;
        }
};

class HWMemory :public Memory
{
        public:
        virtual void storage()
        {
                cout << "华为的内存条开始存储了！" << endl;
        }
};


void test01()
{
    //第一台电脑零件
    CPU *intelCpu = new IntelCPU;
    VideoCard *intelCar = new IntelVideoCard;
    Memory *intelMem = new IntelMemory;

    cout << endl << "======== 第一台电脑开始工作 =========" << endl;
    //创建第一台电脑
    Computer *computer1 = new Computer(intelCpu, intelCar, intelMem);
    computer1->work();
    delete computer1; //工作完释放

    cout << endl << "======== 第二台电脑开始工作 =========" << endl;

        //第二台电脑零件
        CPU *hwCpu = new HWCPU;
        VideoCard *hwCar = new HWVideoCard;
        Memory *hwMem = new HWMemory;

        //创建第二台电脑
        Computer *computer2 = new Computer(hwCpu, hwCar, hwMem);
        computer2->work();
        delete computer2; //工作完释放
       
    cout << endl << "======== 第三台电脑开始工作 =========" << endl;
        //创建第三台电脑
        Computer *computer3 = new Computer(new HWCPU, new IntelVideoCard, new HWMemory);
        computer3->work();
        delete computer3; //工作完释放
    cout << endl << "======================================" << endl;
}

int main(void)
{
    test01();
   
    system("pause");
    return 0;
}

5 文件操作
        程序运行时产生的数据都属于临时数据，程序一旦运行结束都会被释放
        通过文件可以将数据持久化
        c++中对文件操作需要包含头文件<fstream>
       
        文件类型分为两种：
        》文本文件 - 文件以文本的ASCII码形式存储在计算机中
        》二进制文件 - 文件以文本的二进制形式存储在计算机中，用户一般不能直接看懂
       
        操作文件的三大类：
        》ofstream: 写操作
        》ifstream: 读操作
        》fstream:  读写操作
       
5.1 文本文件
5.1.1 写文件 步骤如下
        》包含头文件 #include <fstream>
        》创建流对象 ofstream ofs;
        》打开文件 ofs.open("文件路径", 打开方式);
        》写数据 ofs << "写入的数据";
        》关闭文件： ofs.close();
       
        文件打开方式           解释
        ios::in              为读文件而打开文件
        ios:ut             为写文件而打开文件
        ios::ate             初始位置：文件尾
        ios::app             追加方式写文件
        ios::trunc           如果文件存在先删除，再创建
        ios::binary          二进制方式
        文件打开方式可以配合使用，利用 | 操作符
        例如：用二进制文件读写文件 ios:ut | ios::binary
       
5.1.2 读文件步骤
        》包含头文件：     #include <fstream>
        》创建文件流对象： ifstream ifs;
        》打开文件并判断是否成功：ifs.open("文件路径"，打开方式);
        》读取数据
                四种方式读取：               
        》关闭文件
       
        读写文本文件示例

//文本文件写文件
#include <iostream>
#include <fstream>
#include <string>
using namespace std;

//写文件
void test01()
{
    ofstream ofs;
    ofs.open("test.txt", ios::out);
    ofs << "  咏梅  " << endl;
    ofs << "墙角数枝梅，" << endl;
    ofs << "凌寒独自开。" << endl;
    ofs << "遥知不是雪，" << endl;
    ofs << "为有暗香来。" << endl;

    ofs.close();
}

//读文件
void test02()
{
    ifstream ifs;
    ifs.open("test.txt", ios::in);
    if (! ifs.is_open() )
    {
        cout << "文件打开失败！" << endl;
        return;
    }

    /*第一种读取方式
    char buf[1024] = {0};
    while ( ifs >> buf )
    {
        cout << buf << endl;
    }
    */

    /*第二种读取方式
    char buf[1024] = {0};
    while ( ifs.getline(buf, sizeof(buf)) )
    {
        cout << buf << endl;
    }
    */

    //第三种方式
    string buf;
    while ( getline(ifs, buf) )
    {
        cout << buf << endl;
    }
   

    /*第四种方法
    char c;
    while ( (c = ifs.get()) != EOF )
    {
        cout << c;
    }
    */
    ifs.close();
}

int main(void)
{
    //test01();
    test02();
   
    system("pause");
    return 0;
}

5.2 二进制文件       
        以二进制的方式对文件进行读写操作
        打开方式要指定为 ios::binary

5.2.1 写文件
        二进制方式写文件主要利用流对象调用成员函数 write
        函数原型：ostream &write(const char *buffer, int len);
        参数说明：字符指针buffer指向内存中一段存储空间，len是读写的字节数
       
5.2.2 读文件
        二进制方式读文件主要利用流对象调用成员函数read
        函数原型：istream &read(char *buffer, int len);
        参数说明：字符指针buffer指向内存中一段存储空间，len是读写的字节数
       
        二进制读写文件示例：

//二进制文件读写
#include <iostream>
#include <fstream>
#include <string>
using namespace std;

class Person
{
    public:
    char m_Nmae[64]; //姓名
    int m_Age;       //年龄  
};

//写文件
void test01()
{
    ofstream ofs;
    ofs.open("test.txt", ios::out | ios::binary);

    Person p = {"张三", 18};
    ofs.write((const char *)&p, sizeof(Person));
   
    ofs.close();
}

//读文件
void test02()
{
    ifstream ifs("test.txt", ios::in | ios::binary);
    if (!(ifs.is_open()))
    {
        cout << "文件打开失败！" << endl;
        return;
    }

    Person p1;

    ifs.read(( char * ) &p1, sizeof(p1));
    cout << "姓名: " << p1.m_Nmae << endl;
    cout << "年龄：" << p1.m_Age << endl;


    ifs.close();
}

int main(void)
{
    //test01();
    test02();
    system("pause");
    return 0;
}

 

chxchxkkk
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++学习笔记.pdf
08-12
C++学习笔记
重构-改善既有代码的设计总结
Matrix_Designer的专栏
09-11 567
<br />随着项目的进展，我们会发现已经完成的代码结构不再象我们预想的那么清晰合理，这大多是由于需求的变更造成的。此时我们需要改善目前的代码，有两种方法，一种是重写，另一种是重构。重写的好处是明显的，结构必然更合理，但是问题在于浪费时间。重构是一个折中的方法，时间始终，调整后结构也变得更合理。一般情况下，当我们对已有代码修改超过三次时就需要重构。<br />重构的基本原则是步步为营，每次进行一小步，然后测试，周而复始。另一个原则是抵制诱惑，不要改变代码的外在表现，不要试图修正代码中的Bug。下面是具体的重
C++多态----虚函数初级剖析
a19767939的博客
09-03 290
多态说白了就是多种形态,在C++中不少的函数都可以实现多种形态,例如函数重载,运算符重载等等,这种重载一般都是在编译阶段时就已经确定了形态,这种多态,我们一般称之为静态多态,那么既然静态多态是在编译阶段就已经确定好了形态,那么动态多态,自然也就是在运行时才确定形态
C/C++中void用法总结
热门推荐
竭尽全力的专栏
11-23 6万+
1、void的基本解释： void的字面意思是“无类型”，void* 则为“无类型指针”，void *可以指向任何类型的数据。 void几乎只有“注释”和限制程序的作用，定义一个void变量没有意义，不妨试着定义：void a; 　　这行语句编译时会出错，提示“illegal use of type ‘void’”。不过，即使void a的编译不会出错，它也没有任何实际意义。 　　void
C++学习笔记本
05-14
C++学习笔记C++学习笔记C++学习笔记C++学习笔记C++学习笔记
c++学习笔记.pdf
07-12
c++学习笔记.pdf
C++学习笔记 C++学习笔记
最新发布
08-06
【C++语言基础】 C++是一种强类型、面向对象的编程语言，遵循ANSI标准，具有高度的可移植性。...随着学习的深入，还将涉及到类、对象、模板、异常处理、内存管理等更复杂的概念，这些都是C++强大功能的核心。
C++学习笔记
07-22
该文档主要是C++学习的笔记记录，是一些C++的基础知识，主要用于互联网公司面试用途。
杂记：网络游戏中用到的一些网络协议
chxchxkkk的博客
07-26 4578
【协议】 数据包可以想象成是在网络上传输的电子信封。在它的数据头中有地址和其他相关信息，然后才发出真正的数据帧。 网络数据传输，有着很多不同的协议或规则来定义数据包以什么格式以及为了发送必须 做些什么。 网络游戏现在通常会让游戏逻辑使用两种协议之一：TCP、UDP。有的游戏会使用第三种协议，ICMP，常用于一些非游戏逻辑的功能。 【IP】 全称是Internet Protocol（网际网络协议），要通过网络发送数据，这是需要遵守的最基本的协议。不管是ICMP、TCP还是UDP，都必须附加I...
C语言基础知识：顺序结构
chxchxkkk的博客
12-22 2347
顺序结构 1、定义：从main()开始，由上往下一条一条地执行语句 2、三大类语句：注释、定义、执行语句。 【执行语句】：五类 控制语句（9条） 函数调用语句； 表达式语句； 空语句；-> 只有一个分号的语句。 复合语句{ }-> 花括号只算一条语句。 3、顺序结构的程序设计框架 #include <> main() { 输入 计算 输出 ...
Winsock编程二：简单的聊天程序
chxchxkkk的博客
08-07 1840
客户端： #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <stdlib.h> #include <string.h> #include <winsock.h> #include <windows.h> #pragma comment(lib, "wsock32.lib") int main(void) { char Sendbuf[100]; //发送数据
单链表：学生成绩管理系统
chxchxkkk的博客
03-24 1540
单链表：学生成绩管理系统 student.h #pragma once #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <stdlib.h> #include <string.h> #include <windows.h> struct STUDENT { char ID[8]; char name[20]; char sex[4.
Winsock编程一：基本概念和简单实例
chxchxkkk的博客
08-07 846
什么是Winsock Winsock是Windows下的网络编程接口，它是由Unix下的BSD Socket发展而来,是一个与网络协议无关的编程接口。 构建编程环境 Winsock在常见的Windows平台上有两个主要的版本，即Winsock1和Winsock2。编写与Winsock1兼容的程序你需要引用头文件WINSOCK.H，如果编写使用Winsock2的程序，则需要引用WINSOCK2.H。此外还有一个MSWSOCK.H头文件，它是专门用来支持在Windows平台上高性能网络程序...
内存中的数据
chxchxkkk的博客
03-24 845
【内存中的数据】 只有指针才能访问 【堆】中的数据。 数据在内存中的存放分为六个区域 ●程序代码区：存放程序编译后的可执行代码 ●全局区（静态区）：全局变量和静态变量的存储是放在一起的，初始化的全局变量和初始化的静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。程序结束后由系统释放。 ●常量区：常量就是放在这里的，程序结束后由系统释放。 ●堆区：一般用来存放比较大的程序，一般由...
数制的例题
chxchxkkk的博客
12-22 785
题1：16位的逻辑地址，逻辑地址空间是多大？物理内存32K，地址是多少位？ 1k = 2的10次方 1M=2的20次方 1G=2的30次方 1T=2的40次方 地址是16位，空间是： 2的16次方 = 64K 空间是32K，地址是：15位 2的15次方 = 32K 题2：假设逻辑地址32位，页面大小4K，逻辑地址分成多少个页面？ 一页 4k=2的12次方，即12位 2的32次方除以2的12次...
C语言基础：指针
chxchxkkk的博客
12-28 677
【指针】 一、指针变量与定义 C语言有两种变量：其中变量（普通变量）存储内容值；地址变量（指针变量）存储地址值。 1、定义格式 类型名 *指针变量名；*是指针变量的标志，不包含在变量名里 注： （1）定义变量（普通变量、指针变量）都必须在前面有类型名。前类型后分号为定义语句。除此之外，其它语句都是执行语句。 （2）在定义指针变量时，指针变量名前的 * 表示现定义的是一个...
C语言基础知识：
chxchxkkk的博客
12-26 635
选择结构 1、定义：从main()开始，由上往下有些语句执行有些不执行。 2、两类语句 -》执行语句：控制语句 （1）、两类表达式 A 关系运算符及关系表达式 < <= > >= == != ----------- ----- 优先级6级 7级 B 逻辑运算符与逻辑表达式 && 逻辑与 || 逻辑或 ...
C语言基础：表达式续
chxchxkkk的博客
12-22 426
表达式 注：（1）赋值运算符左边只能是一个变量。 （2）赋值运算符右边可以是合法表达式。 （3）赋值表达式的值就是赋值运算符左边变量的值。 （4）实型数据赋给整型变量时，实型小数舍去；整型数据赋给实型变量时系统自动将整型数据转成实型数据。 复合赋值运算符： +=、-=、/=、%=、&=、|=、*=、 >>=、<<= 注：复合赋值运算符的两个...
ASCII码
chxchxkkk的博客
12-22 408
大小规则 常见ASCII码的大小规则：0~9<A~Z<a~z。 1）数字比字母要小。如 “7”<“F”； 2）数字0比数字9要小，并按0到9顺序递增。如 “3”<“8” ； 3）字母A比字母Z要小，并按A到Z顺序递增。如“A”<“Z” ； 4）同个字母的大写字母比小写字母要小32。如“A”<“a” 。 几个常见字母的ASCII码大小： “A”为65；“a”为...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值