基本C++-------------2018.6.25

最新推荐文章于 2024-04-01 17:33:25 发布

qq_28088259

最新推荐文章于 2024-04-01 17:33:25 发布

阅读量231

点赞数

分类专栏： C++

C++ 专栏收录该内容

21 篇文章 1 订阅

订阅专栏

从头再来一遍，注重细节，注重基本功。

c++是一种编译型语言。

可执行文件无法移植 源代码具有可移植性。

C++提供的标准库组件也是非常普通的C++代码。

C++是一种静态类型语言，编译器在处理任何实体时必须清楚它的类型。

Hello , world!

每一个C++程序中有且只有一个名为main()的全局函数，在执行程序时首先执行该函数，main()函数的非零返回值是程序返回给系统的，表示程序执行失败。

#include<iostream>

int main(){
	std::cout << "Hello, World!\n";
}

#include<iostream>指示编译器把iostream中涉及标准流I/O功能的声明包含进来。

std::cout标准输出流 “Hello, World!\n”字符串字面值 \n是转义字符换行 <<表示把第二个参数写入第一个参数。

std::指定名字cout所在的标准库名字空间。

基本上所有可执行代码都要放在函数中，并且被main()函数直接或间接地调用。

C++批量注释代码段取消注释代码段快捷键

1,先选中要注释的代码段
2，按住ctrl+k+c注释本段代码
3，按住ctrl+k+u取消注释本段代码

#include<iostream>
using namespace std;

double square(double x){
	return x*x;
}

void print_square(double x){
	cout << "the square of " << x << " is " << square(x) << "\n";
}

int main(){
	/*std::cout << "hello, world!\n";*/
	print_square(1.234);
}

需要注意的是：C++函数内部不能定义普通函数。

类型、变量和算术运算

声明是一条语句，负责为程序引入一个新的名字，并指定该命名实体的类型。

类型：决定了操作。

对象：存放某类型值的内存空间。

值：一组二进制位，具体的含义由其类型决定。

变量：是一个命名的对象。

基本类型：

bool-----true false

char-----'a' '9'

int-----1, 42

double----3.14 299793.0

类型的实际尺寸是依赖于实现的（即在不同的机器上可能不同），使用sizeof（）可以得到，比如sizeof(char)为1，这里的1表示1byte, 8 bit。

算术运算符比较运算符

在赋值运算和算术运算中，C++会在基本类型间进行类型转换。

初始化：

double d1 = 2.3;

double d1{2.3};

complex<double> z=1;

complex<double> z2{d1,d2}; //complex是类模板 复数实部和虚部是double

complex<double> z3={1,2}; //使用{}初始化的时候=是可选的

vector<int> v{1,2,3,4,5,6};

使用{}方式的好处在于---可以确保不会发生某些可能导致信息丢失的类型转换。

常量在声明时不能不进行初始化！

普通变量也最好进行初始化！

在定义一个变量时，若变量的类型可以由初始化器推断得到，则无需显式指定其类型

auto b = true; //bool

auto ch = 'x'; //char

auto i = 123; //int

auto d = 1.2; //double

auto 在泛型编程中会经常使用到！！！

常量

const: 我承诺不改变这个值

int var = 17; const double max3 = 1.4 * square(var); 是正确的，它是运行时求值。

constexpr: 在编译时求值 说明常量将数据存于只读内存中，提高性能。

而 int var = 17; constexpr double max3 = 1.4 * square(var); 是错误的，1.4 * square(var)不是常量表达式。

如果某个函数用在常量表达式中，则其必须定义成constexpr.

constexpr double square(double x){return x*x;}

注意：constexpr函数可以接受非常量实参，但此时其结果将不会是一个常量表达式。

编译时求值对程序的性能非常重要，同时不变性概念也是程序设计中要考虑的一个重要问题。

检验和循环

bool accept(){
	cout << "do you want to proceed(y or n)?\n";

	char answer = 0;
	cin >> answer;

	/*if (answer == 'y') return true;
	return false;*/

	switch (answer)
	{
	case 'y':
		return true;
	case 'n':
		return false;
	default:
		cout << "i will take that for a no\n";
		return false;
	}
}

C++提供了一套用于表示选择和循环的常规语句。

指针、数组和循环

声明数组 char v[6]; //含有6个字符的数组 ---v包含了6个元素v[0]到v[5]，数组的大小必须是常量表达式。

