C++程序设计——知识点总结

最新推荐文章于 2024-10-02 22:21:04 发布
最新推荐文章于 2024-10-02 22:21:04 发布
阅读量394 收藏 2
点赞数
文章标签： c/c++ 人工智能 数据结构与算法
原文链接：http://www.cnblogs.com/rubbninja/p/4925633.html
版权

C++程序设计课程的总结，方便以后快速查阅和复习

Week 2 从C走进C++

函数指针

函数名是函数的入口地址，指向函数的指针称为“函数指针”。

比如，qsort库函数:

void qsort(void *base, int nelem, unsigned int width,
    int ( * pfCompare)( const void *, const void *));

其中的第四个参数，就是一个函数指针，pfCompare：比较函数的地址。

命令行参数

int main(int argc, char *argv[]){
    ...
}

argc：命令行参数的个数
argv：指针数组，argv[0]指向第一个命令行参数，argv[1]指向第二个命令行参数...

位运算

&│^~<<>>
按位与按位或按位异或按位非左移右移

异或运算实现a,b值交换：

a = a ^ b;
b = b ^ a;
a = a ^ b;

引用

变量的引用，等价于这个变量，相当于一个别名：

int n = 4;
int &r = n;

const关键字和常量

在定义前加上const关键字，就代表这是个常量（常量，常量指针，常引用），不可变的东西。

const int *p = &n; //常量指针

动态内存分配

用new分配内存，delete释放内存

分配变量：

int * p = new int;
* p = 5;
delete p;

分配数组：

int * p = new int[20];
p[0] = 1;
delete [ ] p;

内联函数，函数重载，缺省参数

  • 内联函数：函数的定义前加关键字inline。
  • 函数重载：名字相同，参数个数或类型不同。

  • 缺省参数：定义函数时，让最右边的几个参数有缺省值，这样在调用的时候相应位置可以不写参数。

    void func( int x1, int x2 = 2, int x3 = 3) { }

类的可访问范围

关键字：private，public，protected，缺省为私有成员

Week 3 类和对象

内联成员函数和重载成员函数

  • 内联成员函数：inline + 成员函数，在类定义内部
  • 成员函数的重载和参数缺省，使用缺省参数时注意避免有函数重载时的二义性

构造函数

  • 成员函数的一种，名字与类名相同，可以有参数，不能有返回值
  • 用来对对象进行初始化
  • 若没有自定义，则默认生成无参构造函数

复制构造函数

用来复制的构造函数，这样一个参数：同类对象的引用

Complex( const Complex & c ) {...} //可以没有const

  • 编译器会自动生成复制构造函数用于复制
  • 若自定义了，则默认的复制构造函数不存在
  • 复制构造函数起作用的三种情况：
    1. 用一个对象初始化同类的另一个对象
    2. 一个包含类A为参数的函数被调用时
    3. 函数的返回值是对象，函数返回时

类型转换构造函数

和类型转换函数不是一个名词的样子，这个类型转换构造函数，其实就是一个构造函数而已，但是像具有类型转换的功能，把其他的东西转换为本类，比如：

Complex(int i){
    real = i; imag = 0;
}

析构函数

  • 名字与类名相同，在前面加 ~，没有参数和返回值，比如：~String();
  • 一个类最多只有一个析构函数
  • 对象消亡时自动调用
  • 若自定义了，则不生成缺省析构函数
  • delete运算可导致析构函数调用，比如：delete pTest; delete [] pTest;

静态成员变量和静态成员函数

  • 在成员变量或成员函数的前面加关键字static
  • 普通成员变量每个对象各自有各自的，而静态成员变量一共就一份，大家共享，所以没有对象也能访问，想个全局变量似的
  • 静态成员函数中，不能访问非静态的东西

成员对象和封闭类

  • 成员对象：类的成员变量是另一个类的对象
  • 封闭类：包含成员对象的类

封闭类里包含了其他的类的对象，所以生成封闭类对象时，应该也要知道里边的对象该怎么初始化

在定义封闭类的构造函数时，添加初始化列表：

CMyClass::CMyClass(int x, int y) : m_y(y), m_x(m_y){...}

