《后台开发-核心技术与应用实践》

2019-03-20  本文已影响0人  Peggy_623

作者按：我一般都是野路子学的C++，没有系统的学习和使用过，现在补充。

1、C++编程常用技术

1.1 第一个C++程序
1.2 函数
  1. 函数的定义
  1. 函数重载
  1. 函数模板
#include <iostream>
using namespace std;
template <typename T>
T min(T a, T b, T c)
{
    if(a>b) a = b;
    if(a>c) a = c;
    return a;
}

int main()
{
    int a = 1, b = 2, c = 3;
    cout << min(a, b, c) << endl;
   
    long long a1 = 100000000;
    long long b1 = 200000000;
    long long c1 = 300000000;
    cout << min(a, b, c) << endl;

    return 0;
}

1.3 数组

  1. 数组的定义
char str[10] = "book";
strlen(str) = 4
sizeof(str) = 10
1.4 指针
  1. 指针的概念
  1. 数组与指针
int (*p)[n]
int* p[n]
优先级：() > [] > *
  1. 字符串与指针
    字符数组/字符指针/字符指针数组/字符串变量
#include<iostream>
#include<string>
using namespace std;
int main()
{
    // 字符数组
    char str[] = "I am a programmer.";
    // 字符指针
    char* str1 = "qbc";
    // 字符指针数组
    char* str2 = {"hello world", "good bye"};
    // 字符串变量
    string str3 = "I am a programmer, too.";
   
    return 0;
}
  1. 函数与指针
// 返回类型  (*指针变量名)([形参列表])

#include<iostream>
using namespace std;
int Mmin(int x, int y)
{
    if(x > y) x = y;
    
    return x;
}

int Mmax(int x, int y)
{
    if(x<y) return y;

    return x;
}

int mian()
{
    int (*f) (int x, int y);
    int a = 10, b = 20;
    f = Mnin;
    cout << (*f)(a, b) << endl;
    f = Mmax;
    cout << (*f)(a, b) << endl;

    return 0;
}
1.5 引用
  1. 引用的定义
  1. 引用作为参数
类型标识符 &引用名 = 目标变量名
int a = 10;
int &r = a ;
  1. 常引用
const 类型标识符 &引用名 = 目标变量名
1.6 结构体、公用体、枚举
1.6.1 结构体、共同体、枚举的概念
  1. 结构体/共用体/枚举
1.6.2 结构体、共用体在内存单元占用字节数计算
1.7 预处理
  1. 常用宏定义命令
// #define 宏名 字符串
#define PI 3.1415926
//  #define 宏 (参数列表) 宏
#define A(x) x
  1. do...while(0)的妙用
  2. 条件编译
#ifdef 标识符
    程序段1
#else
    程序段2
#endif

#if 表达式
    程序段1
#else 
    程序段2
#endif
  1. extern "C" 块的应用

2、面向对象的C++

结构化编程，就是按照计算机的思维写出的代码，以功能为目标来构造应用系统，无法解决重用、维护、扩展的问题。
面向对象编程的主要思想是把构成文艺的各个事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描述一个事物在解决问题中经历的步骤和行为。对象作为程序的基本单元，将程序和数据封装其中，以提高软件的重用性、灵活性和扩展性。
面向对象：封装、继承和多态。

2.1 类与对象
  1. 类与对象的概念
  1. 成员函数
  1. 类的封装性
  2. 构造函数
  1. 析构函数
  2. 静态数据成员
  1. 静态成员函数
