笨蛋学C++ 之 C++ 知识点

本文主要是介绍笨蛋学C++ 之 C++ 知识点，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

C++ 知识点

- 指针常量、常量指针、常量指针常量
- - 1.需要了解
  - - 什么是指针的指向，什么是指针指向的值
  - 2.指针常量
  - - 2.1理解
    - 2.2怎么去看该指针的指向和指针指向的值呢？
    - 2.3总结
  - 3.常量指针
  - - 3.1理解
    - 3.2怎么去看该指针的指向和指针指向的值呢？
    - 3.3总结
  - 4.常量指针常量
  - - 4.1理解
    - 4.2怎么去看该指针的指向和指针指向的值呢？
    - 4.3总结
  - 5.常函数
  - - 在成员函数后加 const 后称为函数为常函数
    - 常函数内不可以修改成员属性
    - 成员属性声明时加关键字mutable后，在常函数中依然可以修改
  - 6.常对象
  - - 声明对象前加 const 称为常对象
    - 常对象只能调用常函数
- 引用
- - 1.引用必须初始化
  - 2.引用在初始化后，不能改变，但是可以进行赋值
  - 3.引用传递，形参修饰实参
  - 4.引用传递不要返回局部变量
  - 5.若函数做左值，则必须返回引用，使用static
  - 6.常量引用（const），无法进行修改，只能读取
- 函数
- - 1.默认参数
  - 2.占位参数
- 重载运算符
- - 函数重载（参数类型、参数顺序、参数个数、参数被const修饰）
- 访问修饰符
- 拷贝构造函数
- - 1.根据创建完毕的对象来初始化新对象
  - 2.值传递的方式给函数参数传值
  - 3.值方式返回局部对象
- 浅拷贝和深拷贝
- this指针
- 友元（friend）
- - 全局函数做友元
  - 类做友元
  - 成员函数做友元
- 运算符重载
- - 重载输出运算符
  - 重载递增/递减运算符
  - 重载赋值运算符
  - 重载关系运算符
  - 重载函数调用运算符（仿函数）
- 模板
- - 1.可以直接用`template <class type>`
  - 2.类模板不能自动推导类型
  - 3.类模板可以指定默认参数
  - 4.类模板的成员函数在调用时创建
  - 5.类模板对象作函数参数
  - 6.类模板对象参数模板化
  - 7.类模板对象类模板化
  - 8.类模板与继承
  - 9.构造函数类外实现
  - 10.分文件编写类模板
  - 11类模板的友元函数

指针常量、常量指针、常量指针常量

1.需要了解

什么是指针的指向，什么是指针指向的值

指针的指向，就是指针变量中存储的内存地址，比如 int *p;，其中*p就是指向int整型的指针
指针指向的值，就是指针指向内存地址所代表的数据，比如 p=&num，其中&num就是内存地址中所存储的数据

2.指针常量

2.1理解

是指用一个 const 修饰一个int 类型常量的指针，所以 *p 的值不能修改，比如const int *p;

2.2怎么去看该指针的指向和指针指向的值呢？

因为 const 修饰的是一个指针，所以该指针的指向不能改变，比如 *p = 20;，这里20就是该指针的指向，指向20的地址
但是被该指针指向的值可以被修改，比如 p=&num;，这里p就可以获取到&num的值

2.3总结

指针本身的地址不可更改，但是指针指向的值可以被修改

3.常量指针

3.1理解

是指用一个 const 修饰一个int *类型的变量，所以 p 的值不能修改，比如 int *const p;

3.2怎么去看该指针的指向和指针指向的值呢？

因为是修饰的是一个变量，所以该指针的指向可以被改变，比如 *p = 20，
但是该指针指向的值不能改变，比如 p = &num，这里p在指向一个地址后，就不能指向另一个地址了

3.3总结

指针本身的地址可以修改，但是指针指向的值可以被修改

4.常量指针常量

4.1理解

是指用两个const，一个const修饰变量，一个const修饰int 类型的指针，比如 const int* const p;

4.2怎么去看该指针的指向和指针指向的值呢？

因为是修饰了一个变量，也修饰了一个int类型的指针，所以该指针的指向不能被改变，比如 *p = 20，
该指针指向的值也不能被改变，比如 p = &num，这里p在指向一个地址后，就不能指向另一个地址了

4.3总结