调用顺序：

  • 对象生成时
    1. 成员对象的构造函数
    2. 封闭类的构造函数
  • 成员对象的构造函数调用顺序
    • 和成员对象在类中的说明顺序一致
    • 与初始化列表无关
  • 对象消亡时
    1. 封闭类的析构函数
    2. 成员对象的析构函数
  • 析构与构造调用顺序相反

友元

  • 友元函数：在一个类里边，用friend加到前面来声明一个函数（这个函数可以是另一个类的成员函数），这个函数就是该类的友元函数，可以访问该类的私有成员

    class A { friend void B::function(); };

  • 友元类：声明一个类是本类的友元，那么那个类的成员函数都可以访问本类的私有成员

    class A { friend class B; };

this指针

指向成员函数当前所作用的对象

静态成员函数不能使用this指针，因为静态成员函数并不具体作用于某个对象

常量对象、常量成员函数和常引用

  • 常量对象：不希望这个对象被修改，在前面加const关键字

    const Demo Obj;

  • 常量成员函数：在成员函数说明后面加const关键字，它不能修改其所作用的对象，所以它不能修改成员变量的值。也不能调用同类的非常量成员函数（静态成员变量和静态成员函数除外，因为静态的东西不算某个对象所自有）
    （有const的和没const的函数，其他一样，算重载）

    void Sample::Get Value() const

  • 常引用：不能通过常引用修改其引用的变量，在前面加const关键字

    void Printf Obj( const Sample & o)
    函数的参数需要传递对象的时候，直接传递对象需要调用复制构造函数，效率低，所有可以用引用（或指针），但是这样有危险（函数有可能一不小心对引用的对象进行修改），所以呢就加一个const，这样的话一旦想修改就会编译错误了

Week 4 运算符重载

运算符重载的基本概念

  • C++预定义了一些运算符，用于基本数据类型的运算
  • 对运算符进行重载，让自定义的类也能使用运算符，比较方便，运算符本质上就是函数
  • 运算符可以被重载为普通函数，也能重载为类的成员函数

    • 重载为普通函数

        Complex operator+ (const Complex & a, const Complex & b) {
      return Complex( a.real+b.real, a.imaginary+b.imaginary); 
  }
      这时，仅仅是对 '+' 这个运算符的功能进行了扩充，参数个数还是本身的运算符目数

    • 重载为成员函数

        Complex Complex::operator+(const Complex & operand2) {
      return Complex( real + operand2.real, imaginary + operand2.imaginary ); 
  } // 在类里边还得声明，或者直接在类中定义，这样就是类的成员函数了

      这时，参数个数为本身的运算符目数减一，因为现在执行这个成员函数的对象本身不需要放在参数里面了

赋值运算符的重载

  • 赋值运算符“=”只能重载为成员函数
  • 对“=”进行重载，就能自定义把一个类型的对象直接赋值给另一个类型的对象

比如：
将一个字符串复制给另一个字符串，直接使用“=”，算是浅复制（指向字符串的指针之间的复制），我们可以重载“=”实现深复制（指针所指向的字符串内容间的复制）
返回值可以是 String &，这样会比较方便

运算符重载为友元函数

有时，成员函数不能满足使用要求，普通函数又不能访问类的私有成员，这时可以重载为友元

流插入运算符和流提取运算符的重载

cout << 5 << "abc" 这种写法是因为在iostream里对“<<”进行了重载

自增自减运算符的重载

自增自减本来都是一元运算符，重载时为了区分吧，然后前置运算符作为一元运算符重载T operator++();，后置运算符作为二元运算符重载T operator++(int);，仅仅只是表面上多一个参数。

  • int可作为一个类型强制转换运算符被重载:

    operator int(){ return n;}，然后就能这些写了：(int) s;等效于s.int()

运算符重载的注意事项

  • 不允许定义新的运算符
  • 不改变运算符的优先级
  • 最好符合日常习惯
  • 以下运算符不能被重载： . * :: ?: sizeof
  • 运算符()，[]，->， = ，必须声明为类的成员函数

Week 5 继承与派生

继承与派生

class 派生类名: public 基类名{...};
派生类对象的体积，等于基类对象的体积，再加上派生类对象自己的成员变量的体积。在派生类对象中，包含着基类对象，而且基类对象的存储位置位于派生类对象新增的成员变量之前。

