C++学习记录

最新推荐文章于 2022-06-18 19:10:49 发布
最新推荐文章于 2022-06-18 19:10:49 发布
阅读量546 收藏
点赞数 1
分类专栏： 学习笔记 C++(C plus plus) 文章标签： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liaoqix/article/details/48740635
版权


注意

C++中使用new创建delete销毁，而C中使用malloc创建free销毁。

C++类class{}后一定要加分号；。


用例

单文件写类

此工程仅由一个main.cpp文件组成。

main.cpp如下：

//main.cpp

#include <iostream>
#include <stdlib.h>

class People
{
public:
	People()
	{
	};
	~People()
	{
	}
	void sayHello()
	{
		std::cout << "Hello!" << std::endl;
	}
};

int main(int argc, const char* argv[])
{
	People *p = new People();
	p->sayHello();
	delete p;

	//system("pause");
	return 0;
}

按类分写

此工程由三个文件组成，分别是main.cpp, People.h, People.cpp。

main.cpp如下：

//main.cpp

#include <iostream>
#include <stdlib.h>
#include "People.h"

int main(int argc, const char* argv[])
{
	People *p = new People();
	p->sayHello();
	delete p;

	//system("pause");
	return 0;
}

People.h如下：

//People.h

#pragma once
class People
{
public:
	People();
	~People();
	void sayHello();
};

People.cpp如下：

//People.cpp

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

People::People()
{
}


People::~People()
{
}

void People::sayHello()
{
	std::cout << "Hello!" << std::endl;
}

使用命名空间

此工程由三个文件组成，分别是main.cpp, People.h, People.cpp。其中对于main.cpp列举了两种使用方法，两种方法选其一即可。

main.cpp使用方法一

//main.cpp
//方法一：不使用using namespace

#include <iostream>
#include <stdlib.h>
#include "People.h"

int main(int argc, const char* argv[])
{
	LQX::People *p = new LQX::People();
	p->sayHello();
	delete p;

	system("pause");
	return 0;
}

main.cpp使用方法二

//main.cpp
//方法二：使用using namespace

#include <iostream>
#include <stdlib.h>
#include "People.h"

using namespace LQX;

int main(int argc, const char* argv[])
{
	People *p = new People();
	p->sayHello();
	delete p;

	//system("pause");
	return 0;
}

People.h如下： 

//People.h

#pragma once

namespace LQX
{
	class People
	{
	public:
		People();
		~People();
		void sayHello();
	};
}

People.cpp如下：

//People.cpp

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

namespace LQX
{

	People::People()
	{
	}


	People::~People()
	{
	}

	void People::sayHello()
	{
		std::cout << "Hello!" << std::endl;
	}

}

类的继承

此工程由五个文件组成，分别是main.cpp, People.h, People.cpp, Man.h, Man.cpp。

main.cpp如下：

//main.cpp

#include <iostream>
#include <stdlib.h>
#include "Man.h"

int main(int argc, const char* argv[])
{
	Man *m = new Man();
	m->sayHello();
	delete m;

	//system("pause");
	return 0;
}
People.h如下： 

//People.h

#pragma once

class People
{
private:
	int age;
	int sex;

public:
	People();
	int getAge();
	int getSex();
	People(int age, int sex);
	void sayHello();
};

People.cpp如下：

//People.cpp

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

People::People()
{
	this->age = 10;
	this->sex = 1;
}

int People::getAge()
{
	return this->age;
}

int People::getSex()
{
	return this->sex;
}

People::People(int age, int sex)
{
	this->age = age;
	this->sex = sex;
}

void People::sayHello()
{
	std::cout << "Hello!" << std::endl;
}

Man.h如下：

//Man.h

#pragma once
#include "People.h"

class Man :
	public People
{
public:
	Man();
	~Man();
};

Man.cpp如下：

//Man.cpp

#include "Man.h"

Man::Man()
{
}


Man::~Man()
{
}

构造方法和析构方法

此工程由一个main.cpp文件组成，但分了三种情况演示。

