C++学习笔记（六）

最新推荐文章于 2023-09-20 09:03:59 发布
最新推荐文章于 2023-09-20 09:03:59 发布
阅读量148 收藏
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45445740/article/details/111505755
版权

目录六

十七.拷贝构造和拷贝赋值

2.拷贝赋值

eg.A a1;
   A a2 = a1; //拷贝构造
   A a3;
   a3 = a1; //拷贝赋值

①当两个对象进行赋值操作时，比如“i3=i2”,编译器会自动将其处理为i3.operator=(i3)成员函数调用形式，其中"operator="被称为拷贝赋值操作符函数，由该函数实现两个对象复制，其返回结果就是表达式结果。
②如果自己没有定义拷贝赋值函数，那么编译器会为类提供一个缺省的拷贝赋值函数，但是缺省的拷贝赋值函数是浅拷贝，可能会有数据共享、double free、内存泄漏等问题，

//举例：
int* i2 = new int(100);
int* i3 = new int(0);
i3 = i2;
//（相当于将i3直接指向了i2这块内存，数据上是对的，正确赋值了，但delete时会报错double free，原来i3上的内存就造成了泄露）

如下图：
在这里插入图片描述
为了避免这些问题，必须自己定义一个深拷贝赋值函数（注意按照下面的格式）：

类名& operator=(const 类名& that){
	if(&that != this){//防止自赋值
		//释放旧内存;
		//分配新内存;
		//拷贝新数据;
	}
	return *this;//返回自引用
}

在这里插入图片描述
在这里插入图片描述
eg.

#include <iostream>
using namespace std;
class Integer{
public:
    Integer(int i):m_pi(new int(i)){
        //m_pi = new int(i);
    }
    void print(void) const {
        cout << *m_pi << endl;
    }
    ~Integer(void){
        cout << "析构函数:" << m_pi << endl;
        delete m_pi;
    }
    //缺省的拷贝构造函数(浅拷贝)
    /*Integer(const Integer& that){
        cout << "缺省的拷贝构造函数" << endl;
        m_pi = that.m_pi;
    }*/
    //自定义拷贝构造函数(深拷贝)
    Integer(const Integer& that){
        cout << "自定义拷贝构造函数" << endl;
        m_pi = new int;
        *m_pi = *that.m_pi;
    }
    //缺省拷贝赋值函数(浅拷贝)
    //i3=i2 ==> i3.operator=(i2)
    /*Integer& operator=(const Integer& that){
        cout << "缺省拷贝赋值函数" << endl; 
        if(&that != this){//防止自赋值
            m_pi = that.m_pi;
        }
        return *this;//返回自引用
    }*/
    //自定义拷贝赋值函数(深拷贝)
    Integer& operator=(const Integer& that){
        cout << "自定义拷贝赋值函数" << endl;
        if(&that != this){//防止自赋值
            delete m_pi;//释放旧内存
            m_pi = new int;//分配新内存
            *m_pi = *that.m_pi;//拷贝新数据
        }
        return *this;//返回自引用
    }

private:
    int* m_pi;
};
int main(void){
    Integer i1(100);
    Integer i2(i1);//拷贝构造
    i1.print();//100
    i2.print();//100
    Integer i3(0);
    //i3.operator=(i2);
    i3 = i2;//拷贝赋值
    i3.print();//100
    return 0;
}

练习

练习：参考上一节的String类，除了实现字符串类(String)里包括构造函数、析构函数、拷贝构造函数以外，增加拷贝赋值函数。

#include <iostream>
#include <cstring>
#pragma warning( disable : 4996 ) 
using namespace std;

class String
{
public:
	//构造函数：支持const char*字符串：动态分配内存
	String(const char* str = NULL)
	{
		m_str = new char[strlen(str ? str : "") + 1]; //防止str是空的字符串，就会报错;动态分配内存，在原有字符串长度基础上＋1
		strcpy(m_str, str ? str : "");//字符串拷贝赋值操作，同样防止str为空的情况
	}

