c++入门学习笔记
预处理-》编译-》链接-》运行
#include
//内置的头文件
// 预处理 编译 链接 运行
//预处理就是把头文件复制到cpp内
// pragma once 这个头文件如果被重复包含 只会被复制一次
// define Koohai int 定义一个变量
// ifdef 如果有定义
// if
预处理之后会形成一个 .i的文件 编译后会有个.obj的结尾
头文件的好处是 可以预编译 ，避免重复编译系统类库等。
汇编语言 .asm结尾 汇编器把asm 转变为obj
如果想两个cpp互相调用，而不用头文件， 就可以使用声明
通过头文件声明，只会引用对应的cpp
基本语法
int koo={10};
更加严格 写成小数会报错
debug模式下声明的变量没有赋值 他的地址就就是cccc 烫烫烫
release模式下 会随机给一些数
const 只可读
int* koohai=(int*)&koo;
*koohai=999;
unsigned int 无符号 没有负数
数据类型
char 1个字节 0-255
short 2个字节
unisgined char age;
int 4字节
longlong 8 byte
float 4byte float a{3.44344f} 不加f 是double
doublt aa{3.452542452}
printf("float:%.10f\n"
bool
转换
int main() {
int a{1};
unsigned int b{2};
std::cout << (a-b)<(a-b); c++写法
a=(char)(a-b) c写法
字符串和宽字符
char ca{'a'};
cout << ca << endl;
cout << (int)ca << endl;
cout << (char)97 << endl;
cout << (char)('a' + 1) << endl;
cout << (char)('a' + 2) << endl;
return 0;
万国码 wchar_t wws{L'答'}
字符组成字符串 数组或者指针
数组 char wlist[]="hellsdfae";
std::cout << wlist << std::endl;
std::cout <auto 关键词
auto b{"bb"};
cout<string
用string 标准库
char a="koohai";
string aa="koohai1 ";
十六个字节内会直接显示 大于16个是分配指针
auto str2=aa.c_str(); 转为c风格的字符串
字符串替换
string aa="koohai1koohai ";
while (true){
auto pos=aa.find("k");
if (pos==string::npos){
break;
}
aa.replace(pos,1,"*");
}
std::cout >>age;
//c++的方法
string first_name = "John";
string sec = "snow";
string res=first_name+sec;
cout << res << endl;
// c的方法
char a[]="hjtll0";
char b[]="woorld";
char* c=new char[strlen(a)+strlen(b)];
strcpy(c,a);
strcat(c,b);
cout<枚举
enum LogLevel{
INFO,
DEBUG,
ERROR
};
using namespace std;
void Log(string str,int level){
switch(level){
case INFO:
cout << "[INFO]: " << str << endl;
break;
case DEBUG:
cout << "[DEBUG]: " << str << endl;
break;
case ERROR:
cout << "[ERROR]: " << str << endl;
break;
}
}
int main() {
Log("Hello World",INFO);
Log("Hello err",ERROR);
Log("Hello debug",DEBUG);
}
默认是0开始
定义类的别名
d#include
#include
#include
#define myself unsigned int
typedef char mychar;
using myself3=unsigned int;
int main() {
myself aa = 10;
mychar b = 'a';
myself3 c = 100;
std::cout < 命名空间
namespace My{
string name = "My name is My";
}
string name= "My name is Out";
int main() {
cout << My::name << endl;
cout << name << endl;
return 0;
}
结构体
struct Pos{
int x=0;
int y=3;
string name="33";
};
int main() {
Pos p=Pos(5,5,"44");
cout << p.x << endl;
cout << p.y << endl;
}
内存中是连续的
不够4个字节 就填充cc
array
string urls[]{"google", "http://www.yahoo.comhoo.com", "http://www.facebook.com"};
cout << sizeof(string)<< endl;
cout < urls{"google", "http://www.yahoo.comhoo.com", "http://www.facebook.com"};
cout << urls.size() << endl;
cout << urls.at(1) << endl;
for(auto tmp:urls) {
cout << tmp << endl;
}
vcector
动态大小
vector v;
vector v{3,"Hello"};
// for(int i = 0; i < 10; i++) {
// v.push_back("Hello");
// };
v[0]="feafae";
v.insert(v.begin()+1, "Hellvvvo");
for (auto i: v){
cout << i << endl;
}
cout << v.size() << endl;
只能放单一类型 ，如果想既放str 又放int 用结构体
指针
void test(int* a){
*a=*a+1;
};
int main() {
int a=1;
int* ap=&a;
test(ap);
cout<引用
void test(int& a){
a+=1;
};
int main() {
int a=1;
int& ac=a;
a=3030;
cout<智能指针
unique_ptr不能复制 可以指向 堆内存 不用手动删除
shared_ptr 共享
函数指针
using prt = int(*)(int,int); //类型一样就可以
int Add(int a,int b){
return a+b;
}
int Sub(int a,int b){
return a-b;
}
int test(int a,int b,prt p){
return p(a,b);
}
int main(int argcount,char* args[]) {
cout<函数重载
阅读方便 参数不同 返回值不同
int Add(int a,int b){
return a+b;
}
int Add(int a){
return a;
}
int main(int argcount,char* args[]) {
cout<函数模板
template
T Add(T a,T b){
return a+b;
}
//template
//T Add(T a,M b){
// return a+b;
//}
//模板重载 强制类型转化 cout<(1.1,3.2)<(1,3)<(1.1,3.2)< decltype
//auto 无法推测const 的类型
static
static 修饰的函数 只可以当前文件用 无法被引用文件使用
inline 也可以处理重复定义的问题
和c混合 extern
extern "C" int Add(int a,int b) {
return a+b;
}
//c++里写一个c函数
clion打包dll库
http://www.chn520.cn/article_detail/1688736838056108
类成员函数
class Course{
public:
const char* anme;
int count;
void repr();
// void repr(Course& course){
// cout << course.anme <<"数量"<anme <<"数量"<count<< endl;
}
int main() {
Course couse;
couse.anme = "语文";
//couse.count = 10;
cout<anme = "数学";
cour1->count = 20;
cour1->repr();
return 0;
}
const
class Course{
public:
const char* anme;
mutable int count;
void repr();
int get_count() const{
count=3;
cout<< "get_count" << count<< endl;
return count;
}
// void repr(Course& course){
// cout << course.anme <<"数量"<anme <<"数量"<count<< endl;
}
void test(Course* couse){
cout << couse->anme << endl;
couse->count = 10;
}
//指针的操作就是点换成箭头
int main() {
Course couse;
couse.anme = "语文";
couse.count = 10;
couse.get_count();
return 0;
}
构造函数
class Course{
public:
char* name;
int count;
Course(int a ,char* n){
this->count = a;
this->name = n;
};
Course(int a):count(a){}; //简洁写法
Course()=default;
};
//作用域 另一种写法
//指针的操作就是点换成箭头
int main() {
Course c(33,"saf");
cout<< c.count << endl;
Course c3e(332);
cout<< c3e.count << endl;
Course c33();
return 0;
}
析构函数
class Course{
int* arr1;
int* arr2;
Course(){
// arr1=200;
arr1= new int(100);
arr2 = new int[10];
};
~Course(){
//析构函数 类似python的————del__
delete arr1;
delete[] arr2;
};
};
//作用域 另一种写法
静态成员变量
class Course{
public:
static int name;
int test;
};
int Course::name = 0;
//static 单独存放
int main() {
Course c1,c2,c3;
cout<静态函数
class Course{
public:
static int name;
void test(){
cout << "test" << endl;
}
static void test2(){
cout << "test2" <友元
class Teac{
string name;
void getName(){
cout << "name is " << name << endl;
}
//getTeacher
friend class Course;
};
};
class Course{
private:
int age=1;
void getAge(){
cout << "age is " << age << endl;
}
void getTeacher(Teac& t){
t.name="teacher";
t.getName();
}
friend void test(Course& c);
friend class Teac;
};
void test(Course& c){
c.age=333;
c.getAge();
Teac t;
c.getTeacher(t);
}
//友元打破类封装 访问private 不属于类成员函数
int main() {
Course c1;
test(c1);
return 0;
}
//Course& c 传递改变参数要通过地址 ，否则不影响原数据
嵌套类
class Course{
public:
const static int num=1;
void getNum(){
cout << num << endl;
}
class Teacher{
public:
int age=1;
void getAge(){
cout << num << endl;
cout << age << endl;
};
Teacher* getTeacher();
};
};
Course::Teacher* Course::Teacher::getTeacher (){
return this;
};
int main() {
Course::Teacher t1;
t1.getAge();
return 0;
}
运算符重载
重写大于 让两个类的属性来比较
类似__gt__ __lt__
class Human{
public:
int age;
bool operator>(Human &h){
return this->age > h.age;
}
Human(int age):age(age){}
};
int main() {
Human t1(33);
Human t2(20);
cout << (t1 > t2) << endl;
cout << (t1.operator>(t2)) << endl;
return 0;
}
=========
#include
#include
#include
#include
#include
#include
#include "library.h"
//typedef int(*prt)(int,int);
using namespace std;
class Human{
friend bool operator>(Human& h1,Human& h2);
public:
int age;
Human(int age):age(age){}
};
bool operator>(Human& h1,Human& h2){
return h1.age > h2.age;
}
int main() {
Human t1(33);
Human t2(20);
cout << (t1>t2) << endl;
return 0;
}
继承
class Human{
friend bool operator>(Human& h1,Human& h2);
public:
const char* name="Koohai";
void getName(){
cout << name << endl;
}
};
class H1 : public Human{
};
//private wufa jicheng
//protected 继承后可以访问，但是实例化后不可以访问
int main() {
H1 t1;
t1.name="feffe";
H1 t2;
t1.getName();
return 0;
}
匿名
int main() {
auto func=[]{
cout<<"Hello World"<更多内容请移步公众号一起学习，同篇笔记可能会有更新喔