继承关系与复合关系

  • 继承：“是”关系
    B是基类A的派生类，则“一个B对象也是一个A对象”
  • 复合：“有”关系
    一个对象中的有一个成员变量是另一个类的对象

基类/派生类同名成员与Protected关键字

void derived::access() {
    j = 5;//error（派生类没有变量j）
    i = 5;    //引用的是派生类的 i
    base::i = 5; //引用的是基类的 i
    func();  //派生类的
    base::func(); //基类的 
}

派生类的成员函数可以访问当前对象的基类的保护成员

派生类的构造函数

FlyBug :: FlyBug (int legs, int color, int wings): Bug(legs, color) {
    n Wings = wings; 
}
  • 派生类对象包含基类对象
  • 执行派生类构造函数之前, 先执行基类的构造函数（析构函数相反）
  • 除了上面的那个显式方式，还可以是隐式方式（派生类的构造函数中, 省略基类构造函数，自动调用基类的默认构造函数）
  • 顺序：基类构造函数\(\rightarrow\)成员对象类的构造函数\(\rightarrow\) ... （析构函数相反）

public继承的赋值兼容规则

如果是public（其他不行）：

  1. 派生类对象可以赋值给基类对象b = d;
  2. 派生类对象可以初始化基类引用 base &br = d;
  3. 派生类对象的地址可以赋值给基类指针base *pb = & d;

Week 6 虚函数与多态

虚函数和多态

  • 虚函数

      class base {
      virtual int get() ; 
  }; 
  int base::get()  //函数声明时加virtual就行
  { }

  • 多态的表现形式1：
    通过基类指针调用基类与派生类中同名的虚函数时，
    若，指针指向的是基类对象，则调用基类的虚函数
    若，指向的是派生类的对象，则调用派生类虚函数

  • 多态的表现形式2：
    用基类引用来实现，和上面的基本一样

  • 多态的好处：增强程序的可扩充性

    比如，很多的类都继承于同一个基类，它们有一些类似的操作，需要使用这些类的对象们，如果没有多态，那么代码的每一个语句都需要具体到哪个类，这样需要写很多类似的重复性代码，增加新的类时很不方便，而使用多态的话，不需要在类的代码里明确到底是对那个类对象进行操作，全都使用基类指针或引用，实际使用时让这个指针指向谁就操作谁， 这样就方便多了。

多态实现原理

“多态”的关键在于通过基类指针或引用调用一个虚函数时，编译时不确定到底调用的是基类还是派生类的函数，运行时才确定 —— 这叫“动态联编”。

多态的函数调用语句被编译成一系列根据基类指针所指向的（或基类引用所引用的）对象中存放的“虚函数表”的地址，在虚函数表中查找虚函数地址，并调用虚函数的指令。

虚析构函数

如果不是虚的析构函数，那么使用基类指针删除派生类对象时，只调用基类的析构函数，这样派生类对象实际上还没被删掉。所以我们这样：把基类的析构函数声明为virtual（这时派生类的析构函数就自动也是虚函数了），这时使用基类指针删除派生类对象，会首先调用派生类的析构函数，然后调用 基类的析构函数。

  • 如果定义了虚函数，最好将析构函数也定义为虚函数
  • 不允许有虚的构造函数

纯虚函数和抽象类

  • 纯虚函数：没有函数体的虚函数virtual void Print() = 0;
  • 抽象类：包含纯虚函数的类（只能用来派生新类，不能创建对象）
    • 成员函数里可以调用纯虚函数
    • 构造/析构函数里不能调用纯虚函数
    • 实现了所有纯虚函数的派生类才能称为非抽象类

Week 7 文件操作和模板

文件操作

  • ifstream，ofstream，fstream 用于文件操作，统称为文件流类
  • 基本流程：打开文件（连接，使用方式）\(\rightarrow\)读写文件\(\rightarrow\)关闭文件
  • ofstream out File(“clients.dat”, ios::out|ios::binary); //打开文件out 删除原有内容， app 在尾部添加 binary 以二进制格式
  • 或者 ofstream fout; fout.open( “test.out”, ios::out|ios::binary );
  • 判断打开是否成功if(!fout) { cerr << “File open error!”<<endl; }
  • 读指针/写指针/读写指针，指向哪里就在哪进行读写操作。tellp(); seekp(); seekg(); ...
    fout.write( (const char *)(&x), sizeof(int) );
    fin.read( (char *)(&x), sizeof(int) );