	//析构函数：主要负责清理对象生命周期中的动态资源
	~String(void)
	{
		//cout << "析构函数：" << &m_str << endl;
		cout << "析构函数：" << (void*)m_str << endl; // 打印delete的地址
		if (m_str) // 若字符串是空的则跳过，若不是空的则要释放内存
		{
			delete[] m_str; //因为申请的内存是char[]，则释放时是delete[]
			m_str = NULL;
		}
	}

	//拷贝构造函数
	String(const String& that)
	{
		m_str = new char[strlen(that.m_str) + 1];
		strcpy(m_str, that.m_str);
		//*m_str = *that.m_str; //这么写相当于只复制了字符串中的第一个元素，与11copy.cpp里面不一样，那里是int类型
	}

	//拷贝赋值
	//str2 = str3 ==> str2.operator=(str3)
	String& operator=(const String& that)
	{
		if (&that != this) //防止自赋值
		{
			//方法一：推荐
			delete[] m_str;//释放旧内存
			m_str = new char[strlen(that.m_str) + 1];//分配新内存
			strcpy(m_str, that.m_str);//拷贝新数据

			//方法二
			//有的人认为方法一会出现释放旧内存后，新内存分配失败，会导致程序崩溃，虽然这可能性很低。
			//方法二的思想是先分配一块新内存，然后释放旧内存，即将方法一的步骤倒一下
			/*char* str = new char[strlen(that.m_str)+1];
			delete[] m_str;
			m_str = strcpy(str,that.m_str);*/

			//方法三：
			//String temp(that);//经过拷贝构造，临时变量里面的指针指向的是新分配的内存，数据也是拷贝后的新的字符串
			//swap(m_str,temp.m_str);//swap()函数用于交换两个指针的指向，相当于str2指针指向新内存新字符串，临时对象的指针指向旧内存旧字符串
		}
		return *this; //返回自引用
	}

	//打印函数
	void print(void)const
	{
		cout << m_str << endl;
	}

private:
	char* m_str;
};

int main(void)
{
	String str("buding");
	str.print();
	String str2 = "duoduo";
	str2.print();

	String str3 = "dummer";
	str2 = str3;
	str2.print();
	return 0;
}

十八.静态成员(static)

1.静态成员变量

  class 类名
  {
  		static 数据类型 变量名;//声明
  };
  数据类型 类名::变量名 = 初值;//定义和初始化

①普通成员变量属于对象，而静态成员变量不属于对象，静态成员变量内存在数据段(全局区)，可以把静态成员变量理解为是被限制在类的内部去使用的全局变量。
②普通成员变量需要在构造时定义和初始化，而静态成员变量需要在类的外部单独定义和初始化。
③使用方法
类名::静态成员变量;（推荐） eg.A::s_data
对象名.静态成员变量；和上面等价（不推荐，容易和普通成员变量混淆） eg.a.s_data
eg.

#include <iostream>
using namespace std;
class A{
public:
    //普通成员变量在构造时定义和初始化
    A(int data = 0):m_data(data){}
    int m_data;//声明普通成员变量
    static int s_data;//声明静态成员变量

    //const和static同时修饰的成员变量,需要在声明时初始化(特殊,了解)
    const static int cs_data = 0;//ok
};
//静态成员变量需要在类的外部单独定义和初始化
int A::s_data = 20;

int main(void){
    A a(10);
    cout << "size=" << sizeof(a) << endl;//4
    //普通成员变量是属于对象的一部分，必须通过对象才能访问
    cout << a.m_data << endl;//10
    //cout << A::m_data << endl;//error

    //静态成员变量即使没有对象时，也可以通过"类名::"可以直接访问
    cout << A::s_data << endl;//20
    cout << a.s_data << endl;//ok

    /*下面是一道笔试题，普通成员变量没有变，静态成员变量变了
    A a2(10);
    a2.m_data = 11;
    a2.s_data = 22;
    cout << a.m_data << endl;//10
    cout << a.s_data << endl;//22*/

    return 0;
}

2.静态成员函数

