C++学习周记（一）

最新推荐文章于 2024-09-16 13:36:19 发布
最新推荐文章于 2024-09-16 13:36:19 发布
阅读量862 收藏 19
点赞数 25
文章标签： 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_81071972/article/details/135042816
版权

1.1 .1封装的意义

//封装一个圆类，求圆的周长
const double PI = 3.14;

//class代表设计一个类，后面跟着的是类名
class Circle
{
public:  //访问权限  公共的权限

	//属性
	int m_r;//半径

	//行为
	//获取到圆的周长
	double calculateZC()
	{
		//2 * pi  * r
		//获取圆的周长
		return  2 * PI * m_r;
	}
};

示例2：设计一个学生类，属性有姓名和学号，可以给姓名和学号赋值，可以显示学生的姓名和学号

//学生类
class Student {
public:
//行为
	void setName(string name) {
		m_name = name;
	}
	void setID(int id) {
		m_id = id;
	}

	void showStudent() {
		cout << "name:" << m_name << " ID:" << m_id << endl;
	}
private:
//属性
	string m_name;
	int m_id;
};

 

类在设计时，可以把属性和行为放在不同的权限下，加以控制

访问权限有三种：

公共权限  public     类内可以访问  类外可以访问
保护权限  protected  类内可以访问  类外不可以访问
私有权限  private    类内可以访问  类外不可以访问

class Person
{
	//姓名  公共权限
public:
	string m_Name;

	//汽车  保护权限
protected:
	string m_Car;

	//银行卡密码  私有权限
private:
	int m_Password;

public:
	void func()
	{
		m_Name = "张三";
		m_Car = "拖拉机";
		m_Password = 123456;
	}
};

int main() {

	Person p;
	p.m_Name = "李四";
	//p.m_Car = "奔驰";  //保护权限类外访问不到
	//p.m_Password = 123; //私有权限类外访问不到

	system("pause");

	return 0;
}

 

1.1.2 struct和class区别

 

在C++中 struct和class唯一的区别就在于 默认的访问权限不同

区别：

  • struct 默认权限为公共

  • class 默认权限为私有

1.1.3 成员属性设置为私有

优点1：将所有成员属性设置为私有，可以自己控制读写权限

优点2：对于写权限，我们可以检测数据的有效性

示例：

class Person {
public:

	//姓名设置可读可写
	void setName(string name) {
		m_Name = name;
	}

	string getName()
	{
		return m_Name;
	}


	//获取年龄 
	int getAge() {
		return m_Age;
	}

	//设置年龄
	void setAge(int age) {
		if (age < 0 || age > 150) {
			cout << "我今年"<<age<<"岁了~" << endl;
			return;
		}
		m_Age = age;
	}

	//情人设置为只写
	void setLover(string lover) {
		m_Lover = lover;
	}

private:
	string m_Name; //可读可写  姓名
	
	int m_Age; //只读  年龄

	string m_Lover; //只写  情人
};

  

1.2.1 构造函数和析构函数

c++利用了构造函数和析构函数 完成对象的初始化和清理  

  • 构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。

  • 析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作。

 

构造函数语法：类名(){}

  1. 构造函数，没有返回值也不写void

  2. 函数名称与类名相同

  3. 构造函数可以有参数，因此可以发生重载

  4. 程序在调用对象时候会自动调用构造，无须手动调用,而且只会调用一次

构造函数分类
1. 按照参数分类分为 有参和无参构造   无参又称为默认构造函数

示例

    //无参（默认）构造函数
    Person() {
    }
    //有参构造函数
    Person(int a) {
        age = a;
    }

2. 按照类型分类分为 普通构造和拷贝构造 

//拷贝构造函数
    Person(const Person& p) {
        age = p.age;
    } 

 

构造函数调用方式：

（以调用person类的有参的构造函数为例）

括号法


    Person p1(10);
    //注意1：调用无参构造函数不能加括号，如果加了编译器认为这是一个函数声明
    //例如：Person p2()这是一个函数声明;

显示法

Person p2 = Person(10); 

隐式转换法

 Person p4 = 10; // 相当于Person p4 = Person(10); 

析构函数语法： ~类名(){}

  1. 析构函数，没有返回值也不写void

  2. 函数名称与类名相同,在名称前加上符号 '~'

  3. 析构函数不可以有参数，因此不可以发生重载

  4. 程序在对象销毁前会自动调用析构，无须手动调用,而且只会调用一次

  5. 示例

 ~Person()
    {
     
    }

 

1.2.2 拷贝构造函数调用时机