指针本身的地址不能修改，但是指针指向的值也不能修改

5.常函数

在成员函数后加 const 后称为函数为常函数
```
void showPerson() const{this->name = "lisi";
}
```

常函数内不可以修改成员属性

void showPerson() const{//这里会报错this->name = "lisi";
}

成员属性声明时加关键字mutable后，在常函数中依然可以修改

void showPerson() const{//现在就不会报错了this->name = "lisi";
}mutable string name;

6.常对象

声明对象前加 const 称为常对象
```
const Person p;//常对象
```

常对象只能调用常函数

void showPerson() const{cout << "常函数" << endl;
}
void infoPerson(){cout << "非常函数" << endl;
}
p.showPerson(); //可以调用
p.infoPerson();//不可以调用

引用

1.引用必须初始化

2.引用在初始化后，不能改变，但是可以进行赋值

int a = 20;
int &b = a; //引用进行初始化
int c = 30;
&b = c; //不能改变引用后的值
b = c; //但是可以进行赋值

3.引用传递，形参修饰实参

//函数参数为&a、&b
void swap(int &a,int &b){int temp = a;a = b;b = temp;
}int x = 10;
int y = 20;
swap(x, y);

4.引用传递不要返回局部变量

int &test(){int a = 10;return a;
}int &ref = test();

int &test(){static int a = 10;return a;
}int &ref  = test();

5.若函数做左值，则必须返回引用，使用static

int &test(){static int a = 10;return a;
}test() = 200; //相当于返回的a 是200，不是10

6.常量引用（const），无法进行修改，只能读取

函数

1.默认参数

函数的形参列表中的形参是可以有默认值的
默认参数必须放在参数的末尾
若有传递参数的值，则参数会代替默认参数
若函数声明有默认参数，则函数实现就不能有默认参数

2.占位参数

返回值类型函数名 (数据类型){}
比如重载运算符时，可以使用到占位运算符

重载运算符

函数重载（参数类型、参数顺序、参数个数、参数被const修饰）

访问修饰符

公共权限，public，类内可以访问，类外可以访问
保护权限，protected，类内可以访问，类外不可以访问，子类可以访问父类中的保护内容
私有权限，private，类内可以访问，类外不可以访问，子类不可以访问父类中的私有内容

拷贝构造函数

1.根据创建完毕的对象来初始化新对象

class Person{
public:string name;Person (string name){this->name = name;}Person (const Person &obj){name = obj.name;}
}Person p1("zhangsan");
Person p2(p1);

2.值传递的方式给函数参数传值

void doWork(Person p){}void test(){Person p;doWork(p);
}

3.值方式返回局部对象

void doWork(){Person p1;return p1;
}void test(){Person p = doWorkd();
}

浅拷贝和深拷贝

Person(const Person &obj){//浅拷贝实现name = obj.name;//深拷贝实现name = 	new string(*obj.name);
}

this指针

当形参和成员变量同名时，可用this指针来区分
```
Person(string name){this->name = name;
}
```

在类的非静态成员函数中返回对象本身，可以使用return *this

Person& updateName(Person &p){this->name = p.name+"1";return *this;
}Person p1("zhangsan");
Person p2("lisi");
p2.updateName(p1).updateName(p1).updateName(p1);

友元（friend）

全局函数做友元

#include <iostream>using namespace std;class Person {friend void showPerson(Person* person);public:string name;Person(string name, int age) {this->name = name;this->age = age;}
private:int age;
};void showPerson(Person* person) {cout << "name = " << person->name << "age = " << person->age << endl;
}
int main(void) {Person p("张三", 22);//直接调用友元函数showPerson(&p);return 0;
}

类做友元

class Father {};
class Person {friend void showPerson(Person* person);//可以访问Person类中的成员friend class Father;
public:string name;Person(string name, int age) {this->name = name;this->age = age;}
private:int age;
};

成员函数做友元