class 类名{
		static 返回类型 函数名(形参表){
			函数体;
		}
};

①静态成员函数没有this指针，也没有常属性（即不能加const），可以把它理解为是被限制在类的内部使用的全局函数。
②使用方法
类名::静态成员函数(实参表)；（推荐）
对象名.静态成员函数(实参表);//和上面等价（不推荐，容易和普通成员函数混淆）

（注：在静态成员函数中只能访问静态成员，因为静态成员函数没有this指针；在非静态成员函数中既可以访问静态成员，也可以访问非静态成员）

eg.

#include <iostream>
using namespace std;
class A{
public:
    A(void):m_data(10){}
    static void func1(void){
        cout << "静态成员函数" << endl;
        //在静态成员函数中只能访问静态成员，因为其没有this指针
        //cout << m_data << endl;//error
        cout << s_data << endl;
    }
    void func2(void) const {
        cout << "非静态成员函数" << endl;
        //在非静态成员函数中既可以访问静态成员，也可以访问非静态成员
        cout << m_data << endl;
        cout << s_data << endl;
    }
    int m_data;
    static int s_data;
};
int A::s_data = 20;

int main(void){
    A::func1();//不用对象，可以通过类名直接调用静态成员函数
    //A::func2();//error，无法通过类名调用非静态成员函数
    A a;
    a.func2();//ok，通过对象，可以调用非静态成员函数，也可以调用静态成员函数
    a.func1();//ok

    return 0;
}

3.单例模式

①概念
一个类只允许存在唯一的对象，并提供它的访问方法。

②实现思路
–》禁止在类的外部创建对象：私有化构造函数，同时将缺省的构造函数也声明为私有
–》类的内部维护唯一的对象：静态成员变量
–》提供单例对象的访问方法：静态成员函数

③创建方式
–》饿汉式：单例对象无论用或不用，程序启动即创建

eg.  static A m_a;

优点：代码实现简单，多线程安全，访问使用效率高（以空间换时间）
缺点：浪费内存
eg.编程思路：单例对象无论用或不用，程序启动即创建。

#include <iostream>
using namespace std;
//单例模式:饿汉式
class Singleton{
public:
    //3)使用静态成员函数获取单例对象
    static Singleton& getInstance(void){
        return s_instance;
    }
    void print(void) const{
        cout << m_data << endl;
    }
private:
    //1)私有化构造函数
    Singleton(int data):m_data(data){
        cout << "单例对象被创建了" << endl;
    }
    //将缺省的拷贝构造函数声明为私有
    Singleton(const Singleton&);
    //2)使用静态成员变量来维护唯一的对象
    static Singleton s_instance;//声明
private:
    int m_data;
};
Singleton Singleton::s_instance(123);//定义（静态成员变量需要在类的外部单独定义和初始化）
int main(void){
    //Singleton s(123);
    //Singleton* ps = new Singleton(123);
    cout << "main开始运行" << endl;
    Singleton& s1 = Singleton::getInstance();
    Singleton& s2 = Singleton::getInstance();
    Singleton& s3 = Singleton::getInstance();
    s1.print();
    s2.print();
    s3.print();
    cout << "&s1=" << &s1 << endl;
    cout << "&s2=" << &s2 << endl;
    cout << "&s3=" << &s3 << endl;
    
    //Singleton s4 = s1;//拷贝构造,应该error
    //cout << "&s4=" << &s4 << endl;

    return 0;
}

–》懒汉式：单例对象用时再创建，不用即销毁

eg.  static A* m_a;

优点：节省内存（以时间换空间）
缺点：访问使用效率低，多线程中需要加锁保护，代码实现复杂
eg.编程思路：单例对象用时再创建，不用即销毁（单线程示例）