C++中调用拷贝构造函数通常有三种情况 

  • 使用一个已经创建完毕的对象来初始化一个新对象

Person man(100); //p对象已经创建完毕
    Person newman(man); //调用拷贝构造函数 

  • 值传递的方式给函数参数传值

  • 以值方式返回局部对象

 Person doWork( Person p1)/

/相当于Person p1 = p;值传递的方式给函数参数传值
{
    cout << (int *)&p1 << endl;
    return p1;

//相当于p=Person p1;以值方式返回局部对象
}

void test02() {
    Person p; //无参构造函数
   p= doWork(p);
}

 

1.2.3 构造函数调用规则

默认情况下，c++编译器至少给一个类添加3个函数

1．默认构造函数(无参，函数体为空)

2．默认析构函数(无参，函数体为空)

3．默认拷贝构造函数，对属性进行值拷贝

构造函数调用规则如下：

  • 如果用户定义有参构造函数，c++不在提供默认无参构造，但是会提供默认拷贝构造

  • 如果用户定义拷贝构造函数，c++不会再提供其他构造函数

1.2.4 初始化列表

作用：

C++提供了初始化列表语法，用来初始化属性

语法：构造函数()：属性1(值1),属性2（值2）... {}

示例：

 //传统方式初始化

Person(int a, int b, int c) {
    m_A = a;
    m_B = b;
    m_C = c;
}

//初始化列表方式初始化
    Person(int a, int b, int c) :m_A(a), m_B(b), m_C(c) {}

 

 

1.2.5 深拷贝与浅拷贝

浅拷贝：简单的赋值拷贝操作

深拷贝：在堆区重新申请空间，进行拷贝操作

class Person {
public:
	//无参（默认）构造函数
	Person() {
		cout << "无参构造函数!" << endl;
	}
	//有参构造函数
	Person(int age ,int height) {
		
		cout << "有参构造函数!" << endl;

		m_age = age;
		m_height = new int(height);
		
	}
	//拷贝构造函数  
	Person(const Person& p) {
		cout << "拷贝构造函数!" << endl;
		//如果不利用深拷贝在堆区创建新内存，会导致浅拷贝带来的重复释放堆区问题
		m_age = p.m_age;
		m_height = new int(*p.m_height);
		
	}

	//析构函数
	~Person() {
		cout << "析构函数!" << endl;
		if (m_height != NULL)
		{
			delete m_height;
		}
	}
public:
	int m_age;
	int* m_height;
};

