C++核心语法

最新推荐文章于 2024-06-12 20:44:27 发布
最新推荐文章于 2024-06-12 20:44:27 发布
阅读量271 收藏 10
点赞数 5
文章标签： c++ 开发语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_20066069/article/details/135383581
版权

一、函数重载和默认参数

#include<stdio.h>
#include<iostream.h>
void func(int a=0,int b){//
	printf("%d %d",a,b);
}
void func(string a,string b){
	printf("%s %s",a,b);
}
//函数重载：函数名相同，但是函数参数以及返回类型有一个不同就可以发生函数重载
int main(){
	func(1,2);
	func("123","abc");
}

二、 内存空间管理（new,delete）

int main(){
	int *p=new int;//申请一个int型空间
	delete p;
	char *p=new char[10];//申请10个char空间
	delete [] p;
]

三、类和对象

类的申明

class A{
public:
	A(){//构造函数
		a=100;
	}
	A(int data):a(data){
	
	};
	~A(){//析构函数
		
	}
	void func(void);
private:
	int a;
protect:
}
//类外申明函数
void A::func(void){
	printf("%d",a);
}

浅拷贝和深拷贝

浅拷贝：单纯的文本赋值，默认构造函数就是浅拷贝
深拷贝：在堆区创建新的内存空间，再把数据赋值（主要是类中有指针数据时需要注意）、

#include<iostream>
#include<string>
using namespace std;

class persion{
public:
   persion(){};

   persion(int age,int height){
    this->age=age;
    *m_height=height;
   }

   persion(const persion &p){
    age=p.age;
    m_height=new int(*p.m_height);
   }

  ~persion(){
    if (m_height!=NULL)
    {
     delete m_height;
     m_height=NULL;
    }
    
  };
private:
    string name;
    int age;
    string number;
    int* m_height;
    
};

void test(){
    persion p1(10,160);
    persion p2(p1);//如果采用浅拷贝的方式，
                //那么在调用结束时会对m_height所指的内存空间进行重复的释放，从而报错、
                //因此采用深拷贝方式，让p2这个对象中的m_height指向新的内存空间就不会出现上述问题，所以需要对拷贝函数重写
};

int main()
{
    test();

}

静态成员

#include<iostream>
#include<string>
using namespace std;

class persion {
public:
    /*
      静态成员变量;
      1.静态成员变量在类内申明，类外初始化（出了类定义就是类外）
      2.所有对象共享同一个静态成员变量
      3.静态成员变量也拥有访问权限
    */
    static int age;
    int number;

    /*
    静态成员函数：
    1.所有对象共享同一个静态成员函数
    2.静态成员函数只能调用静态成员变量，不能调用非静态变量
    3.静态成员函数业也有访问权限
    */
    static void fun() {
        m_height = 100;
        //number=10;因为静态成员函数是共享的，所以无法区分是哪一个对象调用非静态成员
    }
private:
    static int m_height;

};

int persion::age = 100;
int persion::m_height = 200;

void test() {
    persion p1;
    persion p2;
    
    /*
    p1.m_height p2.m_height这样是无法访问的(静态成员也有访问权限问题)
    */
    p1.age = p2.age = 100;
    p1.fun();
    //静态成员变量还可以通过类名访问
    int a = persion::age;
    persion::fun();

};

int main()
{
    test();

}

常成员

#include<iostream>
#include<stdio.h>


class A {
public:
	A(int data) :b(data) {//常成员赋值
	
	}
	void func(void)const {
		printf("%d", b);
		//a = 100;常函数不能修改成员的值
	}

private:
	const int b;
	int a;
};

友元

1.全局函数做友元
2.类做友元
3.成员函数做友元
成为友元后可以访问私有权限的数据

#include<iostream>
#include<string>
using namespace std;

class Buliding {
    friend void visit(Buliding& buliding);//全局函数做友元
    friend void GoodGay::gvisit();//成员函数做友元
    //friend class GoodGay;//类做友元
public:
    Buliding();
public:
    string m_SittingRoom;

private:
    string m_BedRoom;
};
Buliding::Buliding() {//构造函数在类外定义
    m_SittingRoom = "客厅";
    m_BedRoom = "卧室";
};