#include <iostream>
using namespace std;
//单例模式:懒汉式
class Singleton {
public:
    //3)使用静态成员函数获取单例对象
    static Singleton& getInstance(void) {
        if (s_instance == NULL)//只有当s_instance为空时再new一块空间创建单例对象，否则即直接返回*s_instance，即防止多次new，保证一个类只允许存在唯一的对象的单例对象
        {
            s_instance = new Singleton(123);
        }
        ++s_count;//s_count = s_count + 1，每次调用getInstance()函数，即表示一个使用者，则计数+1
        return *s_instance;
    }
    //单例对象不用即销毁,销毁时机?
    //所有的使用者都不再使用,才能销毁
    //这里销毁不用析构函数，因为析构函数销毁的是对象在执行时产生的动态资源内容，而我们这里要销毁的是对象自身
    void release(void) {
        if (--s_count == 0) {
            delete s_instance; //析构函数在delete后执行
            s_instance = NULL;
        }
    }
    void print(void) const {
        cout << m_data << endl;
    }
private:
    //1)私有化构造函数
    Singleton(int data) :m_data(data) {
        cout << "单例对象被创建了" << endl;
    }
    //将缺省的拷贝构造函数声明为私有
    Singleton(const Singleton&);
    //析构函数
    ~Singleton(void) {
        cout << "单例对象被销毁了" << endl;
    }

    //2)使用静态成员变量来维护唯一的对象
    static Singleton* s_instance;//声明，这里是用指针的形式，与饿汉式不同
    //计数:记录单例对象使用者的个数
    static int s_count;
private:
    int m_data;
};
//这里也和饿汉式不同，先初始化s_instance为空指针（即可认为是：程序启动后，只有一个空指针，单例对象还未被创建，只是有一个可以指向单例对象的指针而已。）
Singleton* Singleton::s_instance = NULL;
//当一个共享内存被多个使用者使用时，逻辑应该是当最后一个人不再使用时，共享内存再被释放
int Singleton::s_count = 0;

int main(void) {
    //Singleton s(123);
    //Singleton* ps = new Singleton(123);
    cout << "main开始运行" << endl;
    //++s_count:1,new
    Singleton& s1 = Singleton::getInstance();
    //++s_count:2
    Singleton& s2 = Singleton::getInstance();
    //++s_count:3
    Singleton& s3 = Singleton::getInstance();
    s1.print();
    s1.release();//--s_count:2

    s2.print();
    s3.print();
    cout << "&s1=" << &s1 << endl;
    cout << "&s2=" << &s2 << endl;
    cout << "&s3=" << &s3 << endl;
    s2.release();//--s_count:1
    s3.release();//--s_count:0,delete

    //程序运行保证第一次调取getInstance()时创建单例对象，最后一次调取release()时销毁单例对象。

    return 0;
}

eg.（多线程示例）

//如果报错无法打开源文件pthread.h
//解决办法：https://blog.csdn.net/qq_37058219/article/details/83382690
#include <iostream>
#include <pthread.h>
using namespace std;
//单例模式:懒汉式
class Singleton{
public:
    //3)使用静态成员函数获取单例对象
    static Singleton& getInstance(void){
        //一个线程中加锁成功后，必须等它解锁了，其他的线程才能访问
        pthread_mutex_lock(&mutex);//加锁
        if(s_instance == NULL){
            s_instance = new Singleton(123);
        }
        ++s_count;//s_count = s_count + 1
        pthread_mutex_unlock(&mutex);//解锁
        return *s_instance;
    }
    //单例对象不用即销毁,销毁时机?
    //所有的使用者都不再使用,才能销毁
    void release(void){
        pthread_mutex_lock(&mutex);//加锁
        if(--s_count == 0){
            delete s_instance;
            s_instance = NULL;
        }
        pthread_mutex_unlock(&mutex);//解锁
    }
    void print(void) const{
        cout << m_data << endl;
    }
private:
    //1)私有化构造函数
    Singleton(int data):m_data(data){
        cout << "单例对象被创建了" << endl;
    }
    //将缺省的拷贝构造函数声明为私有
    Singleton(const Singleton&);
    //析构函数
    ~Singleton(void){
        cout << "单例对象被销毁了" << endl;
    }