情况一：使用new方法创建自动执行构造，只有使用delete才会执行析构。

main.cpp如下：

//main.cpp

#include <iostream>
#include <stdlib.h>

class Object
{
public:
	Object()
	{
		printf("Create Object\n");
	}
	~Object()
	{
		printf("Delete Object\n");
	}
};

int main(int argc, const char* argv[])
{
	Object *obj = new Object();
	delete obj;

	system("pause");
	return 0;
}
结果：

情况二：不使用new和delete，之间创建，不会自动执行析构。

main.cpp如下：

//main.cpp

#include <iostream>
#include <stdlib.h>

class Object
{
public:
	Object()
	{
		printf("Create Object\n");
	}
	~Object()
	{
		printf("Delete Object\n");
	}
};

int main(int argc, const char* argv[])
{
	Object obj;

	system("pause");
	return 0;
}
结果：



情况三：使用函数直接创建，函数运行完后自动析构。证明在适用范围中，若无效时自动析构。

main.cpp如下：

//main.cpp

#include <iostream>
#include <stdlib.h>

class Object
{
public:
	Object()
	{
		printf("Create Object\n");
	}
	~Object()
	{
		printf("Delete Object\n");
	}
};

void runObject()
{
	Object obj;
}

int main(int argc, const char* argv[])
{
	runObject();

	system("pause");
	return 0;
}

结果：


情况四：确认上情况证明。

main.cpp如下：

//main.cpp

#include <iostream>
#include <stdlib.h>

class Object
{
public:
	Object()
	{
		printf("Create Object\n");
	}
	~Object()
	{
		printf("Delete Object\n");
	}
};

void runObject()
{
	Object obj;
}

int main(int argc, const char* argv[])
{
	runObject();
	printf("end\n");

	system("pause");
	return 0;
}

结果：


情况五：证明使用是在有效范围内

main.cpp如下：

//main.cpp

#include <iostream>
#include <stdlib.h>

class Object
{
public:
	Object()
	{
		printf("Create Object\n");
	}
	~Object()
	{
		printf("Delete Object\n");
	}
};

void runObject()
{
	{
		Object obj;//局部变量，括号标识代码块范围
	}
}

int main(int argc, const char* argv[])
{
	runObject();
	printf("end\n");

	system("pause");
	return 0;
}

结果：


情况六：再清晰判断。

main.cpp如下：

//main.cpp

#include <iostream>
#include <stdlib.h>

class Object
{
public:
	Object()
	{
		printf("Create Object\n");
	}
	~Object()
	{
		printf("Delete Object\n");
	}
};

void runObject()
{
	Object obj();
	printf("runObject end\n");
}

int main(int argc, const char* argv[])
{
	runObject();
	printf("end\n");

	system("pause");
	return 0;
}

结果：



执行父类的构造方法

此工程由五个文件组成，分别是main.cpp, People.h, People.cpp, Man.h, Man.cpp。

main.cpp如下：

//main.cpp

#include <iostream>
#include <stdlib.h>
#include "Man.h"

int main(int agrc, const char* agrv[])
{
	Man *m = new Man(20);
	printf("age:%d\n", m->getAge());

	system("pause");
	return 0;
}
People.h如下： 
//People.h

class People
{
private:
	int age;
	int sex;

public:
	People();
	People(int age, int sex);
	~People();
	int getAge();
	int getSex();
	void sayHello();
};
People.cpp如下，public People中的public意思是从People继承过来的东西是公开的： 
//People.cpp

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

People::People(int age, int sex)
{
	this->age = age;
	this->sex = sex;
}

People::~People()
{

}

int People::getAge()
{
	return this->age;
}

int People::getSex()
{
	return this->sex;
}

void People::sayHello()
{
	printf("Hello!\n");
}
Man.h如下： 
//Man.h
#include "People.h"

class Man :public People
{
public:
	Man(int age);
	~Man();
};
Man.cpp如下，java 用super()执行： 
//Man.cpp
#include "Man.h"

Man::Man(int age):People(age, 1)
{

}

