CPP笔记

字数统计: 2.7k字   |   阅读时长≈ 12分

CPP笔记

开始细学CPP了，把之前本科毕设的捡起来，这次要学的更细。

CPP和C区别

面向对象特性，引用，STL，模板，C++11后的一系列东西。

引用

引用是变量的一个别名。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
int    i;
double d;

// 声明引用变量
int&    r = i;
double& s = d;

i = 5;
cout << "Value of i : " << i << endl;
cout << "Value of i reference : " << r  << endl;

d = 11.7;
cout << "Value of d : " << d << endl;
cout << "Value of d reference : " << s  << endl;

&读做引用，对r操作和对i操作结果相同。
引用替代指针能使C++程序更容易阅读和维护。

引用用作函数参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
void swap(int& x, int& y)
{
   int temp;
   temp = x; /* 保存地址 x 的值 */
   x = y;    /* 把 y 赋值给 x */
   y = temp; /* 把 x 赋值给 y  */
  
   return;
}
int main ()
{
   // 局部变量声明
   int a = 100;
   int b = 200;
 
   cout << "交换前，a 的值：" << a << endl;
   cout << "交换前，b 的值：" << b << endl;
 
   /* 调用函数来交换值 */
   swap(a, b);
 
   cout << "交换后，a 的值：" << a << endl;
   cout << "交换后，b 的值：" << b << endl;
 
   return 0;
}

原理和指针差不多，本质都是根据传入的内存地址访存。

引用用作函数返回值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
double& setValues(int i) {  
   double& ref = vals[i];    
   return ref;   // 返回第 i 个元素的引用，ref 是一个引用变量，ref 引用 vals[i] 
}
int main ()
{
 
   cout << "改变前的值" << endl;
   for ( int i = 0; i < 5; i++ )
   {
       cout << "vals[" << i << "] = ";
       cout << vals[i] << endl;
   }
 
   setValues(1) = 20.23; // 改变第 2 个元素
   setValues(3) = 70.8;  // 改变第 4 个元素
 
   cout << "改变后的值" << endl;
   for ( int i = 0; i < 5; i++ )
   {
       cout << "vals[" << i << "] = ";
       cout << vals[i] << endl;
   }
   return 0;
}

返回的ref可以用在表达式左部。
用指针的话要写成这样

1
2
3
4
5
6
double *setValues_PTR(int i)
{
    double *ref = &vals[i];
    return ref; // 返回第 i 个元素的引用，ref 是一个引用变量，ref 引用 vals[i]
}
*(setValues_PTR(2)) = 2.23; // 改变第 3 个元素

两者都是根据指针实现的

类

关键字class开头，后面跟类的名称

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
class Box
{
   public:
      double length;   // 长度
      double breadth;  // 宽度
      double height;   // 高度
      // 成员函数声明
      double get(void);
      void set( double len, double bre, double hei );
};
// 成员函数定义
double Box::get(void)
{
    return length * breadth * height;
}
 
void Box::set( double len, double bre, double hei)
{
    length = len;
    breadth = bre;
    height = hei;
}
int main( )
{
   Box Box1;     
   Box Box2;     
   Box Box3;     
   double volume = 0.0; 
   Box1.height = 5.0; 
   Box1.length = 6.0; 
   Box1.breadth = 7.0;
   Box2.height = 10.0;
   Box2.length = 12.0;
   Box2.breadth = 13.0;
 
   volume = Box1.height * Box1.length * Box1.breadth;
   cout << "Box1 的体积：" << volume <<endl;
 
   volume = Box2.height * Box2.length * Box2.breadth;
   cout << "Box2 的体积：" << volume <<endl;
 
   Box3.set(16.0, 8.0, 12.0); 
   volume = Box3.get(); 
   cout << "Box3 的体积：" << volume <<endl;
   return 0;
}