class GoodGay {
public:
    GoodGay();
    void gvisit();

    Buliding* buliding;

};

GoodGay::GoodGay() {
    buliding = new Buliding;

}
void GoodGay::gvisit() {
    cout << buliding->m_SittingRoom << endl;
    cout << buliding->m_BedRoom << endl;
}



void visit(Buliding& buliding) {//全局函数
    cout << buliding.m_SittingRoom << endl;
    cout << buliding.m_BedRoom << endl;
}

int main()
{
    Buliding bulid;
    visit(bulid);
	GoodGay gg;
	gg.gvisit();
}

四、运算符重载

1.加号运算符重载

#include<iostream>
#include<string>
using namespace std;
class persion{
public:
  persion(){
    m_a=10;
    m_b=20;
  }
  //1.成员函数实现运算符重载
  // persion operator+(persion &p){     
  //   persion temp;
  //   temp.m_a+=p.m_a;
  //   temp.m_b+=p.m_b;
  //   return temp;
  // }

  /*
   persion persionADDpersion(persion &p){运算符重载的实质就是成员函数名的更换
    persion temp;
    temp.m_a+=p.m_a;
    temp.m_b+=p.m_b;
    return temp;
  }
  */

  int m_a;
  int m_b;
};

// 2.全局函数的运算符重载
persion operator+(persion p1,persion p2){
  persion temp;
  temp.m_a=p1.m_a+p2.m_a;
  temp.m_b=p1.m_b+p2.m_b;
  return temp;
}

persion operator+(persion p1,int num){
  persion temp;
  temp.m_a=p1.m_a+num;
  temp.m_b=p1.m_b+num;
  return temp;
}

int main()
{
  persion p1;
  persion p2;
  persion p3=p1+p2;

  //成员函数实现运算符重载的实质
  //persion p3=p1.operator+(p2);

  //全局函数实现运算符重载的实质
  //persion p3=operator+(p1,p2);

  //运算符重载实质就是函数，因此可以发生函数重载
  persion p4=p1+100;

}

2.左移运算符重载

#include<iostream>
#include<string>
using namespace std;
class persion{
  friend ostream& operator<<(ostream& cout,persion &p1);//采用友元的方式访问私有权限数据
public:
  persion(){
    m_a=10;
    m_b=20;
  }

private:
  int m_a;
  int m_b;
};
//只能利用全局函数实现左移运算符的重载
ostream& operator<<(ostream& cout,persion &p1){//由于ostream这个类对象只能有一个，
                                                //不能创建一个新的对象，因此全部采用引用的方式来进行传递
      cout<<p1.m_a<<" "<<p1.m_b;
      return cout;
}

int main()
{
  persion p1;
  cout<<p1<<endl;

}

3递增运算符重载

#include<iostream>
using namespace std;


class MyInteger{
	friend ostream& operator<<(ostream& cout, MyInteger myinteger);
public:
	MyInteger() {
		m_a = 0;
	}
	//前置运算符重载
	MyInteger& operator++() {
		m_a++;
		return *this;
	}

	//后置运算符重载
	MyInteger operator++(int) {//利用int占位符来区分前置和后置，而且只能用int来区分
		
		//先存储之前的结果
		MyInteger temp;
		temp = *this;//*this就是其本身
		//++
		m_a++;
		//返回之前的结果
		return temp;
	}

private:
	int m_a;	
};

ostream& operator<<(ostream& cout, MyInteger myinteger) {
	cout << myinteger.m_a;
	return cout;
}

int main() {
	MyInteger a;
	
	cout << a << endl;
	cout << ++a << endl;
	cout << a++ << endl;
	cout << a << endl;


}

4赋值运算符重载（深拷贝，浅拷贝问题）

#include<iostream>
using namespace std;

class persion {

public:
	persion(int age) {
		m_age = new int(age);
	}

	~persion() {
		delete m_age;
	}
	persion& operator=(persion& p){//返回值为persion&，实现程序可以连=操作，
		//先判断是否有数据开辟在堆空间
		if (m_age != NULL) {
			delete m_age;
		}
		m_age = new int(*p.m_age);
		return *this;
	}
	int* m_age;
};