Man::~Man()
{

}
结果：


执行父类的方法

此工程由五个文件组成，分别是main.cpp, People.h, People.cpp, Man.h, Man.cpp。

main.cpp如下：

//main.cpp

#include <iostream>
#include <stdlib.h>
#include "Man.h"

int main(int argc, const char* argv[])
{
	Man *m = new Man(21);
	m->sayHello();

	system("pause");
	return 0;
}
People.h如下： 

//People.h

class People
{
private:
	int age;
	int sex;

public:
	People();
	People(int age, int sex);
	~People();
	int getAge();
	int getSex();
	void sayHello();
};

People.cpp如下：

//People.cpp

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

People::People()
{
	this->age = 10;
	this->sex = 1;
}
People::People(int age, int sex)
{
	this->age = age;
	this->sex = sex;
}

People::~People()
{

}

int People::getAge()
{
	return this->age;
}

int People::getSex()
{
	return this->sex;
}

void People::sayHello()
{
	printf("People say: Hello!\n");
}

Man.h如下：

//Man.h
#include "People.h"

class Man :public People
{
public:
	Man(int age);
	~Man();
	void sayHello();
};
Man.cpp如下： 

//Man.cpp
#include "Man.h"
#include <iostream>

Man::Man(int age):People(age, 1)
{

}
//java 用super()执行

Man::~Man()
{

}

void Man::sayHello()
{
	printf("Man say: Hello!\n");
}
结果：


如果将Man.cpp修改为如下，其他不变，则可以用父类的方法。

Man.cpp如下：

//Man.cpp
#include "Man.h"
#include <iostream>

Man::Man(int age):People(age, 1)
{

}
//java 用super()执行

Man::~Man()
{

}

void Man::sayHello()
{
	People::sayHello();
	printf("Man say: Hello!\n");
}
结果：

或者将main.cpp做一下修改，可以直接使用父类的方法。

main.cpp如下：

//main.cpp

#include <iostream>
#include <stdlib.h>
#include "Man.h"

int main(int argc, const char* argv[])
{
	Man *m = new Man(21);
	m->People::sayHello();

	system("pause");
	return 0;
}
结果：


实函数、虚函数、纯虚函数、函数重写

此工程由五个文件组成，分别是main.cpp, People.h, People.cpp, Man.h, Man.cpp。

main.cpp如下：

//main.cpp

#include <iostream>
#include <stdlib.h>
#include "Man.h"

int main(int argc, const char* argv[])
{
	People *p = new Man(20);
	p->sayHello();
	delete p;

	system("pause");
	return 0;
}
People.h如下： 

//People.h

class People
{
private:
	int age;
	int sex;

public:
	People();
	People(int age, int sex);
	~People();
	int getAge();
	int getSex();
	void sayHello();
};

People.cpp如下：

//People.cpp

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

People::People()
{
	this->age = 10;
	this->sex = 1;
}
People::People(int age, int sex)
{
	this->age = age;
	this->sex = sex;
}

People::~People()
{

}

int People::getAge()
{
	return this->age;
}

int People::getSex()
{
	return this->sex;
}

void People::sayHello()
{
	printf("People say: Hello!\n");
}

Man.h如下：

//Man.h
#include "People.h"

class Man :public People
{
public:
	Man(int age);
	~Man();
	void sayHello();
};
Man.cpp如下： 

//Man.cpp
#include "Man.h"
#include <iostream>

Man::Man(int age):People(age, 1)
{

}
//java 用super()执行

Man::~Man()
{

}

void Man::sayHello()
{
	People::sayHello();
	printf("Man say: Hello!\n");
}
结果：

若需使其自动定位，需要将函数定义为虚函数，将People.h和Man.h两个文件做一下修改。

People.h如下：

//People.h

class People
{
private:
	int age;
	int sex;

public:
	People();
	People(int age, int sex);
	~People();
	int getAge();
	int getSex();
	virtual void sayHello();
};

Man.h如下： 

//Man.h
#include "People.h"

class Man :public People
{
public:
	Man(int age);
	~Man();
	virtual void sayHello();
};