内部可以定义函数，内部的定义的函数是内联的，
类访问修饰符public、private、protected，默认privite。
public是公有，外部也能访问。
private是受保护成员，类的外部不可访问，只有类和友元函数可以访问。
protected类似受保护成员，但是在派生类可以访问。
继承时也可以加关键字。

  1. public 继承：基类 public 成员，protected 成员，private 成员的访问属性在派生类中分别变成：public, protected, private
  2. protected 继承：基类 public 成员，protected 成员，private 成员的访问属性在派生类中分别变成：protected, protected, private
  3. private 继承：基类 public 成员，protected 成员，private 成员的访问属性在派生类中分别变成：private, private, private

构造+析构

构造：在创建类的时候执行，函数名称和类名完全相同，并且无返回值。
析构：类名的函数前面加了~，资源释放的时候执行，delete或者主函数返回后操作系统释放资源。

深浅拷贝

浅拷贝只是对指针的拷贝，拷贝后两个指针指向同一个内存空间，深拷贝不但对指针进行拷贝，而且对指针指向的内容进行拷贝，经深拷贝后的指针是指向两个不同地址的指针。

默认拷贝是浅拷贝

1
2
Stu stu1(70,80,90);
Stu stu2(stu1);

这样进行的是浅拷贝，释放空间的时候会释放同一个区域两次，然后触发异常。
拷贝构造函数定义：

1
2
3
4
5
Stu::Stu(const Stu &obj){
    cout<<"运行复制构造函数 深拷贝 但未初始化"<<endl;
}
Stu stu1(70,80,90);
Stu stu2(stu1);

就不会报错。

友元函数

friend关键字
类的友元函数是定义在类外部，但有权访问类的所有私有（private）成员和保护（protected）成员。尽管友元函数的原型有在类的定义中出现过，但是友元函数并不是成员函数。

this指针

类中使用，指向自己的地址

C++类内存空间

子类父类同名

子类会隐藏父类中的变量，要访问的话要用作用域符号::

重载

命名重复情况

虚函数

函数重载

同一个函数明，函数参数不同可以调用不同的函数，不能仅通过返回值实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class printData
{
   public:
      void print(int i) {
        cout << "整数为: " << i << endl;
      }
 
      void print(double  f) {
        cout << "浮点数为: " << f << endl;
      }
 
      void print(char c[]) {
        cout << "字符串为: " << c << endl;
      }
};
pd.print(5);
pd.print(500.263);

运算符重载

重载内置运算符

1
2
3
4
5
6
7
8
9
Box operator+(const Box& b)
{
    Box box;
    box.length = this->length + b.length;
    box.breadth = this->breadth + b.breadth;
    box.height = this->height + b.height;
    return box;
}
Box3 = Box1+Box2;

多数运算符都可以重载，以下不可重载：

  1. .
  2. ->
  3. ::
  4. sizeof
  5. ?:
  6. #

多态

当类之间存在层次结构，并且类之间通过继承关联时就会用到多态.
调用成员函数时根据成员函数类型执行不同的函数

虚函数

A的B的父类，A中func()定义为虚函数，func(int)不定义为虚函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
class A
{
public:
   virtual void func()
   {
      cout << "A - func()调用" << endl;
   }

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

};

class B : public A
{
public:
   void func()
   {
      cout << "B - func()调用" << endl;
   }
   void func(int a)
   {
      cout << "B - func(int a)调用" << endl;
   }

};

void test01()
{
   A *s = new A;

   s->func();
   cout<<sizeof(*s) << endl;
   delete s;
   // delete s;
   s = new B;
   s->func();       //调用 B
   s->func(10);      //调用 A
   s->func(10,2);      //调用 A
   cout<<sizeof(*s) << endl;

   B *s2 = new B;
   s2->func();       //调用 B
   s2->func(10);    //调用 B
   s2->A::func(10); //调用 A
   // s2.func(1,2);  //报错
}