int main() {
	persion p1(10);
	persion p2(20);
	persion p3(30);



	p3=p2 = p1;
	cout << *p1.m_age << endl;
	cout << *p2.m_age << endl;
	cout << *p3.m_age << endl;


}

关系运算符重载和上述差不多

5函数调用重载（仿函数）

#include<iostream>
using namespace std;

class myprintf {
public:
	void operator()(string str) {
		cout << str << endl;
	}
};
class myadd {
public:
	int operator()(int num1,int num2) {
		return num1 + num2;
	}
};


int main() {
	myadd madd;
	cout << madd(10, 20) << endl;//仿函数和普通函数调用差不多，仿函数就是对‘=’赋值运算符的重载

	cout << myadd()(30, 40) << endl;//匿名函数调用，匿名函数对象创建（使用完一次就释放内存，对象不存在）


}

五、组合和继承

组合：将其他类作为自己的数据成员，调用其接口，但是无法添加新的功能
继承：public继承，继承其他类的成员和属性，可以根据成员添加新的功能，也就是创建更加高级的功能。

#include "arr.h"
#include <iostream>

using namespace std;

class ARRX:public ARR{//继承
public:
	int ever(void)//添加求平均功能
	{
		int i = 0;
		int sum = 0;
		for(;i<tail; i++)
			sum += data[i]; 
		return sum/tail;
	}
};

class Stuma{
public:
	Stuma(){

	}
	~Stuma() { }
	
	void savescore(int score)
	{
		scorearr.addtail(score);
	}
	
	int everscore(void)//组合调用新添加求平均功能
	{
		return scorearr.ever();
	}

	void showscore(void)
	{
		scorearr.show();
	}

private:
	//ARR scorearr;
	ARRX scorearr;//组合
};

int main()
{
	Stuma mmm;

	mmm.savescore(23);
	mmm.savescore(44);
	mmm.savescore(55);
	mmm.savescore(23);

	mmm.showscore();
	cout << mmm.everscore() <<endl;
}

六、多态

虚函数（virtual）

#include<string>
#include<stdio.h>
#include <iostream>
using namespace std;

class A {
public:
	virtual~A() { cout << "A--------" << endl; }
	virtual void show() {//虚函数
		cout << "aaaaaa" << endl;
	}
private:
	int x;
	int y;

};
class AX :public A {
public:
	virtual ~AX() { cout << "AX-----" << endl; }
	void show() {
		cout << "AAAAAAA" << endl;
	}
};


int main() {

	AX a;
	/*c++允许基类指针指向派生类对象*/
	A* p = &a;
	p->show();//没有虚函数请款结果为"aaaaaa",根据指针类型确定。添加虚函数的情况下，结果为："AAAAAAA"
				//派生类同名函数对基类函数进行了一个完全覆盖
	AX* q = &a;
	q->show(); //没有虚函数请款结果为"AAAAAAA"

	/*虚析构函数*/
	A* x = new AX;
	delete x;		//因为x是A基类指针，因此在释放内存时会导致只调用基类的析构函数，那么派生类的析构没有调用，造成内存的泄露
					//因此在编程当中，养成基类的虚构函数变成纯虚构函数，这样派生类的虚构函数也会调用

}

多态应用（联合动态编程）

编写一个类，可以求多种图形的周长

#include<string>
#include<stdio.h>
#include <iostream>
using namespace std;

class shape {

public:
	virtual double getC(void) {
		return 0;
	}

};
class Cir :public shape {
public:
	Cir(double r) :ri(r) {}
	double getC(void) {
		return 2 * 3.14 * ri;
	}

private:
	double ri;

};
class Tir :public shape {
public:
	Tir(double a, double b, double c) :e1(a), e2(b), e3(c) {}
	double getC(void) {
		return e1 + e2 + e3;
	}


private:
	double e1;
	double e2;
	double e3;

};
class Sqr :public shape {
public:
	Sqr(double e) {
		this->e = e;
	}
	double getC(void) {
		return 4 * e;
	}

private:
	double e;
};
/*构造一个函数实现不同类型的图形周长的计算，并返回总周长*/
double countC(shape* arry[], int num) {
	double sumC;
	for (int i = 0; i < num; i++)
	{
		sumC += arry[i]->getC();
	}
	return sumC;

}