结果：


纯虚函数可以在其他类中定义

若需使其自动定位，需要将函数定义为虚函数，将main.cpp, People.h和Man.h三个文件做一下修改。

main.cpp如下：

//main.cpp

#include <iostream>
#include <stdlib.h>
#include "Man.h"

int main(int argc, const char* argv[])
{
	People *p = new Man(20);
	p->sayHello();
	p->eat();
	delete p;

	system("pause");
	return 0;
}
People.h如下： 

//People.h

class People
{
private:
	int age;
	int sex;

public:
	People();
	People(int age, int sex);
	~People();
	int getAge();
	int getSex();//实现了的实函数
	virtual void sayHello();//实现了的虚函数
	virtual void eat()=0;//定义一个抽象方法,=0是抽象方法标志，未被实现的函数
};
Man.h如下： 
//Man.h
#include "People.h"
#include <iostream>

class Man :public People
{
public:
	Man(int age);
	~Man();
	virtual void sayHello();
	virtual void eat()
	{
		printf("Man eat\n");
	}
};
结果：



纯虚类

就是类里面全部都是虚的，可与java里面的单一定义多重实现比较。


函数重载

此工程由一个main.cpp文件组成。

main.cpp如下：

//main.cpp

#include <iostream>
#include <stdlib.h>

class Hello
{
public:
	void sayHello()
	{
		printf("Hello everybody!\n");
	}
	void sayHello(char * name)
	{
		printf("Hello %s\n",name);
	}
};


int main(int argc, const char* argv[])
{
	Hello *h = new Hello();
	h->sayHello();//自动定位到第一个不带参的函数
	printf("-------------\n");
	h->sayHello("zhangsan");//自动定位到第二个带参函数
	printf("-------------\n");
	std::string name = "zhangsan";//这是因为上一个前者会出现不匹配的警告，而实际上直接写"xxx"是属于std的string型
	h->sayHello((char*)name.c_str());//这里要做引用c_str，并且还需强制转换成对应的char*类型

	system("pause");
	return 0;
}
结果：


直接用C++而不带C东西重写程序，可以如下。

main.cpp如下：

//main.cpp

#include <iostream>
#include <stdlib.h>
#include <string>

class Hello
{
public:
	void sayHello()
	{
		printf("Hello everybody!\n");
	}
	void sayHello(std::string name)
	{
		std::string str="Hello ";
		str += name;

		std::cout << str << "\n";//记得include <string>
	}
};


int main(int argc, const char* argv[])
{
	Hello *h = new Hello();
	h->sayHello("zhangsan");//自动定位到第二个带参函数

	system("pause");
	return 0;
}
结果：


运算符重载

此工程由一个main.cpp文件组成。

main.cpp如下：

//main.cpp

#include <iostream>
#include <stdlib.h>
#include <string>

class Point
{
private:
	int x, y;

public:
	Point(int x, int y)
	{
		this->x = x;
		this->y = y;
	}
	int getX()
	{
		return this->x;
	}
	int getY()
	{
		return this->y;
	}
	void add(Point p)
	{
		add(p.getX(), p.getY());
	}
	void add(int x, int y)
	{
		this->x += x;
		this->y += y;
	}
	void operator+=(Point p)//重载运算符
	{
		add(p);
	}
};


int main(int argc, const char* argv[])
{
	Point p(10,9);
	p.add(Point(12, 11));
	std::cout << p.getY() << "\n";
	printf("------------------\n");
	p += Point(13, 14);
	std::cout << p.getY() << "\n";
	printf("------------------\n");
	Point *pn = new Point(5, 6);//这里取用指针输入
	(*pn) += Point(2, 3);//*号为取其运算符
	std::cout << pn->getY() << "\n";

	system("pause");
	return 0;
}
结果：


伪函数

它不是一个真正的函数，它是一个类或者是一个结构体。此工程由一个main.cpp文件组成。

main.cpp如下：

//main.cpp

#include <iostream>
#include <stdlib.h>