    //2)使用静态成员变量来维护唯一的对象
    static Singleton* s_instance;//声明
    //计数:记录单例对象使用者的个数
    static int s_count;
    //互斥锁（实现多线程之间的互斥访问）
    static pthread_mutex_t mutex;
private:
    int m_data;
};
Singleton* Singleton::s_instance = NULL;
int Singleton::s_count = 0;
//定义和初始化互斥锁
pthread_mutex_t Singleton::mutex 
    = PTHREAD_MUTEX_INITIALIZER;


int main(void){
    //Singleton s(123);
    //Singleton* ps = new Singleton(123);
    cout << "main开始运行" << endl;
    //++s_count:1,new
    Singleton& s1 = Singleton::getInstance();
    //++s_count:2
    Singleton& s2 = Singleton::getInstance();
    //++s_count:3
    Singleton& s3 = Singleton::getInstance();
    s1.print();
    s1.release();//--s_count:2

    s2.print();
    s3.print();
    cout << "&s1=" << &s1 << endl;
    cout << "&s2=" << &s2 << endl;
    cout << "&s3=" << &s3 << endl;
    s2.release();//--s_count:1
    s3.release();//--s_count:0,delete

    return 0;
}

十九.成员指针（了解）

1.成员变量指针

①定义

类型 类名::*成员指针变量名 = &类名::成员变量;

②使用

对象.*成员指针变量名;
注：".*"被称为直接成员指针解引用操作符

对象指针->*成员指针变量名;
注："->*"被称为间接成员指针解引用操作符

eg.

#include <iostream>
#include <cstdio>
using namespace std;
class Student{
public:
    Student(const string& name):m_name(name){}
    int m_age;
    string m_name;
};
int main(void){
    //成员变量指针
    string Student::*pname = &Student::m_name;
    Student s("张飞");
    Student* ps = new Student("赵云");
    cout << s.*pname << endl;
    cout << ps->*pname << endl;
   
    //成员变量地址=对象地址+成员变量指针相对地址
    printf("pname=%p\n",pname);
    printf("&s=%p\n",&s);
    printf("&s.m_name=%p\n",&s.m_name);

    return 0;
}

2.成员函数指针

①定义

   返回类型 (类名::*成员函数指针)(参数表)=&类名::成员函数;

②使用

(对象.*成员函数指针)(实参表);
(对象指针->*成员函数指针)(实参表);

eg.

#include <iostream>
using namespace std;
class A{
public:
    void func1(void){
        cout << "A::func1" << endl;
    }
    void func2(void){
        cout << "A::func2" << endl;
    }
};
int main(void){
    void (A::*pfunc)(void) = &A::func1;
    A a; //栈对象
    A* pa = new A; //堆对象
    (a.*pfunc)();
    (pa->*pfunc)();

    //该语法的指针是可以修改指向的
    pfunc = &A::func2;
    (a.*pfunc)();
    (pa->*pfunc)();

    return 0;
}

二十.操作符重载(operator)

1.基本概念

操作符重载就是一些具有特殊名称的函数，“operator操作符”，把已存在操作进行重新定义，针对自定义的类类型对象，完成自定义的运算功能。

eg.
int a=10,b=20;
a+b;
---------------
Integer a(10);
Integer b(20);
a+b; //operator+

eg.复数(x+yi)
1+2i + 3+4i = 4+6i

eg.

#include <iostream>
using namespace std;
class Complex{
public:
    Complex(int r,int i):m_r(r),m_i(i){}
    void print(void) const {
        cout << m_r << "+" << m_i << 'i' << endl;
    }
    //c1+c2 ==> c1.operator+(c2)
    const Complex operator+(
            const Complex& c) const {
        Complex res(m_r+c.m_r,m_i+c.m_i); //构造一个返回结果的实例对象
        return res;
    }
private:
    int m_r;//实部
    int m_i;//虚部
};
int main(void){
    Complex c1(1,2);
    Complex c2(3,4);
    c1.print();
    c2.print();
    //Complex c3 = c1.operator+(c2)
    Complex c3 = c1 + c2;
    c3.print();//4+6i
    return 0;
}