函数模板

  • 泛型程序设计，算法实现时不指定具体要操作的数据的类型，包括函数模板、类木板

  • 比如，交换两个变量的值，编译器会根据调用的情况生成相应数据类型的函数

      template <class T> 
  void Swap(T & x, T & y)  {   
      T tmp = x;   
      x = y;   
      y = tmp; 
  }

  • 编译器先找普通函数，再去找模板函数，再找实参自动类型转换后能匹配的普通函数，如何还找不到就报错

类模板

  • Pair类模板:

      template <class T1, class T2> 
  class Pair{     
  public:   
      T1 key;    //关键字   
      T2 value;    //值   
      Pair(T1 k,T2 v):key(k),value(v) { };   
      bool operator < (const Pair<T1,T2> & p) const;  
  };
  template<class T1,class T2> 
  bool Pair<T1,T2>::operator<( const Pair<T1, T2> & p) const {
      return key < p.key;   
  }

  • Pair类模板的使用

      int main() {    
      Pair<string, int> student("Tom",19);  //实例化出一个类 Pair<string, int>    
      cout << student.key << " " << student.value;     
      return 0;  
  }
  • 类模板的实例化得到的类叫模板类
  • 类模板的参数声明中可以包括非类型参数：
    template <class T, int elements Number> 非类型参数: 用来说明类模板中的属性

  • 类模板与继承：
    类模板派生出类模板，模板类派生出类模板，普通类派生出类模板，模板类派生出普通类

string类

  • 初始化
    • string s1("Hello");
    • string s2(8, 'x');
    • string month = "March";
  • 可以将字符赋值给string对象s = 'n'
  • 长度 s.length()
  • 流读取运算符'cin >> string Object;'
  • getline(cin, s);
  • string的赋值和连接
    • 赋值s2 = s1;
    • 复制s3.assign(s1);
    • 部分复制s3.assign(s1, 1, 3);
    • 单个字符复制s2[5] = s1[3] = 'a';
    • s1.at(i)，会做范围检查
    • 用+连接 s1 += s2;
    • s1.append(s2);
  • 比较string
    • 关系运算符== , >, >=, <, <=, !=
    • int f1 = s1.compare(s2);
  • 子串 s2 = s1.substr(4,5);
  • 交换 s1.swap(s2);
  • capacity(); maximum_size(); length(); size(); empty(); resize()
  • find(); rfind(); find_first_of(); find_last_of(); find_first_not_of(); find_last_not_of();
  • erase(); replace(); insert();
  • c_str(); data(); copy();

输入输出

  • 类：istream, ostream, ifstream, ofstream, iostream, fstream.
  • 标准流对象：cin, cout, cerr, clog
  • 输出重定向：
    freopen("test.txt","w",stdout); //将标准输出重定向到 test.txt文件
  • 输入重定向：
    freopen(“t.txt”,“r”,stdin); //cin被改为从 t.txt中读取数据
  • 判断输入流结束:
    while(cin>>x){...}
  • 键盘 Ctrl+Z 代表输入流结束
  • getline:
    istream & getline(char * buf, int buf Size);
    istream & getline(char * buf, int buf Size,char delim);
    if(!cin.getline(…))
  • bool eof(); 判断输入流是否结束
  • int peek(); 返回下一个字符,但不从流中去掉
  • istream & putback(char c); 将字符ch放回输入流
  • istream & ignore( int n Count = 1, int delim = EOF ); 从流中删掉最多n Count个字符，遇到EOF时结束

Week 8 标准模板库 STL -1