int main() {

	Cir cir(2);
	Tir tir(3, 4, 5);
	Sqr sqr(6);
	//多态的一种应用，基类构建同名函数，便于统一管理和拓展
	shape* arry[] = { &cir,&tir,&sqr };
	cout << countC(arry, 3);

}

七、异常

异常机制

#include<string>
#include<stdio.h>
#include <iostream>
#include<stdlib.h>
#include<exception>
using namespace std;

//异常，类似c语言goto，如果执行出错进行跳转执行
class argexpect :public exception {//继承c++标准的异常处理类
public:
	const char* what() const throw(){
		return "arg err!";
	}


};

int myatoi(const char* str) {
	if (*str < '0' || *str>'9')
		throw argexpect();
	return atoi(str);

}

int main() {
	try {//无异常执行
		int data = myatoi("abcc");
		cout << data;
	}
	catch (argexpect& e) {//出现异常，捕捉异常消息-消息类型 实例
		cout << e.what();
	}
	

}

强制类型转换

#include<string>
#include<stdio.h>
#include <iostream>
#include<stdlib.h>
#include<exception>
using namespace std;

/*
强制类型转换：四种方式
reinterpret_cast
const_cast
static_cast
dynamic_cast
*/

class A {
public:
	virtual void show() {
		cout << "AAAAAAAA" << endl;
	}

};
class B :public A {
public:
	void show() {
		cout << "BBBBBBB" << endl;
	}


};
int main(void) {
#if 0
	int a;
	char* p = reinterpret_cast<char*>(&a);
	//强制转换为char*类型，但是会有内存泄露的风险
#endif

#if 0
	const int a = 1000;
	int* p = const_cast<int*>(&a);
	//用于const之间的强制转换，也会存在内存泄露风险

#endif // 0

#if 0
	A a;
	B &p = static_cast<B&>(a);
	//用于继承之间的强制转换，但是派生类指向基类会有风险

#endif // 0
#if 1
	try
	{
		A a;
		B& p = dynamic_cast<B&>(a);
		//动态强转提供检测机制，判断强转是否出现异常，使用这个强转类中必须要有虚函数
	}
	catch (const std::exception& e)
	{
		cout << e.what();
	}

#endif // 1




}

自定义转换

#include<string>
#include<stdio.h>
#include <iostream>
#include<stdlib.h>
#include<exception>
using namespace std;

/*自定义转换函数*/
class mytime {
public:
	mytime(int a, int b, int c) :hour(a),min(b),sec(c){}

	operator int() {//强制将时间转化为秒数
		return sec + min * 60 + hour * 60 * 60;
	}
private:
	int hour;
	int min;
	int sec;



};
int main() {
	mytime t(1,2,3);
	int sec = int(t);
	cout << sec;

}

八、模版

函数模版

#include<string>
#include<stdio.h>
#include <iostream>
#include<stdlib.h>
#include<exception>
using namespace std;

//函数模版

template<typename T>
void myswap(T& a, T& b) {
	T temp=a;
	a = b;
	b = temp;
	cout << a << " " << b << endl;
}
void test(void) {
	int a = 10, b = 20;
	//1.自动推导类型
	myswap(a, b);
	//2.显示声明类型
	myswap<int>(a, b);
}
int main() {
	
	
	test();

}

函数模版实现选择排序

#include<string>
#include<stdio.h>
#include <iostream>
#include<stdlib.h>
#include<exception>
using namespace std;


template<class T>
void myswap(T& a, T& b) {
	T temp=a;
	a = b;
	b = temp;

}
//函数模版实现选择排序
template<class T>
void mysort(T a[], int len) {
	
	for (int i = 0; i < len; i++)
	{
		int max = i;
		for (int j = i+1; j < len ; j++) {
			if (a[max] < a[j])max = j;
		}
		if (max != i) {
			myswap(a[i], a[max]);
		}
	}
	for (int i = 0; i < len; i++)
	{
		cout << a[i] << " ";
	}
}