void test01()
{
	Person p1(18, 180);

	Person p2(p1);

	cout << "p1的年龄： " << p1.m_age << " 身高： " << *p1.m_height << endl;

	cout << "p2的年龄： " << p2.m_age << " 身高： " << *p2.m_height << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

 

1.2.6 类对象作为类成员

 C++类中的成员可以是另一个类的对象，我们称该成员为 对象成员

示例 

 class A {}
class B
{
    A a；
}

 A与B的构造和析构的顺序:

构造A->构造B->析构B->析构->A

class Phone
{
public:
	Phone(string name)
	{
		m_PhoneName = name;
		cout << "Phone构造" << endl;
	}

	~Phone()
	{
		cout << "Phone析构" << endl;
	}

	string m_PhoneName;

};


class Person
{
public:

	//初始化列表可以告诉编译器调用哪一个构造函数
	Person(string name, string pName) :m_Name(name), m_Phone(pName)
	{
		cout << "Person构造" << endl;
	}

	~Person()
	{
		cout << "Person析构" << endl;
	}

	void playGame()
	{
		cout << m_Name << " 使用" << m_Phone.m_PhoneName << " 牌手机! " << endl;
	}

	string m_Name;
	Phone m_Phone;

};
void test01()
{
	//当类中成员是其他类对象时，我们称该成员为 对象成员
	//构造的顺序是 ：先调用对象成员的构造，再调用本类构造
	//析构顺序与构造相反
	Person p("张三" , "苹果X");
	p.playGame();

}

 

 

1.2.7 静态成员

静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员

静态成员分为：

  • 静态成员变量

    • 所有对象共享同一份数据

    • 在编译阶段分配内存

    • 类内声明，类外初始化

    • 静态成员变量也有访问权限

 

class Person
{
  //类内声明 
public:

    static int m_A; //公共权限

  

private:
    static int m_B; //私有权限
};

//类外初始化 
int Person::m_A = 10;
int Person::m_B = 10;

 访问方式

1、通过对象

Person p1;
cout << "p1.m_A = " << p1.m_A << endl;

2、通过类名

cout << "m_A = " << Person::m_A << endl;

 

  • 静态成员函数

    • 所有对象共享同一个函数

    • 静态成员函数只能访问静态成员变量

class Person
{

public: 
   static void func()//公共权限
    {
        cout << "func调用" << endl;
        m_A = 100;
        //m_B = 100; //错误，不可以访问非静态成员变量
    }

    static int m_A; //静态成员变量
    int m_B; 
private:

    
    static void func2() //私有权限
    {
        cout << "func2调用" << endl;
    }
};
int Person::m_A = 10;

 访问方式

1、通过对象

Person p1;
cout << "p1.m_A = " << p1.m_A << endl;

2、通过类名

cout << "m_A = " << Person::m_A << endl;

 

 

1.3 C++对象模型和this指针

1.3.1 成员变量和成员函数分开存储

在C++中，类内的成员变量和成员函数分开存储

只有非静态成员变量才属于类的对象上

1.3.2 this指针概念

 

this指针指向被调用的成员函数所属的对象

this指针是隐含每一个非静态成员函数内的一种指针

this指针不需要定义，直接使用即可

 

this指针的用途：

  • 当形参和成员变量同名时，可用this指针来区分

 

class Person
{
public:

    Person(int age)
    {
        this->age = age;
    }

    int age;
};
 

 

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

 class Person
{
public:

   Person& PersonAddPerson(Person p)
    {
        this->age += p.age; 
        return *this;//返回对象本身
    }

    int age;
};

 

1.3.3 空指针访问成员函数

C++中空指针也是可以调用成员函数的，但是也要注意有没有用到this指针

class Person {
public:

	void ShowClassName() {
		cout << "我是Person类!" << endl;
	}

	void ShowPerson() {
		if (this == NULL) {
			return;
		}
		cout << mAge << endl;
	}

public:
	int mAge;
};

int main()
{
	Person * p = NULL;
	p->ShowClassName(); //空指针，可以调用成员函数
	p->ShowPerson();  //但是如果成员函数中用到了this指针，空指针错误
return 0；
}

 练习:

《Essential C++》课后习题4.1,4.2

建立Stack.h和Stack.suffix，此处suffix是你的编译器所能接受的扩展名，或是你的项目所使用 的扩展名。编写main()函数，练习操作Stack的所有公开接口，并加以编译执行。程序代码文件和 main()都必须包含Stack.h：#include"Stack.h"

扩展Stack的功能，以支持find()和count()两个操作。find()会查看某值是否存在而返回true或 false。count()返回某字符串的出现次数。重新实现练习4.1的main()，让它调用这两个函数。

//====================================Stack.h===============================
#pragma once
#include<iostream>
#include<vector>
using namespace std;


class Stack {

public:
	bool push(const string&);
	bool pop(string& elem);
	bool peek(string& elem);
	bool find(const string& elem);
	int count(const string& elem);

	bool empty();
	bool full();
	int size();
	Stack() {};
	~Stack() {};
private:
	vector<string>_stack;
};

//=================================Stack.cpp==================================
#include"Stack.h"


bool Stack::empty() {
	return _stack.empty();
}
bool Stack::full() {
	return _stack.size() == _stack.max_size();
	//std::vector::size 返回vector保存的实际对象的数量,
	//std::vector::max_size 返回vector可以容纳的最大元素数
}

bool Stack::push(const string& elem) {
	if (full()) {
		return false;
	}
	_stack.push_back(elem);
	//std::vector::push_back  在vector的尾部添加一个元素。
}

bool Stack::pop(string& elem) {
	if (empty()) {
		return false;
	}
	elem = _stack.back();
	_stack.pop_back();
	//std::vector::pop_back  移出vector尾部的元素。
	return true;
}

bool Stack::peek(string& elem) {
	if (empty())
		return false;
	elem = _stack.back();
	//std::vector::back 返回最后vector一个元素的引用
	return true;
}


int Stack::size() {
	return _stack.size();
}

bool Stack::find(const string& elem) {
	return std::find( _stack.begin(), _stack.end(), elem) != _stack.end();
	//迭代器
}

int Stack::count(const string& elem) {
	return std::count(_stack.begin(), _stack.end(), elem);
	//
}


//=================main.cpp=========================
#include"Stack.h"
void testStack(Stack& stack);


int main() {
    Stack text_1;
    testStack(text_1);
}


void testStack(Stack& stack) {

    // 判断栈是否为空  
    if (stack.empty()) {
        cout << "Stack is empty." << endl;
    }
    else {
        cout << "Stack is not empty." << endl;
    }

  

    // 压栈  
    cout << "Please enter a string of characters" << endl;
    string elem=" ";
    while(1) {
        cin >> elem;
        if (elem == "over") {
            break;
        }
        if (stack.push(elem)) {
            cout << "Pushed element: " << elem << endl;
        }
    }

    // 弹栈  
    string popElem;
    if (stack.pop(popElem)) {
        cout << "Popped element: " << popElem << endl;
    }
    else {
        cout << "Failed to pop element." << endl;
    }

    // 查看栈顶元素  
    string peekedElem;
    if (stack.peek(peekedElem)) {
        cout << "Peeked element: " << peekedElem << endl;
    }
    else {
        cout << "Failed to peek element." << endl;
    }

    // 获取栈的大小  
    int size = stack.size();
    cout << "Stack size: " << size << endl;

    //查找栈中是否存在某个元素
    string to_find;
    cout << "Please enter the element you want to find" << endl;
    cin >> to_find;
    if (stack.find(to_find)) {
        cout << to_find << " found in the stack." << endl;
    }
    else {
        cout << to_find << " not found in the stack." << endl;
    }

    //
    string repeat;
    cout << "Please enter the repeated element " << endl;
    cin >> repeat;
    if (stack.find(repeat)) {
        cout << repeat << " Repeated "<<stack.find(repeat)<<" times." << endl;
    }
    else {
        cout << repeat << " Repeated " << stack.find(repeat) << " times." << endl;
    }


    // 判断栈是否已满  
    if (stack.full()) {
        cout << "Stack is full." << endl;
    }
    else {
        cout << "Stack is not full." << endl;
    }
}

 运行结果

2301_81071972
关注
C++学习周记-第一周
dongwenpu的专栏
03-18 1375
由于想要进行MFC的学习，这周我开始学习C++语言，由于是初学C++，我希望能记下我学习C++语言的点点滴滴，以供今后回味。 C++是面向对象的语言，而C是面向过程的语言，因此两者还是有不小的差异，但C++兼容C语言，因此C语言也能在C++的环境中编写，C++的基本语法与C基本类似，而在C的基础上增加了OOP编程。 刚接触C++，我觉得先熟悉C++的语言，因此选《C++ primer plus》
C++学习笔记（1）
AmazingDlt的博客
04-03 328
一.  内联函数内联函数是指用inline关键字修饰的函数。在类内定义的函数被默认成内联函数。内联函数从源代码层看，有函数的结构，而在编译后，却不具备函数的性质。内联函数不是在调用时发生控制转移，而是在编译时将函数体嵌入在每一个调用处。编译时，类似宏替换，使用函数体替换调用处的函数名。一般在代码中用inline修饰，但是能否形成内联函数，需要看编译器对该函数定义的具体处理。内联扩展是用来消除函数调...
C++学习周记（二）
2301_81071972的博客
12-24 402
一个类中可以有 public、protected、private 三种属性的成员，一般情况下，只有类内的元素可以访问private属性的成员， 如果类外特殊的一些函数或者类需要访问private属性的成员，就需要用到友元的技术(借助关键字friend实现)。为了保持更好的封装性，使之只有特定的函数才可以访问和修改类的内部状态，我们可以只将需要的成员函数作为友元。友元函数访问类的私有成员，通过参数传递对象（可以直接传递对象，也可以传递对象指针或对象引用）这里传递对象的引用，并在访问成员时指明对象。
C++学习周记（三）
2301_81071972的博客
12-31 923
在多继承中，一个派生类对象通过基类指针或引用进行删除，而该派生类对象还包含有动态分配的内存，由于基类指针不能调用派生类的析构函数，那么这些动态分配的内存可能无法被正确释放，从而导致内存泄漏。多态底层是通过动态绑定来实现的，基类的指针p->相应对象的vfptr->访问相应vftabl->（起始值+偏移量）调用的是对应的派生类对象的函数。我们可以将虚函数表看成一个用于存储虚函数的地址的数组，存放虚函数地址的顺序，按照声明的顺序。派生类的虚函数表中将派生类的同名虚函数的地址。为自身的同名虚函数的地址。
C++学习日记 2
01-10
C++学习的每日记事，本次主要内容是C++中的变量名及其命名的一些规则。
计算机实习周记
12-24
计算机应用技术，三年制的大三第一学期的实习周记8篇
实习周记（软件开发）
12-17
【实习周记（软件开发）】是一篇记录个人在软件开发实习过程中的学习与体验的文章。作为实习生，作者通过实际参与项目，积累了丰富的实践经验，并在过程中接触了计算机科学和技术的多个方面。这篇周记可能涵盖了从...
学习周记1：2019.2.18-2019.2.24
陶晨毅的学习笔记
02-18 970
  前言  这学期几乎全是硬核的算法/程序课，为了督促自己认真学习，我将每周写一篇周记。周记模板前一周保留，当周每日更新当日笔记。如有整段文字代码适合另起blog，也将链接标在周记对应的日期下。 课程：算法设计与分析、数字图像处理、程序设计实习、游戏AI中的算法、视觉计算与深度学习、人工智能引论及实践课（NLP）、Python程序设计与数据挖掘导论、大数据分析中的算法   2019....
shader 案例学习笔记之将坐标系分成4个象限
localhost
09-13 213
坐标系被分成了4个单元格，每个单元格都有唯一的索引，后续就可以根据索引去渲染。
UEFI学习笔记（五）：EDK II PCD的概念、类型、使用
qq_44189622的博客
09-11 851
如果在BIOS里面有一些模块是binary方式集成进来的而这些binary又需要用到PCD（用于Binary Release），那么这些Binary集成的要用到的PCD就必须要设置为。PCD的值存在memory里面，下次启动时，上次更改的值丢失了，每次启动都是从default值开始。是存在VPD空间的（在FLASH上，只读），一般是出厂配置。如果platform是从源码build出来的，没有binary在里面的时候，PCD用的都是。作用域在一个模块中（模块级的），可以在Binary Level进行修改。
看Threejs好玩示例，学习创新与技术(二)
htsitr2的专栏
09-14 483
它的主要特点是确保生成的点之间保持一定的最小距离，从而避免点的聚集。这种方法在计算机图形学、游戏开发、物理模拟等领域中非常有用，尤其是在需要生成自然分布的对象（如树木、石头等）时。如果不进行裁剪，那么效果如下（初步的锯齿感是因为矩形内采样的结果）。为啥这么复杂呢，为啥不开始存储每个方块的UV呢？下面代码的vTexCoords（=savedModelMatrix，已修改）记录方块所在的位置，vWorldPosition表示方块中像素的偏移。在上面那副图中，聪明的你一定初步猜到了每个方块的纹理是怎么得到的。
计算几何学习
网安小白
09-12 451
学习计算几何过程中对经典算法的记录
如何用3个月零基础入门网络安全？_网络安全零基础怎么学习
2401_84466224的博客
09-11 940
我们知道计算机最早是在西方发明出来的，很多名词或者代码都是英文的，甚至现有的一些教程最初也是英文原版翻译过来的，而且一个漏洞被发现到翻译成中文一般需要一个星期的时间，在这个时间差上漏洞可能都修补了。”答案是否定的，黑客用的电脑,不需要什么高的配置,只要稳定就行.因为黑客所使用的一些程序,低端CPU也可以很好的运行,而且不占什么内存.还有一个,黑客是在DOS命令下对进行的,所以电脑能使用到最佳状态!观看学习近十年所有0day挖掘的帖，然后搭建环境，去复现漏洞，去思考学习笔者的挖洞思维，培养自己的渗透思维。
关于HarmonyOS的学习
最新发布
m0_72035166的博客
09-16 864
1.node模块化​​​​// tab()2.path模块// path内置模块，专门用来处理路径​// 获取路径最后一部内容，一般用它来获取文件名称​// 给定的路径连接在一起，可以把路径片段拼成完整路径// const result = path.join('day13', 'code', '03_path模块.js')// const result = path.join('day13', 'code', '../','03_path模块.js')​。
【学习笔记】SSL密码套件之哈希
Taki_UP的博客
09-12 1180
本篇介绍了TLS/SSL密码套件中常用的哈希算法，包括Poly1305、SHA384、SHA256、SHA、MD5
C语言从头学59——学习头文件math.h（二）
m0_72128260的博客
09-11 554
继续学习头文件的数学函数。
(更新20240727)机器视觉康耐视visionpro学习步骤
视觉人机器视觉的博客
09-16 156
(更新20240727)机器视觉康耐视visionpro学习步骤
AdaBoost算法（AdbBoost Algorithm）—有监督学习方法、非概率模型、判别模型、非线性模型、非参数化模型、批量学习
nanxiaotao的博客
09-11 874
AdaBoost算法（AdbBoost Algorithm）—有监督学习方法、非概率模型、判别模型、非线性模型、非参数化模型、批量学习
C++学习路径与经典书籍推荐
"这篇文章主要探讨了学习C++的书籍推荐，包括初级、进阶和专业层次的资源。" 学习C++的过程通常分为几个阶段，从基础到深入，每个阶段都有相应的经典书籍作为指导。首先，对于初学者，推荐的是"C++ Primer"这本书，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值