#include <iostream>
using namespace std;//预先声明
class Person;class Father {
public://构造函数Father();Person* person;// 访问Person中的私有成员void showPersonInfo();};
class Person {// 声明友元函数，可以访问私有成员friend void Father::showPersonInfo();public:string name;Person(string name, int age) : name(name), age(age) {} // 使用初始化列表
private:int age;
};//初始化函数
Father::Father() {person = new Person("zhangsan", 22);
}void Father::showPersonInfo() {if (person != nullptr) {cout << "name = " << person->name << ", age = " << person->age << endl;}else {cout << "Person pointer is null!" << endl;}
}int main(void) {// 直接调用友元函数Father father;father.showPersonInfo();return 0;
}

运算符重载

成员函数重载

类名 operator 运算符(const 类名& 参数名){}

全局函数重载

类名 operator 运算符(const 类名& 参数名1，const 类名& 参数名2){}

可重载运算符	运算符类型
双目算术运算符	+ (加)，-(减)，*(乘)，/(除)，% (取模)
关系运算符	==(等于)，!= (不等于)，< (小于)，> (大于)，<=(小于等于)，>=(大于等于)
逻辑运算符	\|\|(逻辑或)，&&(逻辑与)，!(逻辑非)
单目运算符	+ (正)，-(负)，*(指针)，&(取地址)
自增自减运算符	++(自增)，–(自减)
位运算符	\| (按位或)，& (按位与)，~(按位取反)，^(按位异或),，<< (左移)，>>(右移)
赋值运算符	=, +=, -=, *=, /= , % = , &=, \|=, ^=, <<=, >>=
空间申请与释放	new, delete, new[ ] , delete[]
其他运算符	()(函数调用)，->(成员访问)，,(逗号)，[](下标)

不可重载运算符	运算符类型
成员访问运算符	.
成员指针访问运算符	.* ，->*
域运算符	::
长度运算符	sizeof
条件运算符	?:
预处理符号	#

重载输出运算符

ostream& operator<<(ostream &cout, Person &p){cout << "name = " << p.name;return cout;
}Person p;
p.name = "zhangsan";
cout << p << "hello" << endl;

重载递增/递减运算符

#include <iostream>
using namespace std;class MyInteger {
public:MyInteger() {this->num = 0;}int num;//重载前置++运算符MyInteger& operator++() {//先进行运算this->num ++;//再将自身返回return *this;}//重载后置++运算符MyInteger operator++(int) {//先记录MyInteger temp = *this;//后递增this->num++;//再返回记录结果return temp;}
};
ostream& operator<<(ostream &cout, MyInteger myInt) {cout << myInt.num;return cout;
}
int main(void) {MyInteger myInt;cout << ++(++myInt) << endl;MyInteger myInts;cout << (myInts++) << endl;cout << (myInts) << endl;return 0;
}

重载赋值运算符

#include <iostream>using namespace std;class Person {
public:Person(int age) {this->age = new int(age);}int *age;Person& operator=(Person &p) {//编译器默认是浅拷贝，即this->age = age;//采用深拷贝if (this->age != NULL) {delete this->age;age = NULL;}this->age = new int(*p.age);return *this;}
};
int main(void) {Person p1(10);Person p2(20);Person p3(30);p3 = p2 = p1;cout << "p1的年龄为：" << *p1.age << endl;cout << "p2的年龄为：" << *p2.age << endl;cout << "p3的年龄为：" << *p3.age << endl;return 0;
}

重载关系运算符

#include <iostream>using namespace std;
class Person {
public:Person( string name,int age) {this->age = age;this->name = name;}int age;string name;bool operator== (Person &p) {if (this->name == p.name && this->age == p.age) {return true;}return false;}};int main(void) {Person p1("zs", 12);Person p2("ls", 12);if (p1 == p2) {cout << "p1 == p2 " << endl;}else {cout << "p1 != p2 " << endl;}return 0;
}

重载函数调用运算符（仿函数）

#include <iostream>using namespace std;class MyPrint {
public://重载函数调用运算符void operator()(string test) {cout << test << endl;}};
int main(void) {MyPrint myPrint;myPrint("111测试111");return 0;
}

模板

1.可以直接用`template <class type>`

2.类模板不能自动推导类型

3.类模板可以指定默认参数

4.类模板的成员函数在调用时创建

class Person1
{
public:void showPerson1(){cout << "Person1 show" << endl;}
};class Person2
{
public:void showPerson2(){cout << "Person2 show" << endl;}
};template<class T>
class MyClass
{
public:T obj;//类模板中的成员函数，并不是一开始就创建的，而是在模板调用时再生成void fun1() { obj.showPerson1(); }void fun2() { obj.showPerson2(); }};void test01()
{MyClass<Person1> m;m.fun1();//m.fun2();//编译会出错，说明函数调用才会去创建成员函数
}int main() {test01();system("pause");return 0;
}

5.类模板对象作函数参数

//1、指定传入的类型
void printPerson1(Person<string, int> &p) 
{p.showPerson();
}
void test01()
{Person <string, int >p("孙悟空", 100);printPerson1(p);
}

6.类模板对象参数模板化

//2、参数模板化
template <class T1, class T2>
void printPerson2(Person<T1, T2>&p)
{p.showPerson();cout << "T1的类型为： " << typeid(T1).name() << endl;cout << "T2的类型为： " << typeid(T2).name() << endl;
}
void test02()
{Person <string, int >p("猪八戒", 90);printPerson2(p);
}

7.类模板对象类模板化

//3、整个类模板化
template<class T>
void printPerson3(T & p)
{cout << "T的类型为： " << typeid(T).name() << endl;p.showPerson();}
void test03()
{Person <string, int >p("唐僧", 30);printPerson3(p);
}

8.类模板与继承

template<class T>
class Base
{T m;
};//class Son:public Base  //错误，c++编译需要给子类分配内存，必须知道父类中T的类型才可以向下继承
class Son :public Base<int> //必须指定一个类型
{
};
void test01()
{Son c;
}//类模板继承类模板 ,可以用T2指定父类中的T类型
template<class T1, class T2>
class Son2 :public Base<T2>
{
public:Son2(){cout << typeid(T1).name() << endl;cout << typeid(T2).name() << endl;}
};void test02()
{Son2<int, char> child1;
}int main() {test01();test02();system("pause");return 0;
}

9.构造函数类外实现

#include <string>//类模板中成员函数类外实现
template<class T1, class T2>
class Person {
public://成员函数类内声明Person(T1 name, T2 age);void showPerson();public:T1 m_Name;T2 m_Age;
};//构造函数 类外实现
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age) {this->m_Name = name;this->m_Age = age;
}//成员函数 类外实现
template<class T1, class T2>
void Person<T1, T2>::showPerson() {cout << "姓名: " << this->m_Name << " 年龄:" << this->m_Age << endl;
}void test01()
{Person<string, int> p("Tom", 20);p.showPerson();
}int main() {test01();system("pause");return 0;
}

10.分文件编写类模板

将声明和实现写到同一个文件中，并更改后缀名为.hpp

#pragma once
#include <iostream>
using namespace std;
#include <string>template<class T1, class T2>
class Person {
public:Person(T1 name, T2 age);void showPerson();
public:T1 m_Name;T2 m_Age;
};//构造函数 类外实现
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age) {this->m_Name = name;this->m_Age = age;
}//成员函数 类外实现
template<class T1, class T2>
void Person<T1, T2>::showPerson() {cout << "姓名: " << this->m_Name << " 年龄:" << this->m_Age << endl;
}//将声明和实现写到一起，文件后缀名改为.hpp
#include "person.hpp"
void test()
{Person<string, int> p("Tom", 10);p.showPerson();
}

