学习笔记

静态编译型语言（c / c++）先由编译器编译成机器语言，再运行，只需编译一次，下次执行无需编译，效率高。

动态解释型语言（python / Matlab / JavaScript）无需编译，每次运行时需要由解释器解释执行，效率低。

Java既属于编译型（先编译成class）又属于解释型（通过JVM解释运行）。

 

栈区：由编译器分配，一般存储局部变量和函数参数，结构和数据结构中的栈类似，空间大小固定，一般1M或2M，是一段连续的内存空间，效率较高。

堆区：由程序员分配，结构和数据结构中的链表类似，分配堆空间时遍历链表，找到一个空间大于申请空间的堆节点后，将该节点从链表删除，并将该节点多余空间放回链表中，因此在空间上是不连续的，效率较低。

全局（静态）区：存储全局变量和静态变量的区域。

文字常量区：存储文字常量的区域。

//main.cpp 
int a = 0; 全局初始化区 
char *p1; 全局未初始化区 
main() 
{ 
int b; 栈 
char s[] = "abc"; 栈 
char *p2; 栈 
char *p3 = "123456"; 123456/0在常量区，p3在栈上。 
static int c =0； 全局（静态）初始化区 
p1 = (char *)malloc(10); 
p2 = (char *)malloc(20); 
分配得来得10和20字节的区域就在堆区。 
strcpy(p1, "123456"); 123456/0放在常量区，编译器可能会将它与p3所指向的"123456"优化成一个地方。 
} 

 

指针

#include <iostream>
using namespace std;

int main() {
    int a = 10;
    int *p = &a;
    cout<<a<<" "<<&a<<" "<<p<<" "<<&p<<" "<<*p<<endl;
    a+=10;
    p+=10;
    cout<<a<<" "<<&a<<" "<<p<<" "<<&p<<" "<<*p<<endl;
    return 0;
}

//运行结果
10 0x7fff5fbff818 0x7fff5fbff818 0x7fff5fbff810 10
20 0x7fff5fbff818 0x7fff5fbff840 0x7fff5fbff810 1606416464

 

Object obj = new Object()

其中obj是变量，new Object()是类对象Object的一个实例，上面建立了一个变量到对象实例到一个连接，成为引用。简单来说，引用就是变量到对象实例的一个指针。

共享引用存在的问题

>>> list = [1,2,3]
>>> list1 = list
>>> list1[0] = 2
>>> list1
[2, 2, 3]
>>> list
[2, 2, 3]

上面先建立list到列表[1,2,3]的引用，然后令list1和list引用同一对象，这时修改了list1的同时，list也会被修改。

引用计数：当没有变量引用该对象时，其引用计数为0，将会被OS回收。

 

变量作用域取决于变量在哪里定义，如下为全局作用域和函数内作用域，函数内的变量定义对全局变量没影响。

#include <iostream>
using namespace std;

//全局变量
int a=100;
int b=200;

int cal() {
    
    //局部变量
    int a=10;
    int b=20;
    return a+b;
}

int main() {
    cout<<cal()<<" "<<a+b<<endl;
    return 0;
}

//输出结果
30 300

第一个pygame程序：

background_image_filename = 'background.jpg'
mouse_image_filename = 'mouse.png'

import pygame
from pygame.locals import *
from sys import exit

pygame.init()
screen = pygame.display.set_mode((640, 480))
pygame.display.set_caption("Hello World")

background = pygame.image.load(background_image_filename).convert()
mouse_cursor = pygame.image.load(mouse_image_filename).convert_alpha()

while True:
    for event in pygame.event.get():
        if event.type == QUIT:
            exit()

    screen.blit(background, (0,0))  #循环绘制背景，第二个参数是左上角坐标

    x,y = pygame.mouse.get_pos()
    x -= mouse_cursor.get_width() / 2
    y -= mouse_cursor.get_height() / 2

    screen.blit(mouse_cursor, (x,y))  #循环绘制光标

    pygame.display.update()

 pygame贪吃蛇代码：

