本文主要是介绍笨蛋学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=#，这里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，不是106.常量引用（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++ 知识点的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