11类模板的友元函数

#include <string>//2、全局函数配合友元  类外实现 - 先做函数模板声明，下方在做函数模板定义，在做友元
template<class T1, class T2> class Person;//如果声明了函数模板，可以将实现写到后面，否则需要将实现体写到类的前面让编译器提前看到
//template<class T1, class T2> void printPerson2(Person<T1, T2> & p); template<class T1, class T2>
void printPerson2(Person<T1, T2> & p)
{cout << "类外实现 ---- 姓名： " << p.m_Name << " 年龄：" << p.m_Age << endl;
}template<class T1, class T2>
class Person
{//1、全局函数配合友元   类内实现friend void printPerson(Person<T1, T2> & p){cout << "姓名： " << p.m_Name << " 年龄：" << p.m_Age << endl;}//全局函数配合友元  类外实现friend void printPerson2<>(Person<T1, T2> & p);public:Person(T1 name, T2 age){this->m_Name = name;this->m_Age = age;}private:T1 m_Name;T2 m_Age;};//1、全局函数在类内实现
void test01()
{Person <string, int >p("Tom", 20);printPerson(p);
}//2、全局函数在类外实现
void test02()
{Person <string, int >p("Jerry", 30);printPerson2(p);
}int main() {//test01();test02();system("pause");return 0;
}

这篇关于笨蛋学C++ 之 C++ 知识点的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！