bbs375的博客

1 new和delete基本语法1）在软件开发过程中，常常需要动态地分配和撤销内存空间，例如对动态链表中结点的插入与删除。在C语言中是利用库函数malloc和free来分配和撤销内存空间的。C++提供了简便而功能较强的运算符new和delete来取代malloc和free函数。注意： new和delete是运算符，不是函数，因此执行效率高。2）虽然为了与C语言兼容，C++仍保留ma

例子引出#include using namespace std;class Parent{public: Parent(int a = 0) { this->a = a; } virtual void print() { cout<<"Parent"<<endl; } protected:private: int a; };class Child

#include using namespace std;/*c++中的const为真正意义上的const ，由于符号表机制C++编译器对const常量的处理当碰见常量声明时，在符号表中放入常量 =问题：那有如何解释取地址编译过程中若发现使用常量则直接以符号表中的值替换编译过程中若发现对const使用了extern或者&操作符，则给对应的常量分配存储空间（兼容C）*/int m

#include using namespace std;void myFunc(int a){ printf("a:%d\n",a);}void myFunc(char *p){ printf("p:%s\n",p);}void myFunc(int a,int b){ printf("a:%d+b:%d\n",a,b);}//函数指针//声明一个函数类型(用这个

函数重载：必须在同一个类中进行子类无法重载父类的函数，父类同名函数将被名称覆盖重载是在编译期间根据参数类型和个数决定函数调用函数重写：必须发生于父类与子类之间并且父类与子类中的函数必须有完全相同的原型使用virtual声明之后能够产生多态(如果不使用virtual，那叫重定义)多态是在运行期间根据具体对象的类型决定函数调用。#include using na

虚析构函数的作用：#include using namespace std;class A{public: A() { p = new char[20]; strcpy(p,"abcd1234"); cout<<"A"<<endl; } ~A() { delete[] p; cout<<"~A"<<endl; }protected:private

#include using namespace std;class Parent{public: Parent(int a){ this->a = a; cout<<"Parent a:"<<a<<endl; } void print(){ cout<<"Parent 打印a:"<<a<<endl; }private: int a;};class Chil

原则：   先构造父类，再构造成员变量、最后构造自己  先析构自己，在析构成员变量、最后析构父类//先构造的对象，后释放案例：#include using namespace std;class Object{public: Object(int a,int b) { this->a = a; this->b = b; cout<<"Object"

1问题抛出指针使用过程中，经常会出现内存泄漏和内存多次被释放常2 解决方案：例如：boost库的智能指针项目开发中，要求开发者使用预先编写的智能指针类对象代替C语言中的原生指针3 智能指针思想工程中的智能指针是一个类模板通过构造函数接管申请的内存通过析构函数确保堆内存被及时释放通过重载指针运算符* 和-> 来模拟指针的行为通过重载比较运算符 == 和!=

企业信息系统框架集成第三方产品 案例背景：一般的企业信息系统都有成熟的框架。软件框架一般不发生变化，能自由的集成第三方厂商的产品。案例需求：请你在企业信息系统框架中集成第三方厂商的Socket通信产品和第三方厂商加密产品。                     1.第三方厂商的Socket通信产品：完成两点之间的通信；                     2.第三方厂商加密产

指针有两个属性:指向变量/对象的地址和长度但是指针只存储地址,长度则取决于指针的类型 编译器根据指针的类型从指针指向的地址向后寻址 指针类型不同则寻址范围也不同,比如: int*从指定地址向后寻找4字节作为变量的存储单元 double*从指定地址向后寻找8字节作为变量的存储单元 1.void指针是一种特别的指针    void *vp    //说它特别是因

Ø 从类模板实例化的每个模板类有自己的类模板数据成员，该模板类的所有对象共享一个static数据成员Ø  和非模板类的static数据成员一样，模板类的static数据成员也应该在文件范围定义和初始化Ø  每个模板类有自己的类模板的static数据成员副本#include using namespace std;templateclass AA{public

#include using namespace std;templateclass A{public: A(T a) { this->a = a; } void printA() { cout<<"a:"<<a<<endl; }protected:private: T a;};//模板派生是需要具体化模板类 c++编译器需要知道 父类的数据类型具体是什么

问：构造函数中调用虚函数能否实现多态？#include using namespace std;class Parent{public: Parent(int a = 0) { this->a = a; print(); } virtual void print() { cout<<"Parent1"<<endl; } virtual void print2

#include using namespace std;class ABCD{public: ABCD(int a, int b,int c) { this->a = a; this->b = b; this->c = c; printf("ABCD() construct,a:%d,b:%d,c:%d\n",this->a,this->b,this->c); }

1）对象初始化列表出现原因1.必须这样做：如果我们有一个类成员，它本身是一个类或者是一个结构，而且这个成员它只有一个带参数的构造函数，没有默认构造函数。这时要对这个类成员进行初始化，就必须调用这个类成员的带参数的构造函数，如果没有初始化列表，那么他将无法完成第一步，就会报错。 2、类成员中若有const修饰，必须在对象初始化的时候，给const int m赋值当类成员中含有一个

#include using namespace std;class Test{public: Test(const char*p) { this->len = strlen(p); name = (char*)malloc((len+1)*sizeof(char)); strcpy(name,p); } Test(const Test &obj)//解决浅拷贝问题

#include using namespace std;class Test{public: Test() { m_a = 0; m_b = 0; cout<<"无参构造函数"<<endl; } Test(int a)//3种方法 { m_a = a; m_b = 0; cout<<"1个参数有参构造函数"<<endl; } Test(int a,