void hello()
{
	printf("hello\n");
}

class Hello
{
public:
	void operator()()
	{
		printf("Hello!\n");
	}
};


int main(int argc, const char* argv[])
{
	hello();
	printf("----------------\n");
	Hello h;
	h();

	system("pause");
	return 0;
}
结果：


函数指针

此工程由一个main.cpp文件组成。

main.cpp如下：

//main.cpp

#include <iostream>
#include <stdlib.h>

class Object
{
public:
	void(Object::*sayHi)();
};

class Hello :public Object
{
public:
	Hello()
	{
		sayHi = (void (Object::*)())&Hello::HelloSayHi;
		(this->*sayHi)();
	}
	void HelloSayHi()
	{
		printf("Hello!\n");
	}
};

int main(int argc, const char* argv[])
{
	Hello *h = new Hello();
	delete h;

	system("pause");
	return 0;
}
结果：

写得简单一点。

main.cpp如下：

//main.cpp

#include <iostream>
#include <stdlib.h>

class Object;
typedef void(Object::*SayHi)();

class Object
{
public:
	SayHi sayHi;
};

class Hello :public Object
{
public:
	Hello()
	{
		sayHi = (SayHi)(&Hello::HelloSayHi);
		(this->*sayHi)();
	}
	void HelloSayHi()
	{
		printf("Hello!\n");
	}
};

int main(int argc, const char* argv[])
{
	Hello *h = new Hello();
	delete h;

	system("pause");
	return 0;
}
结果：

延时实例

main.cpp如下，但因使用平台非unix，所以没有实现延时，但用了线程的概念：

//main.cpp

#include <iostream>
#include <stdlib.h>
#include <thread>
//#include <unistd.h>//unix头文件

class Object;
typedef void(Object::*SayHi)();
typedef void(Object::*CallaterHandler)();

void threadFunc(Object *target, CallaterHandler handler, int delay)
{
	//sleep(delay);
	(target->*handler)();
}
void callater(Object *target, CallaterHandler handler, int delay)
{
	std::thread t(threadFunc, target, handler, delay);
	t.join();
}

#define CH(fp)(CallaterHandler)(&fp)

class Object
{
public:
	SayHi sayHi;
};

class Hello :public Object
{
public:
	Hello()
	{
//		sayHi = (SayHi)(&Hello::HelloSayHi);
//		(this->*sayHi)();
		callater(this, CH(Hello::HelloSayHi), 3);
	}
	void HelloSayHi()
	{
		printf("Hello!\n");
	}
};



int main(int argc, const char* argv[])
{
	Hello *h = new Hello();
	delete h;

	system("pause");
	return 0;
}
结果：


引用

此工程由一个main.cpp文件组成。

main.cpp如下：

//main.cpp

#include <iostream>
#include <stdlib.h>

class Point
{
private:
	int x, y;
public:
	Point(int x, int y)
	{
		this->x = x;
		this->y = y;
	}
	
	int getX()
	{
		return x;
	}

	int getY()
	{
		return y;
	}

	void add(Point &p)//&为引用
	{
		this->x += p.x;
		this->y += p.y;
	}
};

int main(int argc, const char* argv[])
{
	Point p(1,2);
	p.add(Point(2, 3));
	//printf("------------\n");
	Point p1(3,4);
	p.add(p1);

	system("pause");
	return 0;
}

友元类

将私有类公开给特定的类。此工程由一个main.cpp文件组成。需注意安全。

main.cpp如下：

//main.cpp

#include <iostream>
#include <stdlib.h>

class A
{
	friend class B;//指明B为A的友元类，会使类间耦合度过高
//private://不加修饰符则默认为私有
	int num;
public:
	A()
	{
		num = 10;
	}
};

class B :public A
{
public:
	B()
	{
		printf("%d\n",num);
	}
};

int main(int argc, const char* argv[])
{
	B b;

	system("pause");
	return 0;
}
结果：



倘若没有继承关系也是可以的。

main.cpp如下：

//main.cpp

#include <iostream>
#include <stdlib.h>