void test(void) {
	int arry[] = { 1,4,5,2,6,12,74,8,9,34 };
	int num = sizeof(arry)/sizeof(int);
	mysort(arry, num);
}
int main() {
	
	
	test();

}

notes:
1、普通函数能欧实现隐式类型转换
2.、函数模版 自动类型推导无法实现隐式类型转换
3、函数模版 显式申明可以实现隐式类型转换（建议使用这种）
4.普通函数和函数模版都可以调用时，优先调用普通函数
5.空模版参数列表可以强制调用函数模版
6.函数模版也可以发生函数重载
7.如果函数模版产生更好的匹配，则调用函数模版

函数模版局限

#include<string>
#include<stdio.h>
#include <iostream>
#include<stdlib.h>
#include<exception>
using namespace std;
//函数模版的局限，对于特殊的数据结构无法处理
class persion {
public:
	persion(string name, int age) {
		this->name = name;
		this->age = age;
	}

	string name;
	int age;

};
template<class T>
bool myjudge(T& a, T& b) {
	if (a == b) return true;
	else return false;
}
//对于特殊数据结构进行具体实现
template<>bool myjudge(persion& a, persion& b) {
	if (a.name == b.name && a.age == b.age)return true;
	else return false;

}

void test(void) {
	persion p1("zhangsan", 10);
	persion p2("lisi", 25);
	cout<<myjudge(p1, p2);

}
int main() {
	
	test();


}

notes:学习使用别人封装好的模版才是重点

类模版

#include<string>
#include<stdio.h>
#include <iostream>
#include<stdlib.h>
#include<exception>
using namespace std;
//函数模版的局限，对于特殊的数据结构无法处理
template<class NameType,class AgeType=int>
class persion {
public:
	persion(NameType name, AgeType age) {
		this->name = name;
		this->age = age;
	}
	void show(void) {
		cout << name << " " << age << endl;
	}
	NameType name;
	AgeType age;


};



void test(void) {
	persion<string>p1("zhangsan", 112);//类模版只能是显式申明调用，而不能像函数模版一样采用自动推导
	
}
int main() {
	
	test();


}

类模版中的成员函数只有在调用阶段才创建

类模版对象做函数参数

#include<string>
#include<stdio.h>
#include <iostream>
#include<stdlib.h>
#include<exception>
using namespace std;
//函数模版的局限，对于特殊的数据结构无法处理
template<class NameType,class AgeType>
class persion {
public:
	persion(NameType name, AgeType age) {
		this->name = name;
		this->age = age;
	}
	void show(void) {
		cout << name << " " << age << endl;
	}
	NameType name;
	AgeType age;


};

//指定传入类型（一般采用这种方式）
void printPersion(persion<string, int>& p) {
	p.show();
}
void test1(void) {
	persion<string,int>p1("zhangsan", 112);//类模版只能是显式申明调用，而不能像函数模版一样采用自动推导
	printPersion(p1);
}
//参数模版化
template<class T1,class T2>
void printPersion1(persion<T1, T2>& p) {
	p.show();
	cout << "T1 type" << typeid(T1).name << endl;
}
void test2(void) {
	persion<string, int>p("lisi", 67);
	printPersion1(p);
}
//整个类模版化
template<class T>
void printPersion3(T& p) {
	p.show();
	cout << "T type:" << typeid(T).name << endl;
}
void test3(void) {
	persion<string, int>p("wanger", 98);
	printPersion3(p);
}

int main() {
	
	test1();
	test2();
	test3();


}

类模版与继承

#include<string>
#include<stdio.h>
#include <iostream>
#include<stdlib.h>
#include<exception>
using namespace std;


/*类模版与继承：子类继承父类必须要指明父类的模版参数类型*/

template<class T>
class Base {
public:
	T m;
};