概述

  • 泛型程序设计：使用模板的程序设计法。
  • 容器：类似于类模板
    1. 顺序容器（元素没有按值进行排序）：vector（动态数组），deque（双向队列），list（双向链表）
    2. 关联容器（元素是排序的，平衡二叉树）：set（集合）， multiset（允许相同元素），map（每个元素包含first和second），multimap（允许相同的first）
    3. 容器适配器：stack（栈），queue（队列），priority_queue（优先级队列）
  • 迭代器：类似于指针
    vector::const_iterator i; //常量迭代器
    for( i = v.begin();i != v.end();++i )
    cout << * i << ",";
    reverse_iterator（反向迭代器），iterator（非常量迭代器）
    • 容器上的迭代器类别
      • 随机访问：vector，deque
      • 双向：list，set/multiset，map/multimap
      • 不支持迭代器：stack，queue，priority_queue
  • 算法： 类似于函数模板
    • find()：p = find(v.begin(),v.end(),3);返回一个迭代器，指向找到的元素，或者last
  • 顺序容器和关联容器都有的成员函数：
    begin，end，rbegin，rend，（返回迭代器），erase，clear
  • 顺序容器常用成员函数：
    front，back，（返回元素引用），push_back，pop_back，erase
  • ”x和y相等“有时等价于”x==y为真“，有时等价于”x小于y和y小于x同时为假“

vector

可变长动态数组，#include <vector>，所有STL算法都支持

  • 初始化：
    • vector();
    • vector(int n);
    • vector(int n, const T & val);
    • vector(iterator first, iterator last);
  • 常用成员函数
成员函数作用
void pop_back();删除容器末尾的元素
void push_back(const T & val);将val添加到容器末尾
int size();返回容器中元素的个数
T & font();返回容器中第一个元素的引用
T & back();返回容器中最后一个元素的引用

list和deque

  • list容器还支持：push_front，pop_front，sort，remove，unique，merge，reverse，splice
  • list容器的sort函数（由于list不支持完全随机访问，不能用STL的sort函数）
    list<T> classname classname.sort(compare); classname.sort();
  • deque除了所有适用于vector的操作，还有push_front和pop_front

函数对象

若一个类重载了运算符“()”，则该类的对象就成为函数对象
以下模板可以用来生成函数对象：equal_tp，greater，less ...头文件
lst.sort(greater<int>()); //greater<int>()是个对象

Week 9 标准模板库 STL -2

set和multiset，map和multimap

  • set，multiset，map，multimap还支持：find，lower_bouond，upper_bound，equal_range，count，insert
  • pair模板：pair模板类的对象包含first和second两个成员变量，map/multimap放着的就是这些
  • multiset：
    template<class Key, class Pred = less<Key>, class A = allocator<Key> >
    class multiset { …… };
  • set：
    template<class Key, class Pred = less<Key>, class A = allocator<Key> >
    class set { … }
  • multimap：
    template<class Key, class T, class Pred = less<Key>,class A = allocator<T> >
    class multimap { …...pedef pair<const Key, T> value_type; …….}; //Key 代表关键字的类型
  • map
    template<class Key, class T, class Pred = less<Key>,class A = allocator<T> >
    class map { ….typedef pair<const Key, T> value_type; …….};//关键字（first）各不相同
  • map的[]成员函数，e.g. pairs[key]

容器适配器

用某种顺序容器来实现，让已有的顺序容器以栈/队列的方式工作，stack，queue，priority_queue

  • 三个成员函数
    • push：添加元素
    • top：返回栈顶部或队头元素的引用
    • pop：删除一个元素
  • STL的各种排序，查找，变序等算法都不适合容器适配器

STL算法

STL算法大致可以分为一下七类：

  1. 不变序列算法：
    不修改，适用于顺序容器和关联容器，O(n)
    min，max，min_element，max_element，for_each，count，count_if，find，find_if，find_end，find_first_of，adjacent_find，search，search_n，equal，mismatch，lexicographical_cpmpare
  2. 変值算法：
    会修改，修改的区间不可以是属于关联容器的
    for_each，copy，copy_backward，transform，swap_ranges，fill，fill_n，generate，generate_n，replace，replace_if，replace_copy，replace_copy_if
  3. 删除算法：
    删除某些元素，O(n)，删除是指：将删掉的元素看作空位，然后留下的元素前移补上，最后没被补上的空位维持其原来的值不变
    remove，remove_if，remove_copy，remove_copy_if，unique，unique_copy
  4. 变序算法：
    改变顺序不改变值，不适用于关联容器，O(n)
    reverse，reverse_copy，rotate，rotate_copy，next_permulation，prev_permulation，random_shuffle，partition
  5. 排序算法：
    一般是O(nlog(n))，需要随机访问迭代器，不适用于关联容器和list
    sort，stable_sort，partial_sort，partial_sort_copy，nth_element，make_heap，push_heap，pop_heap，sort_heap
  6. 有序区间算法
    要求区间已经排号序，需要随机访问迭代器，不能用于关联容器和list
    binary_search，includes，lower_bound，upper_bound，equal_range，merge，set_union，set_intersection，set_difference，set_symmetric_difference，inplace_merge
  7. 数值算法...
  • 大多数重载的算法都有两个版本，比如：
    • iterator min_element(iterator first, iterator last);
    • iterator min_element(iterator first, iterator last, Pred op);//表达式op(x, y)的返回值来判断x与y的大小
  • bitset：template<size_t N> class bitset{ ...... };比如
    • bitset<40> bst;一个由40位组成的对象