class A
{
	friend class B;//指明B为A的友元类，会使类间耦合度过高
//private://不加修饰符则默认为私有
	int num;
public:
	A()
	{
		num = 10;
	}
};

class B
{
public:
	B()
	{
		A a;
		printf("%d\n",a.num);
	}
};

int main(int argc, const char* argv[])
{
	B b;

	system("pause");
	return 0;
}
结果：



标准库容器的基本用法

下面以list容器为例。此工程由一个main.cpp文件组成。

main.cpp如下：

//main.cpp

#include <iostream>
#include <stdlib.h>
#include <list>
#include <string>

int main(int argc, const char* argv[])
{
	std::list<std::string>l;
	l.push_back("Hello");
	l.push_back("everybody");

	for (std::list<std::string>::iterator it = l.begin(); it != l.end(); it++)
	{
		std::cout << *it << "\n";
	}

	system("pause");
	return 0;
}
结果：


下面以mapt容器为例。此工程由一个main.cpp文件组成。

main.cpp如下：

//main.cpp

#include <iostream>
#include <stdlib.h>
#include <list>
#include <string>
#include <map>

int main(int argc, const char* argv[])
{
	std::list<std::string>l;
	l.push_back("Hello");
	l.push_back("everybody");

	for (std::list<std::string>::iterator it = l.begin(); it != l.end(); it++)
	{
		std::cout << *it << "\n";
	}

	std::map<std::string, std::string>m;
	m.insert(std::pair<std::string, std::string>("hello","Hello everybody"));
	m.insert(std::pair<std::string, std::string>("name", "zhangsan"));
	std::cout << m.at("hello") << "\n";

	system("pause");
	return 0;
}
结果：



再进一步使用重载中括号[]运算符。

main.cpp如下：

//main.cpp

#include <iostream>
#include <stdlib.h>
#include <list>
#include <string>
#include <map>

int main(int argc, const char* argv[])
{
	std::list<std::string>l;
	l.push_back("Hello");
	l.push_back("everybody");

	for (std::list<std::string>::iterator it = l.begin(); it != l.end(); it++)
	{
		std::cout << *it << "\n";
	}

	std::map<std::string, std::string>m;
	//m.insert(std::pair<std::string, std::string>("hello","Hello everybody"));
	//m.insert(std::pair<std::string, std::string>("name", "zhangsan"));
	//std::cout << m.at("hello") << "\n";
	m["name"] = "zhangsan";
	std::cout << m["name"] << "\n";

	system("pause");
	return 0;
}
结果：


字符串常用操作

此工程由一个main.cpp文件组成。

main.cpp如下：

//main.cpp

#include <iostream>
#include <stdlib.h>
#include <string>
#include <sstream>

using namespace std;

int main(int argc, const char* argv[])
{
	string str;
	str += "Hello ";
	str += "everybody";
	cout << str << "\n";

	printf("-------------\n");

	stringstream ss;
	ss << "Hello ";
	ss << 200;
	ss << " ";
	ss << 2.5;
	ss << "Hello!" << "you" << 1000;
	cout << "C++: "<<ss.str() << "\n";//访问到ss的C++字符串
	cout << "C: " << ss.str().c_str() << "\n";//访问到ss的C字符串

	system("pause");
	return 0;
}
结果：



文件操作

此工程由一个main.cpp文件组成。

main.cpp如下：

//main.cpp

#include <iostream>
#include <stdlib.h>
#include <fstream>
#include <sstream>

using namespace std;

int main(int argc, const char* argv[])
{
	//输出
	ofstream of("data.txt");
	of << "Hello everybody\n";
	of.close();


	//读入
	ifstream inf("data.txt");
	//读取第一个字符
	char c;//如果第一个是整形就是int
	inf >> c;
	std::cout << c << "\n";

	printf("-----------------\n");
	//读取全部
	stringbuf sb;
	inf >> &sb;
	std::cout << sb.str() << "\n";


	system("pause");
	return 0;
}