import pygame, sys, random
from pygame.locals import *

FPS = 5

#window size
WINDOWWIDTH = 640
WINDOWHEIGHT = 480

#cell size and num
CELLSIZE = 20
CELLNUM_X = WINDOWWIDTH / CELLSIZE
CELLNUM_Y = WINDOWHEIGHT / CELLSIZE

#color
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
RED = (255, 0, 0)
GREEN = (0, 255, 0)
DARKGREEN = (0, 155, 0)
DARKGRAY = (40, 40, 40)
BGCOLOR = BLACK

#direction
UP = 'up'
DOWN = 'down'
LEFT = 'left'
RIGHT = 'right'

#snake head
HEAD = 0

def main():
    global FPSCLOCK, DISPLAYSURF, BASICFONT

    pygame.init()
    FPSCLOCK = pygame.time.Clock()
    DISPLAYSURF = pygame.display.set_mode((WINDOWWIDTH, WINDOWHEIGHT))
    BASICFONT = pygame.font.Font('freesansbold.ttf', 18)
    pygame.display.set_caption('G_Snake')

    showStartScreen()

    while True:
        runGame()
        showGameOverScreen()

def runGame():

    #pos of snake head
    startx = random.randint(5, CELLNUM_X - 5)
    starty = random.randint(5, CELLNUM_Y - 5)

    snake_body = [{'x' : startx, 'y' : starty}, {'x' : startx - 1, 'y' : starty}, {'x' : startx - 2, 'y' : starty}]

    direction = RIGHT
    apple = getRandomLocation()

    while True:
        for event in pygame.event.get():
            if event.type == QUIT:
                   terminate()
               elif event.type == KEYDOWN:
                   if (event.key == K_LEFT or event.key == K_a) and direction != RIGHT:
                       direction = LEFT
                   elif (event.key == K_RIGHT or event.key == K_d) and direction != LEFT:
                       direction = RIGHT
                   elif (event.key == K_UP or event.key == K_w) and direction != DOWN:
                       direction = UP
                   elif (event.key == K_DOWN or event.key == K_s) and direction != UP:
                       direction = DOWN
                   elif event.key == K_ESCAPE:
                       terminate()

           # eat apple
           if snake_body[HEAD]['x'] == apple['x'] and snake_body[HEAD]['y'] == apple['y']:
               apple = getRandomLocation()
           else:
               del snake_body[-1]
           
           #move
           if direction == UP:
               newHead = {'x' : snake_body[HEAD]['x'], 'y' : snake_body[HEAD]['y'] - 1}
           elif direction == DOWN:
               newHead = {'x' : snake_body[HEAD]['x'], 'y' : snake_body[HEAD]['y'] + 1}
           elif direction == LEFT:
               newHead = {'x' : snake_body[HEAD]['x'] - 1, 'y' : snake_body[HEAD]['y']}
           elif direction == RIGHT:
               newHead = {'x' : snake_body[HEAD]['x'] + 1, 'y' : snake_body[HEAD]['y']}
           snake_body.insert(0, newHead)

           # hit wall
           if snake_body[HEAD]['x'] == -1 or snake_body[HEAD]['x'] == CELLNUM_X or snake_body[HEAD]['y'] == -1 or snake_body[HEAD]['y'] == CELLNUM_Y:
               return

           # hit self body
           for body in snake_body[1:]:
               if(body['x'] == snake_body[HEAD]['x'] and body['y'] == snake_body[HEAD]['y']):
                   return

           DISPLAYSURF.fill(BGCOLOR)
           drawGrid()
           drawApple(apple)
           drawSnake(snake_body)
           drawScore(len(snake_body) - 3)
           pygame.display.update()
           FPSCLOCK.tick(FPS)

def drawPressKeyMsg():
     pressKeySurf = BASICFONT.render('Press any key to play.', True, DARKGRAY)
     pressKeyRect = pressKeySurf.get_rect()
     pressKeyRect.topleft = (WINDOWWIDTH - 200, WINDOWHEIGHT - 30)
     DISPLAYSURF.blit(pressKeySurf, pressKeyRect)