class Son :public Base<int> {//必须指明父类T的类型


};
//如果想要灵活指定父类T的类型，子类也需要是变类模版
template<class T1,class T2>
class Son2 :public Base<T1> {
public:
	Son2() {
		cout << "T1  type:" << typeid(T1).name() << endl;
		cout << "T2  type:" << typeid(T2).name() << endl;

	}
	T2 x;
};

void test(void) {
	Son2<string, int>s;

}
int main() {
	test();


}

类模版成员函数类外实现

#include<string>
#include<stdio.h>
#include <iostream>
#include<stdlib.h>
#include<exception>
using namespace std;


/*类模版与继承：子类继承父类必须要指明父类的模版参数类型*/
template<class T1,class T2>
class persion {
public:
	persion(T1 name, T2 age);
	void show();

	T1 m_name;
	T2 m_age;

};


template <class T1,class T2>
persion<T1,T2>::persion(T1 name, T2 age) {
	this->m_age = age;
	this->m_name = name;
}


template<class T1,class T2>
void persion<T1, T2>::show(void) {
	cout << "name:" << this->m_name << "age:" << this->m_age << endl;
}



void test(void) {
	persion<string, int>p("zhansgan", 45);

}
int main() {
	test();


}

类模版分文件编写

#include<string>
#include<stdio.h>
#include <iostream>
#include<stdlib.h>
#include<exception>
using namespace std;

#include"persion.hpp"//类模版分文件编写解决：将.h和.cpp的文件写到一个文件，并以.hpp后缀命名


//template<class T1,class T2>
//class persion {
//public:
//	persion(T1 name, T2 age);
//	void show();
//
//	T1 m_name;
//	T2 m_age;
//
//};
//
//
//template <class T1,class T2>
//persion<T1,T2>::persion(T1 name, T2 age) {
//	this->m_age = age;
//	this->m_name = name;
//}
//
//
//template<class T1,class T2>
//void persion<T1, T2>::show(void) {
//	cout << "name:" << this->m_name << "age:" << this->m_age << endl;
//}



void test(void) {
	persion<string, int>p("zhansgan", 45);

}
int main() {
	test();


}

类模版与友元（全局函数类外实现）

#include<string>
#include<stdio.h>
#include <iostream>
#include<stdlib.h>
#include<exception>
using namespace std;

//全局函数类外实现
//首先让编译器知道有个类模版
template<class t1,class t2>
class persion;

//第二，编译器知道全局函数的实现
template<class t1,class t2>
void printPersion2(persion<t1, t2>p) {
	cout << p.m_name<<" "<<p.m_age;
}




template<class t1,class t2>
class persion {

	friend void printPersion1(persion<t1, t2>p) {//全局函数类内实现
		cout << "name:"<<p.m_name << "age:"<<p.m_age;
	}
	friend void printPersion2<>(persion<t1, t2>p);//注意这里需要添加模版空列表参数
public:
	persion(t1 name, t2 age) {
		this->m_age = age;
		this->m_name = name;
	}
private:
	t1 m_name;
	t2 m_age;

};



void test(void) {
	persion<string, int>p("zhansgan", 45);
	//printPersion1(p);
	printPersion2(p);
}
int main() {
	test();


}

九、STL标准模版库

容器 算法 迭代器

预备知识

#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;

void printfNum(int val) {

	cout << val << " ";
}

int main() {

	vector<int>num;
	for (int i = 0; i < 10; i++)
	{
		num.push_back(i);
	}

	for (vector<int>::iterator it = num.begin(); it < num.end(); it++)//*it就代表<>中的内容，这里*it代表int
	{
		cout << *it << " ";
	}
	cout << endl;

	for_each(num.begin(), num.end(), printfNum);//利用算法遍历

	vector<vector<int>>nums;//容器嵌套
	for ( int i = 0;  i < 10;  i++)
	{
		nums.push_back({ i,i + 1,i + 2 });
	}

	for (vector<vector<int>>::iterator  it = nums.begin(); it <nums.end() ; it++)
	{

		for (vector<int>::iterator its = (*it).begin(); its < (*it).end(); its++)
		{
			cout << *its << " " ;
		}
		cout << endl;
	}
	

}

1.string

2.vector

互换容器->swap(vec)

3.deque

双端数组，可以对头端也可以对尾端进行插入和删除的操作