声明指针 char* p; //该指针指向字符指针变量中存放的是一个相应类型对象的地址（内存地址）。

char* p = &v[3]; //p指向v的第四个元素

char x = *p; //取出其中的内容

前置一元运算符*表示“.....的内容” 前置一元运算符&表示“......的地址”。

范围for语句：

void print(){
	int v[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; //列表初始化数组时无需指定其大小

	for (auto x : v)    //范围for语句
		cout << x << '\n';
}

如果我们不希望把v的值拷贝到x中，而只想令x指向某个元素，则

void print(){
	int v[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; //列表初始化数组时无需指定其大小

	for (auto& x : v)    //范围for语句
		cout << x << '\n';
}

一元后置运算符&表示“....”的引用。

引用类似于指针，唯一的区别是我们不需要使用前置运算符*访问引用的值。

要确保指针永远指向某一个对象

若没有对象可指的时候（比如列表的末尾），则可以令指针取值为nullptr("空指针")。所有指针类型都共享同一个nullptr。

在旧式代码中，0和NULL都可以用来替代nullptr的功能，但使用nullptr可以避免在整数(0或NULL)和指针(nullptr)之间发生混淆。

指针指向一个字符数组，该数组的结尾处是0.

注意：有很多时候，莫名其妙的错误是由于括号等的中英文输入的错误！！！！！！

int count_x(char* p, char x){  //统计P[]中出现x的次数
	if (p == nullptr) return 0;      //看指针是否是空
	int count = 0;
	for (; *p != 0;++p)   //判断是否达到字符数组尾部  *p != 0  尾部为0
		if (*p == x)
			++count;
	return count;
}

用户自定义类型

内置类型通过 基本类型、 const修饰符、 声明运算符构造，偏重 底层编程， 不能向程序员提供书写高级应用程序的上层特性。

故，c++扩充了这些内置类型和操作，引入了成熟的抽象机制。

C++抽象机制的目的是让程序员能够设计并实现他们自己的数据类型，称为用户自定义类型，比如类、枚举等。

主要在于用户自定义类型的设计、实现和使用。

结构

new运算符从一块名为 自由存储(free store){又称 动态内存(dynamic memory)}或 堆(heap)的区域分配内存。

访问struct成员有两种方法，一种用. , 一种用->。

struct Vector{    //构建一种新类型的第一步是把所需的元素组织成一种数据结构
	int sz;   //元素的个数
	double* elem;  //指向元素的指针
};

void vector_init(Vector& v, int s){     //初始化函数  引用方式
	v.elem = new double[s];     //分配一个数组，它包含s个double值 数组的头地址给了指针 
	v.sz = s;
}

double read_and_sum(int s){
	Vector v;
	vector_init(v, s);
	for (int i = 0; i != s; ++i)
		cin >> v.elem[i];       //v.elem可以看成是数组名

	double sum = 0;
	for (int i = 0; i != s; ++i){
		sum += v.elem[i];
	}
	return sum;
}

cout<<read_and_sum(4);

以Vector 和标准库中的vector为例，目的：

1.展现语言特性和程序设计技术。

2.帮助读者学会使用这些标准库组件。

学会了之后，尽量直接使用vector 、string等标准库组件。

类

上面的做法是将数据和操作进行了分割。

下面的做法是将类型的接口与其实现分离开来，称为类。一般方法是public，成员变量是private的。

外界只能调用public public方法可以调用private变量

在这里，Vector 对象是一个句柄，包含了 指向元素的指针以及 元素的个数。

即：一个固定大小的句柄指向位于别处（通过new分配的自由空间）的一组可变数量的数据。

class Vector{
public:
	Vector(int s) :elem{ new double[s] }, sz{ s }{} //初始化  使用了成员初始化器列表来初始化成员
	double& operator[](int i){ return elem[i]; }  //通过下标访问
	int size(){ return sz; }
private:
	double* elem;   //指向元素的指针
	int sz;    //元素的个数
};

double read_and_sum(int s){
	Vector v(s);     //调用接口  构造函数（用来构造类的对象的函数） 作用是初始化类的对象
	for (int i = 0; i != v.size(); ++i)
		cin >> v[i];

	double sum = 0;
	for (int i = 0; i != v.size(); ++i)
		sum += v[i];
	return sum;
}