//a=b ==> a.operator=(b)
//a+b ==> a.operator+(b)
boss-dog
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++学习笔记本
05-14
C++学习笔记C++学习笔记C++学习笔记C++学习笔记C++学习笔记
C++学习的总结（类和对象）
qq_49884358的博客
10-29 485
本文主要记录了我在 “黑马程序员” 上自学C++的学习笔记 为了总结我自己的笔记，开始写我自己的博客，目的仅仅是为了能够在任何地方能够随时随地登录我的账号来查看我的学习笔记，温故知新，也同时希望我的笔记能够帮助一些想要学习C++的小伙伴们。
【C++编程语言】之类和对象---对象初始化和清除
kaszxc的博客
09-03 1050
​ C++利用了构造函数和析构函数解决上述问题，这个函数将会被编译器自动调用，完成对象初始化和清除工作。: 当对象p2释放内存是会把堆区的内存也一起释放，但是当轮到对象p1是否内存是，堆区的内存已经释放了，以此造成错误。​ 1.如果用户定义有参构造函数，c++不提供默认无参构造，但会提供默认拷贝构造。：主要作用于创建对象时为对象的成员属性赋值，构造函数有编译器自动调用，无需手动调用。​ 4.程序在调用对象时候会自动调用构造，无需手动调用，而且只调用一次。
14.C++之对象的初始化和清理
菜鸟要爱学习
06-11 307
C++之对象的初始化和清理
C++ 22.类与对象—对象特性—构造函数的分类及调用（拷贝构造函数调用时机、构造函数调用规则）
qq_41630696的博客
01-23 448
构造函数分类方式 按参数分为：有参构造和无参构造(默认构造) 按类型分为：普通构造和无参构造 构造函数三种调用方式 1.括号法 2.显示法 3.隐式转换法 #include <iostream> using namespace std; class Person { public: Person()//无参构造 { cout << "Person 无参构造函数的调用" << endl; } Person(int a)//有参构造 { ...
Java的对象传参问题
Anna的博客
08-04 4631
在c/c++中对于传参类型，无外乎就是传值、传引用、传指针这几种。但在java中，由于没有指针类型，其传参的方式也发生了相应的变化。之前有搜过相关的知识点一直理解的是：Java的传参方式中主要有两种：传值和传引用。（基本数据类型相当于传值，对象相当于传参）           但是，在做需求的时候遇到了，将从上一个方法中获取到的对象，当做参数传进下一个方法中的时候，如果传进来的是空对象，那么在给...
C++学习笔记.pdf
08-12
C++学习笔记
c++学习笔记.pdf
07-12
c++学习笔记.pdf
C++学习笔记
04-01
C++是C语言的继承，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行以继承和多态为特点的面向对象的程序设计。
C++之对象特性
qq_68066657的博客
08-16 391
大概白话理解，就是在创建对象参数的时候有些指针类型的属性创建在堆区，在有对象进行拷贝操作的时候，如果调用的时编译器自带的拷贝构造函数，就会导致两个对象的属性指向同一块内存空间，在析构释放时，拷贝对象（P2）会先释放掉指向的那块内存空间，被拷贝对象（p1)在析构释放时会要求再释放一遍，这就导致了同一块内存空间重复释放的问题，解决办法就是自己写一个拷贝构造函数，在自己写的拷贝构造函数里，把指针类型的属性数据重新开辟一块空间（深拷贝）。浅拷贝：简单的赋值拷贝操作，编译器提供的拷贝构造函数里提供的操作都是浅拷贝。.
【C++基础】笔记3——类与对象1
qq_44616566的博客
03-11 509
类与对象 C++面向对象的三大特性：封装，继承，多态 封装 意义：将属性和行为作为一个整体，表现生活中的事务 将属性和行为加以权限控制 语法：class 类名{ 访问权限: 属性/行为 }; const double PI = 3.14; //圆周率 class Circle { public: //属性 int m_r; //半径 //行为（用函数） double calZC() { //计算周长 return 2 * PI * m_r; } }; int main() {
【C++学习(5)】C++中对象作为参数传递给函数的三种情况(值传递，指针传递，引用传递)
最新发布
Hali_Botebie的博客
09-20 1144
实际参数 复制到 形式参数（对形式参数进行初始化）。与实际参数无关。因此在class 传递时，值传递方式，会调用 复制构造函数 进行新（临时）对象的初始化，不会修改原来的 class。
c++讲解成员对象作为函数参数传参的三种方式（主要是引用传递的讲解）
m0_53175693的博客
07-27 1535
拿类对象作为函数参数举例，三种形式如下： #include<iostream> using namespace std; class cube { public: void setM_h(int h) { M_h = h; } int getM_h() { return M_h; } void setM_k(int k) { M_k = k; } int getM_k() { return M_k; } void setM_l(int l)
c++类的对象作为方法参数（即函数参数）
热门推荐
yhblog的博客
09-12 2万+
c++类的对象作为参数传递时，有三种传递方式 #include <iostream> using namespace std; //求圆的面积 class Mycircle{ public: double r; double s; public: double getR(){ return r; } void setR(do...
5分钟掌握 Python 对象的引用
Python中文社区
12-24 1045
1. 引言引用在各种编程语言中都有涉及，如java中值传递和引用传递。python的对象引用也是学习python过程中需要特别关注的一个知识点，特别是对函数参数传递，可能会引起不必要的B...
C/C++字符串string操作的全面总结
C语言与CPP编程的博客
10-26 1万+
字符串操作看似简单，其实非常重要，不注意的话，经常出现代码运行结果和自己想要的不一致，甚至崩溃。总结一下构建string对象方法、修改string对象的方法、string类型的操作函数、string类型的查找、string对象的比较。 首先，为了在我们的程序中使用string类型，我们必须包含头文件 。如下： #include 1.构建string对象方法 声明一个字符串变量很简单： string Str; 这样我们就声明了一个字符串变量，但既然是一个类，就有构造函数和析构函数。上面的声明没有传入参数，所
数组 指针与字符串
枫闲言的博客
07-29 468
有些部分在C程序设计有总结。点击进入C程序语言设计栏 数组：具有一定顺序关系的若干相同类型变量的集合体，组成数组的变量称为该数组的元素。 数组的声明： 数据类型 数组名[常量表达式1] [常量表达式2]… 例如：int a[10];  表示 a 为整型数组，有10个元素：a[0]...a[9] 对象数组：数组的元素不仅可以是基本数据类型，也可以是自定义类型。对象
C++学习（数组、指针与字符串）
qq_37988883的博客
11-18 294
指针 指针的赋值 • 指针变量的初始化 ▫ 语法形式 存储类型数据类型*指针名＝初始地址； 例：int *pa = &a; • 注意事项 ▫ 用变量地址作为初值时，该变量必须在指针初始化之前已声明过，且变量类型应与指针类型一致。 ▫ 可以用一个已赋初值的指针去初始化另一个指针变量。 指针变量的赋值运算 指针名= 地址 ▫ “地址”中存放的数据类型与指针类型必须相符。 ▫ 向指针变量赋的值...
C++类的对象作为函数参数和返回值的传递方式
qq_41791653的博客
09-03 1万+
一、普通数据作为函数参数的和返回值的传递方式： 作为函数参数（形参结合）： 主调函数调用被调函数时，主调函数已经被压入了运行栈中，首先将要传递的参数压入运行栈的一段特殊区域中（这段内存，主调函数和被调函数都可以访问到），再将被调函数压入运行栈中（被调函数的形参此时才具有内存，且在此时将主调函数的实参赋值给形参）完成了形参结合。 作为函数返回值： 主调函数调用被调函数时，被调函数运行结束，返...
零基础c++学习笔记pdf
05-16
《零基础C语言学习笔记》pdf是一份非常好的学习材料。该pdf对C语言进行了系统的介绍，并且从最基础的内容开始进行讲解，适合于零基础的初学者学习。尤其是对于那些没有编程经验的人，该pdf提供了很多实用的示例和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

boss-dog

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值