4.stack

5.queue

6.list

7.set

8.pari

9.set

10.map

十、常用算法

划水的fish
关注
  • 5
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++ 之基本结构语法
wei_hkkf5566的博客
06-10 3155
从语言的分类角度而言，C++是一种非常特殊的存在。属于高级语言范畴，但又具有低级语言的直接访问硬件的能力，这也成就了C++语言的另类性，因保留有其原始特性，其语法并不象其它高级语言一样易理解，但处理能力却比其它语言高很多。从语言的处理能力和速度而言，让人爱；从语法体系角度而言，对于学习者并不友好。但对于专业开发者，建议学好C++语言，C++的底层特性对于理解其它语言的高级封装原理有很大的帮助。本文将从一个简单的Hello world C++程序开始，以此程序中出现的基础知识为导入点，深入探讨这些知识的底层逻
c++入门语法及使用 - c++学习路线
.
11-21 2944
文章目录C++基础一、入门学习路线图二、基础语法2.1 基本数据类型2.2 运算符算数运算符赋值运算符比较运算符逻辑运算符三目运算符2.3 逻辑循环语句2.4 复合数据类型数组字符串2.5 指针/引用2.6 函数三、面向对象3.1 strust - 结构体3.2 union - 共用体3.3 enum - 枚举3.4 class - 类封装继承多态结束 C++基础 文章目录 《C++ Primer Plus》 一、入门学习路线图 大致是这样，我有的时候学了很多语言，一个语言
《黑马》——C++核心编程
漏网小鱼的博客
09-05 21万+
前言： ** 配套视频： https://www.bilibili.com/video/BV1et411b73Z?from=search&seid=16795623907667609637 只是为方便学习，不做其他用途，在此发布C++基础入门部分配套讲义，原作者为黑马程序 C++核心编程 本阶段主要针对C++面向对象编程技术做详细讲解，探讨C++中的核心和精髓。 1 内存分区模型 C++程序在执行时，将内存大方向划分为4个区域 代码区：存放函数体的二进制代码，由操作系统进行管理的 全局区：存放全局
C++核心编程(二)
Augenstern_QXL的博客
05-25 4万+
C++核心编程 0.写在前面 本篇笔记视频讲解地址：https://www.bilibili.com/video/BV1et411b73Z?p=1 笔记配合视频效果更好 外链图片上传失败已经解决，手动校正，如有错误和遗漏，可私信与评论进行指正，看到了会及时更改 与各位共勉 用来复习回顾使用 本阶段主要针对C++面向对象编程技术做详细讲解，探讨C++中的核心和精髓。 1 内存分区模型 C++程序在执行时，将内存大方向划分为4个区域 代码区：存放函数体的二进制代码，由操作系统进行管理的 全局区：存放全局变
C++ 学习（基础语法篇）
qq_44755885的博客
04-02 9835
C++学习之基础语法
17 C++11常用语法
精致的灰的博客
01-24 4153
文章目录一、C++11简介二、列表初始化2.1. 容器如何支持花括号初始化三、变量类型的推导3.1. 编译时类型推导：auto3.2. decltype类型推导3.3. 运行时类型推导 typeid四、final、override五、新增容器六、范围for循环七、默认成员函数控制defaultdelete八、右值引用8.1. 右值引用的移动语义8.2. 移动语义需要注意的问题8.3. 右值引用引用左值move的用法和注意事项8.4. 总结8.5. 完美转发 一、C++11简介 在2003年C++标准委员
C++17新语法及标准库
飞鹤的程序员人生
06-12 6638
在C++ 17中，引入了一个新的auto规则来改进直接列表初始化（direct-list-initialization）的行为。在此前，使用auto声明变量并对其进行直接列表初始化时，结果类型通常为std::initializer_list。这意味着该变量只能表示一个具有可复制语义的对象集合，并且很难用于处理其他类型的值。在上面的示例中，我们使用了新的auto规则来声明变量并对其进行直接列表初始化。在第一个示例中，由于列表只包含单个元素，因此结果类型为int。
黑马程序员讲义-C++核心编程
kangjielearning的博客
09-03 1万+
C++核心编程（黑马程序员讲义） 本阶段主要针对C++面向对象编程技术做详细讲解，探讨C++中的核心和精髓。 1 内存分区模型 C++程序在执行时，将内存大方向划分为4个区域 代码区：存放函数体的二进制代码，由操作系统进行管理的 全局区：存放全局变量和静态变量以及常量 栈区：由编译器自动分配释放, 存放函数的参数值,局部变量等 堆区：由程序员分配和释放,若程序员不释放,程序结束时由操作系统回收 内存四区意义： 不同区域存放的数据，赋予不同的生命周期, 给我们更大的灵活编程 1.1 程序运行前 ​ 在程序
C++教程(最全)
热门推荐
HeiRen
03-04 34万+
C++简介
C++核心——多态
wtzhu_13的博客
03-28 1425
C++核心——多态 多态的基本概念 多态是C++面向对象三大特性之一，是利用继承语法实现的一种编程思想，简称调父用子，调用父类的函数，实际调用的是子类的实现 多态分为两类 静态多态: 函数重载 和 运算符重载属于静态多态，复用函数名 动态多态: 派生类和虚函数实现运行时多态 静态多态和动态多态区别： 静态多态的函数地址早绑定 - 编译阶段确定函数地址 动态多态的函数地址晚绑定 - 运...
c++核心语法
06-22
从入门开始讲解到c++高级编程MFC界面编程...其次将C++核心操作语法和知识点，包括c++封装、继承、多态。然后讲C++的应用MFC界面编程，最后补充一点多线程知识。通过本课程学员可以从零基础跨越到非常熟练的C++程序员。
C++核心编程.md
11-21
C++核心编程.md、C++核心编程.md、C++核心编程.md 一提到这个名字相信有需要的小伙伴瞬间就能明白了，打开的话用typora这个软件，特别好，不认识名字的朋友也不要紧 这就是一个C++编程文档，很实用的，里边有一些C++...
C++核心编程.pdf
04-10
C++核心编程.pdf C++核心编程是面向对象编程技术的重要组成部分，本阶段主要针对C++面向对象编程技术做详细讲解，探讨C++中的核心和精髓。 1. 内存分区模型 C++程序在执行时，将内存大方向划分为4个区域：代码区...
C++核心指南教程解析
09-30
C++核心指南教程解析 本书是C++编程语言的核心指南教程，旨在帮助读者深入了解C++语言的核心概念和实践经验。下面是本书的知识点摘要： 1. C++语言的基本概念：C++是一种面向对象的编程语言，具有强大的编程能力和...
C++语言语法大全.docx
07-29
C++ 语言语法大全 C++ 语言是面向对象编程的高级语言，它是在 C 语言基础上增加了面向对象编程特性的。C++ 的核心特性是类（Class），类是用户定义的类型，可以用来指定对象的形式。类是封装了数据和函数的组合，类...
c++实现二叉搜索树（上）
最新发布
henjdx的博客
06-12 993
二叉搜索树1.树节点增加key属性，用来比较谁大谁小，key不可以重复2.对于任意一个节点，它的key比左子树的key都大，同时也比右子树的key都小善解人意的小吉猜很多小可爱们看到这些概念都很难一下子就理解了，接下来小吉画一张图，方便大家理解（比起上面👆的概念，小吉认为下面的图比较重要）注：标的数值都是键值最后，小吉来考考你们🧐，看看你们是否是真的了解了二叉搜索树，上图👆键值6的右子树的取值范围（>6&&
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 998
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
C++——计算不同的非空子串个数
我发布的博客，快来抄答案吧
06-09 143
BCSP-X 11题 C++代码详解
LeetCode 算法：轮转数组c++
小金牛来了
06-09 676
LeetCode 算法：轮转数组c++
黑马程序员c++核心编程
10-24
黑马程序员C++核心编程是一门针对C++语言的深入学习课程，主要包括C++基础语法、面向对象编程、模板、STL等内容。该课程通过理论讲解和实战演练相结合的方式，帮助学员深入理解C++语言的核心概念和编程思想，掌握C++...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值