定义A类型指针指向开辟的B类区域。func()函数在基类A中定义为虚函数，调用时执行B的函数，其余两种执行的A中的。
定义B类型的指向开辟的B类区域，执行就是B中的函数，调用A中同名需要增加域操作指定。
不使用虚函数的话s->func()不会调用B中函数，因为会静态链接好，
纯虚函数
为了在派生类中重新定义该函数，基类中没什么意义的时候用到。

1
virtual int area() = 0;

告诉编译器函数没有主体。
有纯虚函数的类不难直接初始化，必须派生使用。

模板

函数模板一般类型

1
2
3
4
template <typename type> ret-type func-name(parameter list)
{
   // 函数的主体
}

<>里面放指定类型，用type占位，调用的时候指定类型，可以实现类型的传递。

类模板类似。

1
2
3
template <class type> class class-name {
.
}

具体实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
#include <iostream>
#include <string>
using namespace std;
//类模板
template <class T>
class Func
{
public:
   Func(T t1, T t2)
   {
      this->m_t1 = t1;
      this->m_t2 = t2;
   }
   void Print(void);
   void GetMaxMinNum(void);
   void Swap(void);
   void test(void)
   {
      Print();
      GetMaxMinNum();
      Swap();
      Print();
   }

public:
   T m_t1;
   T m_t2;
};
template <class T>
void Func<T>::Print(void)
{
   cout << "顺序输出变量" << endl;
   cout << this->m_t1 << endl;
   cout << this->m_t2 << endl;
}

template <class T>
void Func<T>::GetMaxMinNum(void)
{
   cout << "获得最大值最小值" << endl;
   if (this->m_t1 > this->m_t2)
      cout << "大数" << this->m_t1 << "小数" << this->m_t2 << endl;
   else
      cout << "大数" << this->m_t2 << "小数" << this->m_t1 << endl;
}

template <class T>
void Func<T>::Swap(void)
{
   cout << "交换变量" << endl;
   T temp = this->m_t1;
   this->m_t1 = this->m_t2;
   this->m_t2 = temp;
}

int main()
{
   Func<int> a(2, 3);
   a.test();
   Func<float> b(2.5, 3.5);
   b.test();
   Func<char> c('a', 'b');
   c.test();

   return 0;
}

STL

容器

用来管理某一类对象的集合。

vector

vector是将元素放到动态数组中加以管理的容器。vector容器可以随机存取元素，也就是说支持[]运算符和at方式存取。
vector在尾部添加或者移除元素非常快，在中间操作非常耗时，因为它需要移动元素。
基本用法

  • front()返回头部元素的引用，可以当左值
  • back()返回尾部元素的引用，可以当左值
  • push_back()添加元素，只能尾部添加
  • pop_back()移除元素，只能在尾部移除
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#include <iostream>
#include <vector>
using namespace std;
 
int main()
{
   // 创建一个向量存储 int
   vector<int> vec; 
   int i;
 
   // 显示 vec 的原始大小
   cout << "vector size = " << vec.size() << endl;
 
   // 推入 5 个值到向量中
   for(i = 0; i < 5; i++){
      vec.push_back(i);
   }
 
   // 显示 vec 扩展后的大小
   cout << "extended vector size = " << vec.size() << endl;
 
   // 访问向量中的 5 个值
   for(i = 0; i < 5; i++){
      cout << "value of vec [" << i << "] = " << vec[i] << endl;
   }
 
   // 使用迭代器 iterator 访问值
   vector<int>::iterator v = vec.begin();
   while( v != vec.end()) {
      cout << "value of v = " << *v << endl;
      v++;
   }
 
   return 0;
}

list

queue

set

map

算法

作用于算法

迭代器

cmake

string类

赏

谢谢你请我吃糖果

支付宝、QQ、微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

研究生就读专业：
微电子学与固体电子学
从事方向：
数字集成电路设计、计算机体系结构

联系QQ:1271661038