作者：rubbninja
出处：http://www.cnblogs.com/rubbninja/
关于作者：目前主要研究领域为机器学习与无线定位技术，欢迎讨论与指正！

转载于:https://www.cnblogs.com/rubbninja/p/4925633.html

weixin_34336292
关注
C++ 程序设计基本概念 知识点 小结
稚枭天卓
08-12 2618
知识点包括：全局变量的二次赋值；计算转化为二进制后，数字中 1 的数量；用一个非循环表达式判断一个数是否是2的N次方；逻辑运算与位逻辑运算；printf 输入表达式的执行顺序；位运算判断输入参数是否为2的幂次；位运算两个数值的取平均与求和；无判断语句求取变量中较大存在；无中间量交换变量；C/C++关系。
c++程序设计——矢量图管理
LIAO_0312的博客
12-11 1957
矢量图管理系统 摘要 ​ 利用面向对象的封装性、继承性和多态性等技术设计了该矢量图管理系统，可以创建多种矢量图，用智能指针来进行管理矢量图对象的内存申请与释放，并用STL<vector>容器进行矢量图对象的储存。程序界面设计采用了EGE图形库，监听鼠标与键盘消息来实现不同的矢量图图形操作(如选中、拖动、新建、复制、粘贴等)，以及实现了使用文件流从TXT文件读取数据来绘制矢量图图形，并可以再次保存至TXT文件。 1. 总体设计 系统功能： 设置画布绘制矢量图图形 选择TXT文件读取矢量图数据
网络程序设计（C++版） 知识点总结
小张的编程之旅
01-14 2137
1、TCP/IP协议层次,各层协议? 答：应用层、传输层、网络层、链路层； 1）应用层：FTP、Telnet、SMTP、HTTP、RIP、NFS、DNS  （2）传输层：传输控制协议TCP与用户数据报协议UDP （3）网际层协议：网际协议IP、网际控制报文协议ICMP、网际主机组管理协议IGMP、 （4）网络接口层：地址解析协议ARP和RARP 2、在Internet中定位一个应用
Java研发笔记5——C语言程序设计学习笔记4
最新发布
Lbs_gemini0603的博客
10-02 420
Java研发笔记5——C语言程序设计学习笔记4
C++语言程序设计(郑丽)含课本知识点摘要、讲稿、习题答案、例题代码
09-09
内有郑丽版C++课本知识的整理，相信有个这个，您可以把书本丢掉了，此外、还包括讲稿、习题答案和例题代码！
C++程序设计小知识点
成长、蜕变
10-13 443
1、this指针可指向常量型数据、可指向成员函数，不可以指向静态成员函数。 2、宏定义语句：#define BUFSIZE 100; == const int BUFSIZE 100; 3、模板类的基类和派生类都可以是模板类或非模板类。 4、类A声明为类B的友元后，类A直接访问类B的公有成员。 5、对数据进行降幂和检索操作，需要包含头部文件functional。 6、对数据进行升幂等操作，...
C++程序设计知识点汇总
rocsoft
05-05 1200
C++面向对象编程参数传递的方式函数重载内联函数静态变量静态函数C++内存管理指针new和malloc的区别类的构造函数和析构函数类和对象友元函数运算符重载继承虚继承多态静态方式动态方式虚函数纯虚函数抽象类 面向对象编程 面向对象编程是将对象抽象成类，把类的数据与操作封装在一起而进行的编程。 优点：易维护、提高代码复用率 参数传递的方式 数据复制：创建形参，复制实参的值，占用不同的存储空间 地址...
C++课程设计——银行储蓄管理系统
02-13
本篇将详细解析一款使用C++编写的银行储蓄管理系统，这是一个典型的面向对象编程实例，涵盖了文件操作、类的设计与实现、异常处理等多个核心知识点。 首先，银行储蓄管理系统的核心功能包括账户管理、存款、取款、...
软考——程序设计语言知识点总结（文法知识点）
weixin_61187634的博客
10-14 1416
软考-程序设计语言知识点总结（文法知识点）
程序设计——数组知识总结
qq_45793656的博客
12-24 683
程序设计 数组 所谓数组，是有序的元素序列也就是一组相同类型的变量，它们都是为了表示同一批对象的统一属性。若将有限个类型相同的变量的集合命名，那么这个名称为数组名。数组是在程序设计中，为了处理方便， 把具有相同类型的若干元素按无序的形式组织起来的一种形式。这些无序排列的同类数据元素的集合称为数组。而在前面的学习中我们学习了在程序设计中输入小量数据可以用cin语句，如果要输入大量数据用cin语句会很...
C++面向对象程序设计教程——课件PPT
10-19
在“C++面向对象程序设计教程——课件PPT”中，我们可以深入学习这一主题，由陈维兴和林小茶编著，清华大学出版社出版。这套教程通过一系列的PPT章节，详细讲解了C++面向对象编程的关键概念。 首先，第1章“面向...
c++程序设计知识点总结（谭浩强）.docx
09-05
自己整理的山东大学C++考试重点 自己整理的山东大学C++考试重点 自己整理的山东大学C++考试重点
C程序设计复习知识点总结
08-04
C程序设计复习知识点总结
思维导图之C++语言程序设计总结
weixin_33713707的博客
10-18 307
    花了大约一周的时间，将c++的课本过了一遍，米老师说第一遍不求甚解，仅仅管去看就能够了，我很成功地运行了老师这种方法，嘿嘿。那么c++是什么呢？百度上这样说，它是一种使用很广泛的计算机编程语言。C++是一种静态数据类型检查的、支持多重编程范式的通用程序设计语言。它支持过程化程序设计、数据抽象、面向对象程序设计、泛型程序设计等多种程序设计风格。     说的非常厉害，事实上就是一个...
