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

2024-05-09 19:36
文章标签 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++ 知识点的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/974300。

相关文章

C#如何调用C++库

C#如何调用C++库

《C#如何调用C++库》：本文主要介绍C#如何调用C++库方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录方法一：使用P/Invoke1. 导出C++函数2. 定义P/Invoke签名3. 调用C++函数方法二：使用C++/CLI作为桥接1. 创建C++/CL
阅读更多...
C++如何通过Qt反射机制实现数据类序列化

C++如何通过Qt反射机制实现数据类序列化

《C++如何通过Qt反射机制实现数据类序列化》在C++工程中经常需要使用数据类,并对数据类进行存储、打印、调试等操作,所以本文就来聊聊C++如何通过Qt反射机制实现数据类序列化吧... 目录设计预期设计思路代码实现使用方法在 C++ 工程中经常需要使用数据类，并对数据类进行存储、打印、调试等操作。由于数据类
阅读更多...
Linux下如何使用C++获取硬件信息

Linux下如何使用C++获取硬件信息

《Linux下如何使用C++获取硬件信息》这篇文章主要为大家详细介绍了如何使用C++实现获取CPU,主板,磁盘,BIOS信息等硬件信息,文中的示例代码讲解详细,感兴趣的小伙伴可以了解下... 目录方法获取CPU信息：读取"/proc/cpuinfo"文件获取磁盘信息：读取"/proc/diskstats"文
阅读更多...
C++使用printf语句实现进制转换的示例代码

C++使用printf语句实现进制转换的示例代码

《C++使用printf语句实现进制转换的示例代码》在C语言中,printf函数可以直接实现部分进制转换功能,通过格式说明符（formatspecifier）快速输出不同进制的数值,下面给大家分享C+... 目录一、printf 原生支持的进制转换1. 十进制、八进制、十六进制转换2. 显示进制前缀3. 指
阅读更多...
C++中初始化二维数组的几种常见方法

C++中初始化二维数组的几种常见方法

《C++中初始化二维数组的几种常见方法》本文详细介绍了在C++中初始化二维数组的不同方式,包括静态初始化、循环、全部为零、部分初始化、std::array和std::vector,以及std::vec... 目录1. 静态初始化2. 使用循环初始化3. 全部初始化为零4. 部分初始化5. 使用 std::a
阅读更多...
C++ vector的常见用法超详细讲解

C++ vector的常见用法超详细讲解

《C++vector的常见用法超详细讲解》：本文主要介绍C++vector的常见用法,包括C++中vector容器的定义、初始化方法、访问元素、常用函数及其时间复杂度,通过代码介绍的非常详细,... 目录1、vector的定义2、vector常用初始化方法1、使编程用花括号直接赋值2、使用圆括号赋值3、ve
阅读更多...
如何高效移除C++关联容器中的元素

如何高效移除C++关联容器中的元素

《如何高效移除C++关联容器中的元素》关联容器和顺序容器有着很大不同,关联容器中的元素是按照关键字来保存和访问的,而顺序容器中的元素是按它们在容器中的位置来顺序保存和访问的,本文介绍了如何高效移除C+... 目录一、简介二、移除给定位置的元素三、移除与特定键值等价的元素四、移除满足特android定条件的元
阅读更多...
Python获取C++中返回的char*字段的两种思路

Python获取C++中返回的char*字段的两种思路

《Python获取C++中返回的char*字段的两种思路》有时候需要获取C++函数中返回来的不定长的char*字符串,本文小编为大家找到了两种解决问题的思路,感兴趣的小伙伴可以跟随小编一起学习一下... 有时候需要获取C++函数中返回来的不定长的char*字符串，目前我找到两种解决问题的思路，具体实现如下：
阅读更多...
C++ Sort函数使用场景分析

C++ Sort函数使用场景分析

《C++Sort函数使用场景分析》sort函数是algorithm库下的一个函数,sort函数是不稳定的,即大小相同的元素在排序后相对顺序可能发生改变,如果某些场景需要保持相同元素间的相对顺序,可使... 目录C++ Sort函数详解一、sort函数调用的两种方式二、sort函数使用场景三、sort函数排序
阅读更多...
Java调用C++动态库超详细步骤讲解(附源码)

Java调用C++动态库超详细步骤讲解(附源码)

《Java调用C++动态库超详细步骤讲解(附源码)》C语言因其高效和接近硬件的特性,时常会被用在性能要求较高或者需要直接操作硬件的场合,：本文主要介绍Java调用C++动态库的相关资料,文中通过代... 目录一、直接调用C++库第一步：动态库生成（vs2017+qt5.12.10）第二步：Java调用C++
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2