def checkForKeyPress():
    if len(pygame.event.get(QUIT)) > 0:
        terminate()
    keyUpEvents = pygame.event.get(KEYUP)
    if len(keyUpEvents) == 0:
        return None
    if keyUpEvents[0].key == K_ESCAPE:
        terminate()
    return keyUpEvents[0].key

def showStartScreen():
    titleFont = pygame.font.Font('freesansbold.ttf', 100)
    titleSurf1 = titleFont.render('Hello!', True, WHITE, DARKGREEN)
    titleSurf2 = titleFont.render('Snake!', True, GREEN)
    
    titleRect1 = titleSurf1.get_rect()
    titleRect2 = titleSurf2.get_rect()

    titleRect1.center = (WINDOWWIDTH / 2, WINDOWHEIGHT / 2 - 50)
    titleRect2.center = (WINDOWWIDTH / 2, WINDOWHEIGHT / 2 + 50)

    while True:
        DISPLAYSURF.fill(BGCOLOR)
        DISPLAYSURF.blit(titleSurf1, titleRect1)
        DISPLAYSURF.blit(titleSurf2, titleRect2)

        drawPressKeyMsg()

        if checkForKeyPress():
            pygame.event.get()
            return

        pygame.display.update()
        FPSCLOCK.tick(FPS)


def terminate():
    pygame.quit()
    sys.exit()

def getRandomLocation():
    return {'x' : random.randint(0, CELLNUM_X - 1), 'y' : random.randint(0, CELLNUM_Y - 1)}

def showGameOverScreen():
    gameOverFont = pygame.font.Font('freesansbold.ttf', 100)
    
    gameSurf = gameOverFont.render('GAME', True, WHITE)
    overSurf = gameOverFont.render('OVER', True, WHITE)
    
    gameRect = gameSurf.get_rect()
    overRect = overSurf.get_rect()

    gameRect.midtop = (WINDOWWIDTH / 2 , 100)
    overRect.midtop = (WINDOWWIDTH / 2, gameRect.height + 100)

    DISPLAYSURF.blit(gameSurf, gameRect)
    DISPLAYSURF.blit(overSurf, overRect)

    drawPressKeyMsg()
    pygame.display.update()
    pygame.time.wait(500)
    checkForKeyPress()

    while True:
        if checkForKeyPress():
            pygame.event.get()
            return


def drawScore(score):
    scoreSurf = BASICFONT.render('Score: %s' %(score), True, WHITE)
    scoreRect = scoreSurf.get_rect()
    scoreRect.topleft = (WINDOWWIDTH - 120, 10)
    DISPLAYSURF.blit(scoreSurf, scoreRect)

def drawSnake(snake_body):
    for body in snake_body:
        x = body['x'] * CELLSIZE
        y = body['y'] * CELLSIZE

        BodyRect = pygame.Rect(x, y, CELLSIZE, CELLSIZE)
        pygame.draw.rect(DISPLAYSURF, DARKGREEN, BodyRect)
        InnerBodyRect =  pygame.Rect(x + 4, y + 4, CELLSIZE - 8, CELLSIZE - 8)
        pygame.draw.rect(DISPLAYSURF, GREEN, InnerBodyRect)

def drawApple(apple):
    x = apple['x'] * CELLSIZE
    y = apple['y'] * CELLSIZE

    appleRect = pygame.Rect(x, y, CELLSIZE, CELLSIZE)
    pygame.draw.rect(DISPLAYSURF, RED, appleRect)

def drawGrid():
    for x in range(0, WINDOWWIDTH, CELLSIZE):
        pygame.draw.line(DISPLAYSURF, DARKGRAY, (x, 0), (x, WINDOWHEIGHT))
    for y in range(0, WINDOWHEIGHT, CELLSIZE):
        pygame.draw.line(DISPLAYSURF, DARKGRAY, (0, y), (WINDOWWIDTH, y))

if __name__ == '__main__':
    main()