C++程序设计（第3版 谭浩强）重点知识点整理 第四章
m0_59312484的博客
09-13 595
第四章 利用函数实现指定功能 4.1 什么是函数 4.1.1 为什么需要函数 无论是C还是C++，程序中的各项操作基本上都是由函数来实现的，程序编写者要根据需要编写一个个函数，每个函数用来实现某一功能。 4.1.2 函数调用举例 一个函数并不从属于另一个函数，即函数不能嵌套定义，也就是在定义一个函数的过程中又定义另一个函数，也不能把函数的定义部分写在主函数之中。 4.1.3 函数的分类 ①系统函数，即库函数 ②用户自己定义的函数 （1）无参函数 （2）有参...
C++程序设计|基础知识总结（一）
weixin_63336179的博客
02-06 902
C++概述；背景基本知识：进制转换，存储单位，二进制数的编码表示，ASCII码；
C++程序设计|基础知识总结（二）
weixin_63336179的博客
02-14 462
基本类型（关键字，标识符，文字，基本数据类型，变量，操作符，分隔符，空白） 构造类型（数组，结构体，联合体，枚举） 指针类型 空类型
C程序设计重点总结
JessiesCC的博客
03-19 1336
1、参考书和IDE 参考书：《C程序设计（第四版）》，谭浩强著，清华大学出版社，IDE:code::blocks. 2、C语言程序结构 C语言程序由一个主函数和若干个其他函数构成，主函数的作用是按照一定的逻辑顺序调用其他函数，实现C程序的功能，其他函数的作用是实现某个小模块的功能，其他函数之间也可以相互调用，但是不能调用主函数，主函数是有系统调用的。下面是C语言的一段示例，功能是求两个整数...
C++程序设计：数组作为函数参数解析
"这篇课件主要讲解了C++程序设计中...总结来说，这篇课件深入浅出地介绍了C++中数组作为函数参数的原理和使用技巧，同时也涵盖了C++语言的基础知识和C语言的发展历程，对学习C++程序设计的学生提供了宝贵的学习材料。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值