liaoqix
关注
专栏目录
C++中-＞怎么用
Kashing Zoe
03-02 6042
c++中->怎么用 对于C++中的类，结构体，共用体等具有成员函数或变量的数据类型(对象)时，如果存在对象a，而对象中有成员b，那么可以使用a.b的方式，使用对应的成员。如果存在变量p，指向a, 即p = &a, 这时可以用p->b来使用成员b。即，->操作符是用于带成员的类型对应指针上，用来提取成员变量或函数用的。p->b等同于(*p).b。对于任意的对象a，写作(&a)->b也是可以
c++中“-＞“符号是什么？
FG_future的博客
03-04 1万+
对于C++中的类，结构体，共用体等具有成员函数或变量的数据类型(对象)时，如果存在对象a，而对象中有成员b，那么可以使用a.b的方式，使用对应的成员。 如果存在变量p，指向a, 即p = &a, 这时可以用p->b来使用成员b。 即，->操作符是用于带成员的类型对应指针上，用来提取成员变量或函数用的。 p->b等同于(*p).b。 对于任意的对象a，写作(&a)->b也是可以的，不过很少有这样写。 ...
c++中 . 和 -＞ 的区别是什么？
红尘道，红尘练心
05-11 1412
主要用于访问类的成员，->主要用于类类型的指针访问的成员，而.运算符，主要用于类类型的对象访问类的成员。 举例 class A{ public: 　　int a; } A ma; A *p=ma; 指针p应用->来访问成员a，比如p->a,而ma应使用.来访问，比如ma.a区别就在这里，凡是指针就使用->,对象就使用.运算符。 如果定义了一个结构体数组。 struct student { 　　int age； 　　char name[100]; }; ..
C语言相关
lianyangfeng的专栏
06-18 371
1. 初始化。数组初始化，超过声明的元素个数会报错。少于时，多余的置0.char p[]="abcd"是数组，字符串是数组。2. C语言所有的函数调用是值传递，如果需要对象传递，需要用到指针。函数调用时，传递指针，只是把地址值赋值给形参。3. 指针与数组&取值运算符只能用于变量和数组元素。不能用于常量。int *p, a[10]时，p=a等效于p=a[0]，&a[i]等效于a+i。指针和数组的区别：指针是变量，p++合法，a++、a=p不合法。把数组名传给函数时，实际是传了数组第一个元素的地址。形参char
【C++学习笔记】一份详细的学习笔记，让你轻松掌握C++编程！
最新发布
06-04
【C++学习笔记】这份详尽的资源是为那些希望深入了解C++编程语言的人们精心准备的。C++是一种强大的、通用的编程语言，它的设计理念是面向对象，同时支持过程化编程，使得它在系统软件、应用软件、游戏开发、设备...
c++学习笔记
04-07
这份"C++学习笔记"涵盖了C++的基础概念、语法结构、面向对象编程以及可能的高级主题，旨在帮助初学者或者有经验的程序员巩固C++知识。 首先，C++是从C语言发展而来，它保留了C语言的效率，同时引入了类和对象的概念...
c++学习笔记.pdf
07-12
C++是一种静态类型、编译式、通用的编程语言，它支持过程化编程、面向对象编程和泛型编程。C++广泛应用于软件开发领域，包括操作...以上内容覆盖了C++语言中一些基础知识点，对于学习和理解C++编程具有重要的指导意义。
c++学习笔记精华版
08-27
### C++ 学习笔记精华版 #### 一、C++ 语言概述 **1、历史背景** - **C++ 的江湖地位** - Java、C、C++、Python、C# 是当前主流的编程语言之一，而 C++ 在这些语言中以其高效性和灵活性著称。 - **C++ 之父 ...
C++学习笔记
07-22
### C++基础知识与面试要点详解 #### 一、C与C++的区别 1. **文件扩展名**： - C语言通常使用`.c`作为源文件的扩展名。 - C++则通常使用`.cpp`作为源文件的扩展名。 2. **兼容性**： - C++完全兼容C语言，即...
C++ *p &a p->function() 之间的意义
阿姆斯特哩的博客
04-11 1372
困惑了好久的知识终于抽个时间总结一下 1.C++指针跟取地址之间的问题 指针的概念  本质上讲指针也是一种变量，普通的变量包含的是实际的数据，而指针变量包含的是内存中的一块地址，这块地址指向某个变量或者函数，指针就是地址。指针是一个指示器，它告诉程序在内存的哪块区域可以找到数据。 指针的内容  指针的内容包含4部分：指针的类型，指针所指向的类型，指针的值，指针本身所占有的内存区。在初
c++ 中.、->、::和:
m0_37290785的博客
01-08 278
转自：https://www.jianshu.com/p/0b7d67d39607 1、A.B 则 A 为对象或者结构体； 2、A->B 则A 为指针，-> 是成员提取，A->B 是提取 A 中的成员 B，A 只能是指向类、结构、联合的指针； 3、:: 是作用域运算符，A::B 表示作用域 A 中的名称 B，A 可以是名字空间、类、结构； 4、：一般用来表示继承； ...
c++里 p.print() 和 p->print() 有什么区别
syy0377的专栏
10-06 2367
当p是对象变量时，用p.print()调用成员函数print()；当p是对象变量的指针时用 p->print()调用成员函数print()。.前是变量，->前是指针，二者调用效果一样。
【C++】*P、P 、&P的区别
立志欲坚不欲锐，成功在久不在速度
09-20 9100
在刚开始接触到C++的时候一提到 指针P就会联想到一个箭头指向了一个地址，这是一个最为基础而且不算全面的理解，在后面的学习过程中总是能遇到类似指针的知识点，发现一个简单的指针包含的知识点很多。 下面就来介绍几个关于指针的知识点： 1. *P 、 P 、&P的区别： 刚刚接触到C++的时候对于这三个符号表示困惑，好像是指针的意思，但是分不清楚他们之间的...
->:间接引用运算符
weixin_30955617的博客
06-26 1667
->是一个整体，它是用于指向结构体、C++中的class等含有子数据的指针用来取子数据。换种说法，如果我们在C语言中定义了一个结构体，然后申明一个指针指向这个结构体，那么我们要用指针取出结构体中的数据，就要用到“->”.举个例子：struct Data{ int a,b,c;}; /*定义结构体*/struct Data * p;/*定义结构体指...
C++中关于int *p和 int* p的区别？
热门推荐
yangyongUestc的博客
06-23 2万+
根据C++Primer介绍： 对于int* p（这种写法合法，但是容易造成误导），其基本数据类型是int,后面的*其实是声明符。在一组公用的数据类型后面可以使用不同的声明符。例如： int i =1024, *p = &i, &r = i;    //i是一个int类型的数据，p是一个int型的指针，r是一个int型引用。 对于int *p，其和int* p 的含义一样，都表示int类型的指针
C\C++之(++p)-＞x 与 ++p-＞x的区别小记
小啊呜的博客
12-15 6296
C\C++学习小记 注意(++p)->x与++p->x的区别 叮嘟！这里是小啊呜的学习课程资料整理。好记性不如烂笔头，今天也是努力进步的一天。一起加油进阶吧！
多态的摸索之路( 甲 )
goldberg_cpp的专栏
06-28 3815
C++ 中的多态是极为复杂、难缠、庞大的，就像深海里的鲨鱼，凶猛而强大。那么到底如何才能游刃有余地驾于好这头潜伏在深海的远古猛兽呢？！别着急，咱们慢慢来，一点一点地摸索清它的性格和脾气，再控制就容易啦。例甲：#includeusing namespace std;class TradesPerson {public:       virtual void sayHi() { cout };class Tinker : public TradesPerson {public:       virtual vo
C++学习笔记：类与对象概述
"C++学习笔记，面向对象程序设计，C++之父比雅尼·斯特劳斯特鲁普，课程性质，课时安排，作业考核，C++的特点与历史，行业地位，应用领域" 在深入探讨类与对象的概念之前，我们先来理解C++的基本概述。C++是由比...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值