#include using namespace std;class Test{public: Test() { m_a = 0; m_b = 0; cout<<"无参构造函数"<<endl; } ~Test() { cout<<"析构函数"<<endl; } Test(int a)//3种方法 { m_a = a; m_b = 0; cout

#pragma once#include using namespace std;class MyString{public: MyString(); MyString(int len); MyString(const char*p); MyString(const MyString& obj); ~MyString(void); void print(); int ge

#include using namespace std;class Name{public: Name(const char *myp) { m_len = strlen(myp); m_p =(char *)malloc(m_len+1); strcpy(m_p,myp); } Name(const Name& obj) { m_len = obj.m_le

#include using namespace std;void swap(int a ,int b){ int c=0; c = a; a = b; b = c;}void swap1(int*a ,int*b){ int c=0; c = *a; *a = *b; *b = c;}//引用作函数参数不需要初始化void swap2(int &a ,int

#include using namespace std;float temp; //定义全局变量tempfloat fn1(float r); float &fn2(float r); float fn1(float r) //定义函数fn{ temp = (float)r*r*3.14; return temp;}float &fn2(float r)//定义函数fn2

类型兼容规则是指在需要基类对象的任何地方，都可以使用公有派生类的对象来替代。通过公有继承，派生类得到了基类中除构造函数、析构函数之外的所有成员。这样，公有派生类实际就具备了基类的所有功能，凡是基类能解决的问题，公有派生类都可以解决。类型兼容规则中所指的替代包括以下情况：子类对象可以当作父类对象使用子类对象可以直接赋值给父类对象子类对象可以直接初始化父类对象父类指针可以直接指向子类对

#include using namespace std;class Test{public: Test(int a = 0,int b = 0) { this->a = a; this->b = b; } ~Test() { cout<<"析构函数"<<endl; } Test addTest1(Test &obj) { Test tmp(this->a

前言 C++对象模型可以概括为以下2部分：1. 语言中直接支持面向对象程序设计的部分，主要涉及如构造函数、析构函数、虚函数、继承（单继承、多继承、虚继承）、多态等等。2. 对于各种支持的底层实现机制。在c语言中，“数据”和“处理数据的操作（函数）”是分开来声明的，也就是说，语言本身并没有支持“数据和函数”之间的关联性。在c++中，通过抽象数据类型（abstract data t

定义静态成员变量 Ø 关键字 static 可以用于说明一个类的成员，     静态成员提供了一个同类对象的共享机制Ø  把一个类的成员说明为 static 时，这个类无论有多少个对象被创建，这些对象共  享这个 static 成员Ø  静态成员局部于类，它不是对象成员静态成员函数Ø  静态成员函数数冠以关键字staticØ  静态成员函数提供不依赖于类数据结构

#include #include "Array1.h"Array1::Array1(int length){ if (length<0) { this->mlength = 0; } this->mlength = length; this->mspace = new int[this->mlength];}Array1::Array1(const Array1& o

C++中的const常量类似于宏定义const int c = 5; ≈ #define c 5C++中的const常量与宏定义不同const常量是由编译器处理的，提供类型检查和作用域检查 宏定义由预处理器处理，单纯的文本替换#include using namespace std;void fun1(){ #define a 10 const int b = 2

理论知识：1）&&和||是C++中非常特殊的操作符 2）&&和||内置实现了短路规则 3）操作符重载是靠函数重载来完成的 4）操作数作为函数参数传递 5）C++的函数参数都会被求值，无法实现短路规则 测试案例：#include #include using namespace std;class Test{ int i;public: Test(i

#include using namespace std;class Complex{public: Complex() { } Complex(int a,int b) { this->m_a = a; this->m_b = b; } void printCom() { cout<<m_a<<"+"<<m_b<<"i"<<endl; } //成员函数

#include using namespace std;#define MYFUNC(a, b) ((a) < (b) ? (a) : (b)) inline int myfunc(int a, int b) { return a < b ? a : b;}int main(){ int a = 1; int b = 3; //int c = myfunc(++a,

#include using namespace std;struct Teacher { char name[64]; int age;};//在被调用函数 获取资源int getTeacher(Teacher**p){ Teacher *tmp =NULL; if (p == NULL) { return -1; } tmp = (Teacher*)mallo

a) 在C++中新增加了引用的概念b) 引用可以看作一个已定义变量的别名c) 引用的语法：Type& name = var; d)引用做函数参数那？（引用作为函数参数声明时不进行初始化）#include using namespace std;int main(){ int a = 10;//编译器分配4个字节内存空间 a为内存空间的别名 int &b = a;//b

1）C语言返回变量的值C++语言是返回变量本身C语言中的三目运算符返回的是变量值，不能作为左值使用C++中的三目运算符可直接返回变量本身，因此可以出现在程序的任何地方2）注意：三目运算符可能返回的值中如果有一个是常量值，则不能作为左值使用(a 3）C语言如何支持类似C++的特性呢？====>当左值的条件：要有内存空间；C++编译器帮助程序员取了一个地址而已思考：如何

#include using namespace std;/*若返回静态变量或全局变量可以成为其他引用的初始值即可作为右值使用，也可作为左值使用*/int getA(){ static int a =10 ; a ++ ; return a;}int* getA2(){ static int a =20 ; a++; return &a;}int& g

#include using namespace std;struct Teacher{    char name[64];    int age;};int operateTeacher(const Teacher* p){    //p->age=10;指针指向的内存空间不能被修改    return 0;}int operateTeac

#include using namespace std;struct Teacher{ char name[64]; int age;};void printTeacher(const Teacher &p){ //p.age =20;//编译不通过 由于正在通过常量对象访问age，因此无法对其进行修改 //常引用 让实参变量拥有只读属性 防止修改 printf("age