#include <iostream>
using namespace std;
class CStudent{
public:
    // 定义带参数的构造函数
    CStudent (int n, int s): num(n), score(s){}
    void total();
    // 静态成员函数
    static double average();
private:
    int num;
    int score;
    // 静态数据成员所有对象共享，声明静态数据成员
    static int count;
    static int sum;
};
// 定义静态数据称焉
int CStudent::count = 0;
int CStudent::sum = 0;
// 定义非静态成员函数
void CStudent::total()
{
    // 非静态成员函数中可以使用静态数据成员、非静态数据成员
    sum+=score;
    count++;
}
// 定义静态成员函数
// 直接饮用静态数据成员，不用加类名
double CStudent::average()
{
    return sum*1.0/count;
}
int main()
{
    CStudent stu1(1, 100);
    stu1.total();
    CStudent stu2(2, 98);
    stu2.total();
    CStudent stu3(3, 99);
    stu3.total();
    // 调用类的静态成员函数
    // 函数名前加上`类::函数名`
    cout << CStudent::average() << endl;
}
  1. 对象的存储空间
  1. this 指针
    保证不同对象的成员函数引用的数据成员属于该对象。隐式使用。
  2. 类模板
#include <iostream>
using namespace std;

// template <class T>
class Operation
{
 public:
    Operation(T a, T b): x(a), y(b){}
    T add()
    {
        return x+y;
    }
    T subtract()
    {
         return x - y;
     }
private:
    T x, y;
}

int main
{
    Operation <int> oper_int(1, 2);
    cout << oper_int.add() << " " << oper_int.subtract() << endl;
    Operation <double> oper_double(3.5, 1.2);
    cout << oper_double.add() << " " << oper_double.subtract() << endl;
  
    return 0;
}
  1. 构造函数和析构函数执行顺序
2.2 继承和派生
  1. 继承和派生的一般形式
                          ⬇️默认
class 派生类名 : [public | private | protected] 基类名
{
    派生类新增加的成员;
};
  1. 派生类的访问属性
  1. 派生类的构造函数与析构函数（看不懂👀）
  2. 派生类的构造函数与析构函数的调用顺序
2.3 类的多态
  1. 多态的概念
    在C++程序设计中，多态性是指具有不同功能的函数可以用同一个函数名，这样就可以用一个函数名调用不同内容的函数。在面向对象方法中一般这样表述多态性的：向不同的对象发送同一个消息，不同的对象在接收时会产生不同的行为（即方法）；也就是说，每个对象可以用自己的方式去响应共同的消息。所谓消息就是调用函数，不同的行为就是指不同的实现，即执行不同的函数。（与函数重载的区别）
#include <iostream>
#include <string>

using namespace std;

/* 声明基类Box */
class Box
{
public:
    // 声明构造函数
    Box(int h, int w, int l);
    // 声明输出函数
    virtual void display();
protected:
    int height, width, length;
}

Box::Box(int h, int w, int l)
{
    length = l;
    width = w;
    height = h;
}

void Box::display()
{
    cout << "length: " << length << endl;
    cout << "width: " << width << endl;
    cout << "height: " << height << endl;
}

class FilledBox : public Box
{
public:
    FilledBox(int, int, int, int, string);
    virtual void display();
private:
    int weight;
    string fruit;
}

FilledBox::FilledBox(int h, int w, int l, int we, string f) : Box(h,w,l), weight(we), fruit(f){}

void FilledBox::display()
{
    cout << "length: " << length << endl;
    cout << "width: " << width << endl;
    cout << "height: " << height << endl;
    cout << "weight: " << weight << endl;
    cout << "fruit: " << fruit << endl;
}

int main(int argc, char const *argv[])
{
    char* str = "hello world!";
    char* str1 = "abc";
    str = str1;
    // printf("%s\n", str);

    Box box(1,2,3);
    FilledBox fbox(2,3,4,5,"apple");
    Box *pt = &box;
    pt->display();
    pt = &fbox;
    pt->display();

    return 0;
}
  1. 虚函数的使用
  1. 纯虚函数
virtual void func() = 0;
  1. 析构函数
  2. 单例模式
2.4 本章小结

6、TCP协议

关于这部分，因为作者是网络研究方向，且网络知识相当零碎，所以不再此处做笔记。改为纸质笔记。谢谢！

后记：我一直觉得想要学习一门语言（无论是编程语言还是沟通语言），最重要的就是用起来，没有什么比这个更快了。

上一篇下一篇

猜你喜欢

热点阅读